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 Rust (1.15.1) (judge verdict: Wrong Answer)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::io::Read;
use std::io::{stdout, BufWriter, Write};
 
fn main() {
    let mut buf = String::new();
    
    let out = stdout();
    let mut out = BufWriter::new(out.lock());
 
    // 標準入力から全部bufに読み込む
    std::io::stdin().read_to_string(&mut buf).unwrap();
 
    // 読み込んだStringを空白で分解する
    let mut iter = buf.split_whitespace();
 
    
    let n: usize = iter.next().unwrap().parse().unwrap();
    
    let mut d : Vec<u32> = (0..n).map(|_| {
        iter.next().unwrap().parse().unwrap()
        }).collect();
    
    d.sort();
    
    println!("{:?}",d);
    
    if d[n/2 - 1] == d[n/2] {
        println!("0");
    }else {
        println!("{}", d[n/2] - d[n/2-1]);   
    }
    
    /*
    let mut buf = [0u32; 100001];
    
    let mut min = 100000;
    let mut max = 0;
    
    for i in 0..n {
        let item = d[i];
        //println!("item {}" ,item);
        buf[item as usize] += 1;
        if item < min {
            min = item;
        }
        else if item > max {
            max = item;
        }
    }
    
    let mut kcount = 0;
    let mut under = buf[min as usize];
    for i in min+1..max{
        if under * 2 == n as u32 {
            //println!("detect {}", i);
            kcount += 1;
        }
        if under * 2 > n as u32 {
            break;
        }
        
        // for next steps
        under += buf[i as usize];
    }

    //println!("{} {}", min, max);
    println!("{}", kcount);
    
    //println!("{:?}", buf);
    */
}