Problem:
Score : 400 points

Problem Statement

You are given N integers; the i-th of them is A_i.
Find the maximum possible sum of the absolute differences between the adjacent elements after arranging these integers in a row in any order you like.

Constraints

2 \leq N \leq 10^5

1 \leq A_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print the maximum possible sum of the absolute differences between the adjacent elements after arranging the given integers in a row in any order you like.

Sample Input 1

5
6
8
1
2
3

Sample Output 1

21

When the integers are arranged as 3,8,1,6,2, the sum of the absolute differences between the adjacent elements is |3 - 8| + |8 - 1| + |1 - 6| + |6 - 2| = 21. This is the maximum possible sum.

Sample Input 2

6
3
1
4
1
5
9

Sample Output 2

25

Sample Input 3

3
5
5
1

Sample Output 3

8

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

use std::io::*;
use std::str::FromStr;
//https://qiita.com/tubo28/items/e6076e9040da57368845
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: usize = read();
    let mut a: Vec<i64> = (0..n).map(|_| read()).collect();
    a.sort_by(|x,y| y.cmp(x));

    if n % 2 == 0 {
        let mut sum = 0;
        for i in 0..n/2 - 1{
            sum += a[i]*2;
        }
        sum += a[n/2-1];
        sum -= a[n/2];
        for i in n/2+1..n{
            sum -= a[i]*2;
        }
        println!("{}",sum);
    }else{
        let mut sum1 = 0;
        let mut sum2 = 0;
        for i in 0..n/2 - 1{
            sum1 += a[i]*2;
        }
        sum1 += a[n/2-1];
        sum1 += a[n/2];
        for i in n/2+1..n{
            sum1 -= a[i]*2;
        }

        for i in 0..n/2{
            sum2 += a[i]*2;
        }
        sum2 -= a[n/2];
        sum2 -= a[n/2+1];
        for i in n/2+2..n{
            sum2 -= a[i]*2;
        }
        println!("{}",std::cmp::max(sum1,sum2));

    }
}