Problem:
Score : 300 points

Problem Statement

Takahashi made N problems for competitive programming.
The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).

He is dividing the problems into two categories by choosing an integer K, as follows:

A problem with difficulty K or higher will be for ARCs.

A problem with difficulty lower than K will be for ABCs.

How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?

Problem Statement

2 \leq N \leq 10^5

N is an even number.

1 \leq d_i \leq 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
d_1 d_2 ... d_N

Output

Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.

Sample Input 1

6
9 1 4 4 6 7

Sample Output 1

2

If we choose K=5 or 6, Problem 1, 5, and 6 will be for ARCs, Problem 2, 3, and 4 will be for ABCs, and the objective is achieved.
Thus, the answer is 2.

Sample Input 2

8
9 1 14 5 5 4 4 14

Sample Output 2

0

There may be no choice of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.

Sample Input 3

14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1

Sample Output 3

42685

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
class Qsort
{
    public void Sort(int[] data, int start, int end)
    {
        if (end - start <= 1)  //要素数が1個以下。end=data.Lengthよりdata[end-1]が最後の要素であることに注意する。
        {
            return;
        }

        int p = data[start];                   //データの1番目をピボットする
        int i = start - 1;
        int j = end;

        while (true)
        {
            //データのstart(1番目、左端)から一つずつ調べて、p以上ならbreakしてiの値を保存。次に調べるのはi+1番目から
            for (i = i + 1; i < data.Length; i++)
            {
                if (p <= data[i])
                    break;
            }
            //データのend-1(最後、右端)から一つずつ調べて、p以下ならbreakしてjの値を保存。次に調べるのはj-1番目から
            for (j = j - 1; j > 0; j--)
            {
                if (p >= data[j])
                    break;
            }

            if (j < i)　　　　　//iとjの値が逆転したなら、whileから抜け出す。
                break;
            else        //そうでないなら、i番目とj番目を交代
            {
                int tmp = data[i];
                data[i] = data[j];
                data[j] = tmp;
            }
        }
        //i-1番目とi番目の間を境界にして分けて再帰。data[end-1]がデータの最後であるので前半(start～i-1)、後半(i～end-1)
        Sort(data, start, i);
        Sort(data, i, end);
    }
}

class a
{
    public static void Main()
    {
        int n = int.Parse(Console.ReadLine());
        int[] d = new int[n];
        string[] str = Console.ReadLine().Split(' ');
        for (int i = 0; i < n; i++)
        {
            d[i] = int.Parse(str[i]);
        }
        
        Qsort qsort = new Qsort();
        qsort.Sort(d, 0, d.Length);
        
        Console.WriteLine(d[n/2]-d[n/2-1]);
    }
}