Problem:
Score : 300 points

Problem Statement

When l is an odd number, the median of l numbers a_1, a_2, ..., a_l is the (\frac{l+1}{2})-th largest value among a_1, a_2, ..., a_l.

You are given N numbers X_1, X_2, ..., X_N, where N is an even number.
For each i = 1, 2, ..., N, let the median of X_1, X_2, ..., X_N excluding X_i, that is, the median of X_1, X_2, ..., X_{i-1}, X_{i+1}, ..., X_N be B_i.

Find B_i for each i = 1, 2, ..., N.

Constraints

2 \leq N \leq 200000

N is even.

1 \leq X_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
X_1 X_2 ... X_N

Output

Print N lines.
The i-th line should contain B_i.

Sample Input 1

4
2 4 4 3

Sample Output 1

4
3
3
4

Since the median of X_2, X_3, X_4 is 4, B_1 = 4.

Since the median of X_1, X_3, X_4 is 3, B_2 = 3.

Since the median of X_1, X_2, X_4 is 3, B_3 = 3.

Since the median of X_1, X_2, X_3 is 4, B_4 = 4.

Sample Input 2

2
1 2

Sample Output 2

2
1

Sample Input 3

6
5 5 4 4 3 3

Sample Output 3

4
4
4
4
4
4

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)


use std::io;
use std::str::FromStr;
use std::io::{stdout, Write, BufWriter};

macro_rules! get {
      ($t:ty) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.trim().parse::<$t>().unwrap()
          }
      };
      ($($t:ty),*) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              let mut iter = line.split_whitespace();
              (
                  $(iter.next().unwrap().parse::<$t>().unwrap(),)*
              )
          }
      };
      ($t:ty; $n:expr) => {
          (0..$n).map(|_|
              get!($t)
          ).collect::<Vec<_>>()
      };
      ($($t:ty),*; $n:expr) => {
          (0..$n).map(|_|
              get!($($t),*)
          ).collect::<Vec<_>>()
      };
      ($t:ty ;;) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.split_whitespace()
                  .map(|t| t.parse::<$t>().unwrap())
                  .collect::<Vec<_>>()
          }
      };
      ($t:ty ;; $n:expr) => {
          (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()
      };
}

#[test]
fn test_1(){
   let l = vec![2, 4, 4, 3];
   let expect = solve(4, 1, &l);
   assert_eq!(4, expect);
   let expect = solve(4, 2, &l);
   assert_eq!(3, expect);
   let expect = solve(4, 3, &l);
   assert_eq!(3, expect);
   let expect = solve(4, 4, &l);
   assert_eq!(4, expect);
}

#[test]
fn test_2(){
   let expect = solve(2, 1, &vec![1, 2]);
   assert_eq!(2, expect);
   let expect = solve(2, 2, &vec![1, 2]);
   assert_eq!(1, expect);
}


#[test]
fn test_3(){
   let expect = solve(6, 1, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);   
   let expect = solve(6, 2, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);
   let expect = solve(6, 3, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);
   let expect = solve(6, 4, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);
   let expect = solve(6, 5, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);
   let expect = solve(6, 6, &vec![5, 5, 4, 4, 3, 3]);
   assert_eq!(4, expect);
}

fn solve(n: u64, i:u64, xi:&Vec<u64>) -> u64{
    let mut ai = xi.clone();
    ai.remove((i-1) as usize);
    ai.sort();

    let index = n / 2 - 1;

    ai[index as usize]

}

fn main() {

    let n = get!(u64);
    
    let stdin = io::stdin();
    let mut buf = String::new();
    stdin.read_line(&mut buf).ok();

    let xi: Vec<u64> = buf.split_whitespace()
        .map(|n| u64::from_str(n).unwrap())
        .collect();

    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    
    for i in 0..n {
        let ans = solve(n, i+1, &xi);
        writeln!(out, "{}", ans).unwrap();   
    }
}