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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#define _CRT_SECURE_NO_WARNINGS
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<functional>
#include<iomanip>
#include<iostream>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<utility>
#include<vector>

#define ll long long
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)   FOR(i,0,n)
#define FORR(i,a,b) for(int i=(a);i>=(b);--i)
#define REPR(i,n)   FORR(i,n,0)

using namespace std;

int main() {
	/*int A, B, K;
	cin >> A >> B >> K;
	REP(i, K) {
		if (i % 2 == 0) {
			if (A % 2 == 1) {
				A -= 1;
				A /= 2;
				B += A;
			}
			else {
				A /= 2;
				B += A;
			}
		}
		else {
			if (B % 2 == 1) {
				B -= 1;
				B /= 2;
				A += B;
			}
			else {
				B /= 2;
				A += B;
			}
		}
	}

	cout << A << " " << B << endl;
	*/

	int N;
	vector<ll> A;
	ll x;
	cin >> N;
	REP(i, N) {
		cin >> x;
		A.push_back(x);
	}
	sort(A.begin(), A.end());

	int r = N / 2, l = r - 1;
	ll ans = 0;
	if (N % 2 == 0) {
		FOR(i, r + 1, N) {
			ans += 2 * A[i];
		}
		REP(i, l) {
			ans += -2 * A[i];
		}
		ans += A[r];
		ans -= A[l];
	}
	else {
		FOR(i, r + 2, N) {
			ans += 2 * A[i];
		}
		REP(i, l) {
			ans += -2 * A[i];
		}
		ans += max(-2 * A[l] + A[r] + A[r + 1], 2 * A[r + 1] - A[r] - A[l]);
	}

	cout << ans << endl;

	return 0;
}