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 (GCC 5.4.1) (judge verdict: Accepted)

#include <stdio.h>

void merge_list(
    long *list,
    long list_member_num,
    long *forward_list,
    long forward_list_member_num,
    long *backward_list,
    long backward_list_member_num
) {
    long i = 0, j = 0, forward_list_index = 0, backward_list_index = 0;

    /* Merge forward_list and backward_list to one list */
    for ( i = 0; i < list_member_num; i++ ) {
        if ( forward_list[forward_list_index] >
             backward_list[backward_list_index] ) {
            list[i] = backward_list[backward_list_index];
            if ( backward_list_index < backward_list_member_num - 1 ) {
                    backward_list_index++;
            }
            /* If all backward_list member were added, 
             * add all rest forward_list member to the end of list */
            else {
                for ( j = i + 1; j < list_member_num; j++ ) {
                    list[j] = forward_list[forward_list_index];
                    forward_list_index++;
                }
                break;
            }
        }
        else {
            list[i] = forward_list[forward_list_index];
            if ( forward_list_index < forward_list_member_num - 1 ) {
                    forward_list_index++;
            }
            /* If all forward_list member were added, 
             * add all rest backward_list member to the end of list */
            else {
                for ( j = i + 1; j < list_member_num; j++ ) {
                    list[j] = backward_list[backward_list_index];
                    backward_list_index++;
                }
                break;
            }
        }
    }

    return;
}

void merge_sort(
    long *list,
    long list_member_num
) {
    long i = 0;
    long middle_index = (list_member_num) / 2;
    long forward_list[middle_index];
    long backward_list[list_member_num - middle_index];

    /* If list size == 1, return */
    if ( list_member_num <= 1 ) {
        return;
    }

    /* Divide list into two lists */
    for ( i = 0; i < middle_index; i++ ) {
        forward_list[i] = list[i];
    }
    for ( i = middle_index; i < list_member_num; i++ ) {
        backward_list[i - middle_index] = list[i];
    }

    /* Sort each of the divided list */
    merge_sort(forward_list, middle_index);
    merge_sort(backward_list, list_member_num - middle_index);

    /* Merge the sorted lists */
    merge_list(list, list_member_num,
               forward_list, middle_index,
               backward_list, list_member_num - middle_index);

    return;
}

int main() {
    long n, i;
    scanf("%ld", &n);
    long d[n];
    for ( i = 0; i < n; i++ ) {
        scanf("%ld", &d[i]);
    }

    merge_sort(d, n);
    printf("%ld\n", d[n / 2] - d[n / 2 - 1]);

    return 0;
}