Problem:
Score : 400 points

Problem Statement

Let {\rm comb}(n,r) be the number of ways to choose r objects from among n objects, disregarding order.
From n non-negative integers a_1, a_2, ..., a_n, select two numbers a_i > a_j so that {\rm comb}(a_i,a_j) is maximized.
If there are multiple pairs that maximize the value, any of them is accepted.

Constraints

2 \leq n \leq 10^5

0 \leq a_i \leq 10^9

a_1,a_2,...,a_n are pairwise distinct.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

n
a_1 a_2 ... a_n

Output

Print a_i and a_j that you selected, with a space in between.

Sample Input 1

5
6 9 4 2 11

Sample Output 1

11 6

\rm{comb}(a_i,a_j) for each possible selection is as follows:

\rm{comb}(4,2)=6

\rm{comb}(6,2)=15

\rm{comb}(6,4)=15

\rm{comb}(9,2)=36

\rm{comb}(9,4)=126

\rm{comb}(9,6)=84

\rm{comb}(11,2)=55

\rm{comb}(11,4)=330

\rm{comb}(11,6)=462

\rm{comb}(11,9)=55

Thus, we should print 11 and 6.

Sample Input 2

2
100 0

Sample Output 2

100 0

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

pub trait BinarySearch<T> {
    fn lower_bound_by_key<B: Ord, F: FnMut(&T) -> B>(&self, x: &B, mut f: F) -> usize;
    fn lower_bound(&self, x: &T) -> usize;
}


impl<T: Ord + Clone> BinarySearch<T> for Vec<T> {
    fn lower_bound(&self, x: &T) -> usize {
        self.lower_bound_by_key(x, |y| y.clone())
    }

    fn lower_bound_by_key<B: Ord, F: FnMut(&T) -> B>(&self, x: &B, mut f: F) -> usize {
        let mut high = self.len();
        let mut low = 0;
        while low < high {
            let mid = (low + high) / 2;
            if  f(&self[mid]).lt(&x) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        low
    }
}

fn solve(mut aa: Vec<u32>) -> (u32, u32) {
    aa.sort();
    let n = aa[aa.len()-1];
    aa.pop();

    let mut m = aa.lower_bound(&(n/2));

    if m >= aa.len() {
        m = m-1;
    } else {
        let f = (n as f32) / 2f32;
        let d1 = (aa[m-1] as f32 - f).abs();
        let d2 = (aa[m] as f32 - f).abs();
        if d1 < d2 {
            m = m-1;
        }
    }
    (n, aa[m])
}

fn main() {
    read_line!();

    let aa = parse_vec!(u32);

    let (a,b) = solve(aa);

    println!("{} {}", a, b);
}

#[test]
fn solve_test() {
    assert_eq!(solve(vec![6,9,4,2,11]), (11, 6));
    assert_eq!(solve(vec![100, 0]), (100, 0));
}