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 (Clang 3.8.0) (judge verdict: Accepted)

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include <wchar.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? -(a) : (a))
#define ABSS(a, b) ((a) > (b) ? (a) - (b) : (b) - (a))

int compare_f(const void *a, const void *b) {
	return *((uint64_t *)a) < *((uint64_t *)b) ? -1 : 1;
}

static size_t comb(const size_t n, const size_t r) {
	size_t result = 1;

	for (size_t i = 0; i < r; i++) {
		result *= n - i;
		result /= i + 1;
	}

	return result;
}

static uint64_t gcd(uint64_t m, uint64_t n)
{
	uint64_t temp;

	while (m%n != 0) {
		temp = n;
		n = m % n;
		m = temp;
	}

	return n;
}

static uint64_t A[100000];
static uint64_t As[100000];

int main(void) {
	uint64_t N;

	scanf("%"PRIu64"\n", &N);
	for (uint64_t idx = 0; idx < N; idx++) {
		scanf("%"PRIu64, &A[idx]);
		if (idx < N - 1) {
			scanf("\n");
		}
	}

	qsort(A, (size_t)N, sizeof(uint64_t), compare_f);

	As[0] = A[N / 2 - 1];
	As[N - 1] = A[N / 2];

	for (uint64_t idx = 1; idx < N - 1; idx++) {
		if (idx % 2 == 0) {
			As[idx] = A[idx / 2 - 1];
		}
		else {
			As[idx] = A[N - 1 - idx / 2];
		}
	}

	uint64_t sumMax = 0;
	for (uint64_t idx = 0; idx < N - 1; idx++) {
		sumMax += ABSS(As[idx], As[idx + 1]);
	}

	{
		As[0] = A[(N - 1) / 2];
		As[N - 1] = A[(N + 1) / 2];

		for (uint64_t idx = 1; idx < N - 1; idx++) {
			if (idx % 2 == 0) {
				As[idx] = A[N - 1 - (idx - 1) / 2];
			}
			else {
				As[idx] = A[idx / 2];
			}
		}

		uint64_t sum = 0;
		for (uint64_t idx = 0; idx < N - 1; idx++) {
			sum += ABSS(As[idx], As[idx + 1]);
		}

		if (sumMax < sum) {
			sumMax = sum;
		}
	}

	printf("%"PRIu64, sumMax);

	return 0;
}