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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	_ "strings"
)

var sc = bufio.NewScanner(os.Stdin)

func nextLine() string {
	sc.Scan()
	return sc.Text()
}

func convertToInt(s []string, len int) []int {
	ret := make([]int, len)
	for i := 0; i < len; i++ {
		ret[i], _ = strconv.Atoi(s[i])
	}
	return ret
}

func main() {
	N, _ := strconv.Atoi(nextLine())
	a := make([]int, N)
	for i := 0; i < N; i++ {
		a[i], _ = strconv.Atoi(nextLine())
	}
	sort.Ints(a)
	a2 := a
	mid := N / 2
	b := make([]int, N)
	b[mid] = a[0]
	a = a[1:]
	maxTurn := true
	for i := 1; i <= N/2; i++ {
		if maxTurn {
			if mid-i >= 0 {
				b[mid-i] = a[len(a)-1]
				a = a[:len(a)-1]
			}
			if mid+i < N {
				b[mid+i] = a[len(a)-1]
				a = a[:len(a)-1]
			}
			maxTurn = false
		} else {
			if mid-i >= 0 {
				b[mid-i] = a[0]
				a = a[1:]
			}
			if mid+i < N {
				b[mid+i] = a[0]
				a = a[1:]
			}
			maxTurn = true
		}
	}

	sum1 := 0.0
	for i := 0; i < N-1; i++ {
		sum1 += math.Abs(float64(b[i] - b[i+1]))
	}

	//fmt.Println(a2)
	b2 := make([]int, N)
	b2[mid] = a2[len(a2) - 1]
	a2 = a2[:len(a2) - 1]
	minTurn := true
	for i := 1; i <= N /2; i++ {
		if minTurn {
			b2[mid-i] = a2[0]
			a2 = a2[1:]

			if mid + i < N {
				b2[mid+i] = a2[0]
				a2 = a2[1:]
			}
			minTurn = false
		} else {
			b2[mid-i] = a2[len(a2)-1]
			a2 = a2[:len(a2)-1]
			if mid + i < N {
				b2[mid+i] = a2[len(a2)-1]
				a2=a2[:len(a2)-1]
			}
			minTurn = true
		}
	}

	sum2 := 0.0
	for i := 0; i < N-1; i++ {
		sum2 += math.Abs(float64(b2[i] - b2[i+1]))
	}

	if sum1 > sum2 {
		fmt.Println(sum1)
	} else {
		fmt.Println(sum2)
	}

}