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 Scala (2.11.7) (judge verdict: Wrong Answer)


object Main extends App {

  import scala.io.StdIn._
  import scala.math._

  val ballCount = readLine.trim.toInt
  val series = readLine.trim.split(' ').map{_.toLong}.sorted
  var stack: List[Ball] = List(new Ball(series.head, 1))
  for (i ← 1 until series.length){
    println(
      stack.mkString(",")
    )
    if (stack.head.number == series(i)){
      stack.head.count += 1
    }else {
      stack ::= new Ball(series(i), 1)
    }
  }
  val balls = stack.toArray.reverse
  val exp = Array.tabulate(33){_ ⇒ 1L}
  for (i ← 1 until exp.length){
    exp(i) = exp(i - 1) * 2
  }
  var sum: Int = 0
  for (i ← balls.indices.reverse){
    for (e ← exp){
      if (e < balls(i).number * 2 && e > balls(i).number) lowerBound(balls, e - balls(i).number) match {
        case r if balls(r).number + balls(i).number == e && balls(r).count >= 1 ⇒
          val min = math.min(balls(r).count, balls(i).count)
          sum += min
          balls(r).count -= min
        case _ ⇒
      }else if (e == balls(i).number * 2 && balls(i).count >= 2) {
        sum += balls(i).count / 2
      }
    }
  }

  println(sum)
  def lowerBound(balls: Array[Ball], target: Long): Int = {
    var left = 0
    var right = balls.length - 1
    while (left < right){
      val mid = (left + right) / 2
      if (balls(mid).number < target){
        left = mid + 1
      }else {// target <= balls(mid).number
        right = mid
      }
    }
    right
  }
  def upperBound(balls: Array[Ball], target: Long): Int = {
    var left = 0
    var right = balls.length - 1
    while (left < right){
      val mid = (left + right) / 2
      if (balls(mid).number <= target){
        left = mid + 1
      }else {// target < balls(mid).number
        right = mid
      }
    }
    right
  }

  class Ball(val number: Long, var count: Int) {
    override def toString: String = s"Ball($number, $count)"
  }
  implicit class Extenion[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}
/*

 */