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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	var n int
	scanner.Scan()
	fmt.Sscanf(scanner.Text(), "%d", &n)

	as := make([]int, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		fmt.Sscanf(scanner.Text(), "%d", &as[i])
	}
	sort.Sort(sort.IntSlice(as))
	m := as[len(as)-1]
	as = as[0 : len(as)-1]
	index := sort.SearchInts(as, m/2)

	_ = index
	/*
		if index == len(as) {
			fmt.Println(m, as[index-1])
			return
		}
		if index == 0 {
			fmt.Println(m, as[index])
			return
		}
		if combination(m, as[index]) > combination(m, as[index-1]) {
			fmt.Println(m, as[index])
		} else {
			fmt.Println(m, as[index-1])
		}
	*/
}

func max(ns ...int) int {
	ret := math.MinInt64
	for _, n := range ns {
		if n > ret {
			ret = n
		}
	}
	return ret
}

func combination(a, b int) int {
	if a-b < b {
		return combination(a, a-b)
	}
	prod := 1
	for i := 0; i < b; i++ {
		prod = prod * (a - i) //% MOD
	}
	f := factorial(b)
	//return prod * inverse(f) % MOD
	return prod / f
}

func power(a, pow int) int {
	if pow == 1 {
		return a
	} else if pow%2 == 0 {
		rt := power(a, pow/2)
		return rt * rt //% MOD
	} else {
		return a * power(a, pow-1) //% MOD
	}
}

func factorial(n int) int {
	ret := 1
	for n >= 1 {
		ret = ret * n
		n--
	}
	return ret
}