Problem:
Score : 300 points

Problem Statement

There are N people living on a number line.

The i-th person lives at coordinate X_i.

You are going to hold a meeting that all N people have to attend.

The meeting can be held at any integer coordinate. If you choose to hold the meeting at coordinate P, the i-th person will spend (X_i - P)^2 points of stamina to attend the meeting.

Find the minimum total points of stamina the N people have to spend.

Constraints

All values in input are integers.

1 \leq N \leq 100

1 \leq X_i \leq 100

Input

Input is given from Standard Input in the following format:

N
X_1 X_2 ... X_N

Output

Print the minimum total stamina the N people have to spend.

Sample Input 1

2
1 4

Sample Output 1

5

Assume the meeting is held at coordinate 2. In this case, the first person will spend (1 - 2)^2 points of stamina, and the second person will spend (4 - 2)^2 = 4 points of stamina, for a total of 5 points of stamina. This is the minimum total stamina that the 2 people have to spend.

Note that you can hold the meeting only at an integer coordinate.

Sample Input 2

7
14 14 2 13 56 2 37

Sample Output 2

2354

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules! read_i {
    ( $($args:expr ; $t:ty),* ) => {{
        let line = read_string();
        let mut line = line.split_whitespace();
        $(
            let tmp:$t = line.next().unwrap().parse().unwrap();
            *$args = tmp;
        )*
    }};
}
pub fn read_string() -> String{
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf).unwrap();
    buf.trim().to_owned().to_string()
}
pub fn read_vec_i(n:usize) -> Vec<i32> {
    let mut v:Vec<i32> = Vec::new();
    let line = read_string();
    let mut line = line.split_whitespace();
    for _i in 0..n {
        let x = line.next().unwrap().parse().unwrap();
        v.push(x);
    }
    v
}
pub fn read_vec2_i(n:usize, m:usize) -> Vec<Vec<i32>> {
    let mut v:Vec<Vec<i32>> = Vec::new();
    for i in 0..n {
        let v1:Vec<i32> = Vec::new();
        v.push(v1);
        let line = read_string();
        println!("> {}", line);
        let mut line = line.split_whitespace();
        for _j in 0..m {
            let x = line.next().unwrap().parse().unwrap();
            v[i].push(x);
        }
    }
    v
}
fn main(){
    let mut n = 0;
    read_i!(&mut n;usize);
    let x = read_vec_i(n);

    let mut ans = 99999999;
    for i in 0..100 {
        let mut sum = 0;
        for j in &x {
            sum += (j - i).pow(2);
        }
        if sum < ans {
            ans = sum;
        }
    }
    println!("{}", ans);
}