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 Kotlin (1.0.0) (judge verdict: Wrong Answer)


fun main(args:Array<String>) {
    val n = readLine()!!.toInt()
    val numberList = (1..n).map { readLine()!!.toLong() }.sorted().toMutableList()
    if( n%2 == 0) {
        val list = mutableListOf<Long>()
        var flag = true
        while (list.size < n) {
            if(flag) {
                list.add(0, numberList.first())
                list.add(numberList.last())
            } else {
                list.add(0, numberList.last())
                list.add(numberList.first())
            }
            numberList.removeAt(0)
            numberList.removeAt(numberList.lastIndex)
            flag = !flag
        }
        println(getScore(list))
    } else {
        val source = listOf(numberList.toMutableList(), numberList.reversed().toMutableList())
        var flag = true
        val lists = listOf(mutableListOf(source[0].first()), mutableListOf(source[1].first()))
        source[0].removeAt(0)
        source[1].removeAt(0)
        while (source[0].size > 0) {
            if(flag) {
                for(i in (0..1)) {
                    lists[i].add(0, source[i].last())
                    source[i].removeAt(source[i].lastIndex)
                    lists[i].add(source[i].last())
                    source[i].removeAt(source[i].lastIndex)
                }
            } else {
                for(i in (0..1)) {
                    lists[i].add(0, source[i].first())
                    source[i].removeAt(0)
                    lists[i].add(source[i].first())
                    source[i].removeAt(0)
                }
            }
        }

        println(lists.map { getScore(it) }.max())
    }
}

fun getScore(num:List<Long>):Long {
    var ans = 0L
    for(i in (1 until num.size)) {
        ans += Math.abs(num[i-1] - num[i])
    }
    return ans
}