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# (Mono 4.6.2.0) (judge verdict: Accepted)

using CompLib.Util;
using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{

    public void Solve()
    {
        var sc = new Scanner();
        int n = sc.NextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++)
        {
            a[i] = sc.NextInt();
        }
        Array.Sort(a, (x, y) => -x.CompareTo(y));
        if (n % 2 == 0)
        {
            long b = 0;
            for (int i = 0; i < n / 2; i++)
            {
                b += a[i];
                if (i < n / 2 - 1)
                {
                    b += a[i];
                }
            }

            for (int i = n / 2; i < n; i++)
            {
                b -= a[i];
                if (i > n / 2)
                {
                    b -= a[i];
                }
            }

            Console.WriteLine(b);
        }
        else
        {
            long b = 0;
            for (int i = 0; i < n / 2; i++)
            {
                b += a[i];
                b += a[i];
            }

            for (int i = n / 2; i < n; i++)
            {
                b -= a[i];
                if (i > n / 2 + 1)
                {
                    b -= a[i];
                }
            }

            long c = 0;
            for (int i = 0; i < n / 2 + 1; i++)
            {
                c += a[i];
                if (i < n / 2-1)
                {
                    c += a[i];
                }
            }

            for (int i = n / 2 + 1; i < n; i++)
            {
                c -= a[i];
                c -= a[i];
            }

            Console.WriteLine(Math.Max(b, c));
        }
    }

    public static void Main(string[] args) => new Program().Solve();
}

namespace CompLib.Util
{
    using System;
    using System.Linq;
    class Scanner
    {
        private int _index;
        private string[] _line;
        const char separator = ' ';

        public Scanner()
        {
            _index = 0;
            _line = new string[0];
        }

        public string Next()
        {
            while (_index >= _line.Length)
            {
                _line = Console.ReadLine().Split(separator);
                _index = 0;
            }
            return _line[_index++];
        }
        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            _line = Console.ReadLine().Split(separator);
            _index = _line.Length;
            return _line;
        }
        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
    }
}