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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Control.Monad
import Data.List
import Data.Maybe
import qualified Data.ByteString.Char8 as B

main = do
    n<-readLn::IO Int
    as<-replicateM n $ fst.fromJust.B.readInt <$> B.getLine ::IO[Int]
    print $ max (sol n as) (sol2 n as)
--
sol 2 [a,b] = abs(a-b)
sol n as = re (n-1) [a] [] u v
    where
        (a:u) = sort as
        v = reverse u

sol2 2 [a,b] = abs(a-b)
sol2 n as = re (n-1) [a] [] u v
    where
        (a:u) = sortBy (flip compare) as
        v = reverse u

re 0 lv rv _ _ = cal 0 (lv++reverse rv)
re 1 lv@(l:_) rv@(r:_) _ (a:_) = cal (max (abs(l-a)) (abs(r-a))) (lv++reverse rv)
re n [l] [] u (a:b:v) = re2 (n-2) [a,l] [b] u v
re n lv@(l:_) rv@(r:_) u (a:b:v)
    | (abs(l-a)+abs(r-b))>(abs(l-b)+abs(r-a)) = re2 (n-2) (a:lv) (b:rv) u v
    | otherwise = re2 (n-2) (b:lv) (a:rv) u v

re2 0 lv rv _ _ = cal 0 (lv++reverse rv)
re2 1 lv@(l:_) rv@(r:_) (a:_) _ = cal (max (abs(l-a)) (abs(r-a))) (lv++reverse rv)
re2 n lv@(l:_) rv@(r:_) (a:b:u) v
    | (abs(l-a)+abs(r-b))>(abs(l-b)+abs(r-a)) = re (n-2) (a:lv) (b:rv) u v
    | otherwise = re (n-2) (b:lv) (a:rv) u v

cal s [_] = s
cal s (a:b:v) = cal (s+abs(a-b)) (b:v)