Problem:
Score : 600 points

Problem Statement

Takahashi has N balls with positive integers written on them. The integer written on the i-th ball is A_i.
He would like to form some number of pairs such that the sum of the integers written on each pair of balls is a power of 2.
Note that a ball cannot belong to multiple pairs.
Find the maximum possible number of pairs that can be formed.

Here, a positive integer is said to be a power of 2 when it can be written as 2^t using some non-negative integer t.

Constraints

1 \leq N \leq 2\times 10^5

1 \leq A_i \leq 10^9

A_i is an integer.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible number of pairs such that the sum of the integers written on each pair of balls is a power of 2.

Sample Input 1

3
1 2 3

Sample Output 1

1

We can form one pair whose sum of the written numbers is 4 by pairing the first and third balls.
Note that we cannot pair the second ball with itself.

Sample Input 2

5
3 11 14 5 13

Sample Output 2

2

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

use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;
use std::iter::FromIterator;

fn main() {
    let cin = stdin();
    let mut scan = Scanner::new(cin.lock());
    let n = scan.read::<usize>();
    let a = scan.readn::<i64>(n);
    let mut cnt = Counter::new();
    for c in a {
        cnt[Rev(c)] += 1;
    }
    let mut ret = 0i64;
    while let Some((&Rev(c), &_x)) = cnt.iter().next() {
        cnt.dec(Rev(c));
        let mut p = 1;
        while p <= c {
            p *= 2;
        }
        let opp = p - c;
        if cnt.contains_key(&Rev(opp)) {
            ret += 1;
            cnt.dec(Rev(opp));
        }
    }
    println!("{}", ret);
}

#[derive(Eq, PartialEq, Clone, Debug, Hash)]
pub struct Rev<T>(pub T);

impl<T: PartialOrd> PartialOrd for Rev<T> {
    fn partial_cmp(&self, other: &Rev<T>) -> Option<std::cmp::Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl<T: Ord> Ord for Rev<T> {
    fn cmp(&self, other: &Rev<T>) -> std::cmp::Ordering {
        other.0.cmp(&self.0)
    }
}

// region counter

use std::collections::BTreeMap;
use std::hash::Hash;
use std::ops::*;

#[derive(Clone, Debug)]
struct Counter<K: Eq + Hash + Ord> {
    cnt: BTreeMap<K, i64>,
    d: i64,
}

#[allow(dead_code)]
impl <K: Eq + Hash + Ord + Clone> Counter<K> {
    fn new() -> Counter<K> {
        Counter {cnt: BTreeMap::new(), d: 0}
    }
    fn dec(&mut self, key: K) {
        self[key.clone()] -= 1;
        if self[key.clone()] == 0 {
            self.remove(&key);
        }
    }
}

#[allow(dead_code)]
impl <K: Eq + Hash + Ord> Deref for Counter<K> {
    type Target = BTreeMap<K, i64>;
    fn deref(&self) -> &Self::Target {
        &self.cnt
    }
}

#[allow(dead_code)]
impl <K: Eq + Hash + Ord> DerefMut for Counter<K> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.cnt
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash + Ord> Index<K> for Counter<K> {
    type Output = i64;

    fn index(&self, index: K) -> &Self::Output {
        self.cnt.get(&index).unwrap_or(&self.d)
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash + Ord + Clone> IndexMut<K> for Counter<K> {
    fn index_mut(&mut self, index: K) -> &mut i64 {
        if !self.cnt.contains_key(&index) {
            self.cnt.insert(index.clone(), self.d);
        }
        self.cnt.get_mut(&index).unwrap()
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash + Ord> std::iter::FromIterator<K> for Counter<K> {
    fn from_iter<T: IntoIterator<Item=K>>(iter: T) -> Self {
        let mut cnt = BTreeMap::new();
        for i in iter {
            *cnt.entry(i).or_insert(0) += 1;
        }
        Counter {cnt: cnt, d: 0}
    }
}
// endregion

// region template
#[allow(dead_code)]
fn iu(i: i64) -> usize { i as usize }

#[allow(dead_code)]
fn ui(i: usize) -> i64 { i as i64 }

#[allow(dead_code, deprecated)]
fn join<T: std::fmt::Display>(slice: &[T], sep: &str) -> String {
    let strings = slice.iter().map(|t| format!("{}", t)).collect::<Vec<_>>();
    strings.connect(sep)
}

#[allow(dead_code)]
fn arr<'a, S, T>(n: usize, mut f: S) -> Vec<T> where S: FnMut(usize) -> T + 'a {
    (0..n).map(|i| f(i)).collect::<Vec<T>>()
}

#[allow(dead_code)]
fn alt<S, T>(v: Vec<S>) -> T where T: FromIterator<S> {
    v.into_iter().collect::<T>()
}

#[allow(dead_code)]
fn dup<S, T>(v: &[S]) -> T where T: FromIterator<S>, S: Clone {
    v.iter().cloned().collect::<T>()
}

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

#[allow(dead_code)]
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }

    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }

    fn readn<T: FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect()
    }

    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
// endregion