Number of pairs whose sum is a power of 2 | Set 2

Given an array arr[] consisting of N integers, the task is to count the maximum number of pairs (arr[i], arr[j]) such that arr[i] + arr[j] is a power of 2.

Examples:

Input: arr[] = {1, -1, 2, 3}
Output: 5
Explanation: (1, 1), (2, 2), (1, 3), (-1, 3), (-1, 2) are the valid pairs whose sum is power of 2.

Input: arr[] = {1, 1, 1}
Output: 6

Naive Approach: The simplest approach to solve the problem is to generate all possible pairs from a given array and for each pair, check if the sum of the pair is a power of 2 or not. 

C++

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// c++ code to implement the above idea
#include <bits/stdc++.h>
using namespace std;

// Function to count all pairs
// whose sum is a power of two
int countPair(vector<int>& arr, int k)
{

    int count = 0;

    for (int i = 0; i < arr.size(); ++i) {
        int sum = 0;
        for (int j = i; j < arr.size(); j++) {
            int sum = arr[i] + arr[j];
            int t = log2(sum);
            if (pow(2, t) == sum) {
                count++;
            }
        }
    }

    // Return count
    return count;
}

// Driver Code
int main()
{
    vector<int> arr = { 1, 8, 2, 10, 6 };
    int n = arr.size();
    cout << countPair(arr, n) << endl;

    return 0;
}

Java

/*package whatever //do not write package name here */

import java.util.*;

class GFG {

  // Function to count all pairs
// whose sum is a power of two
static int countPair(int[] arr, int k)
{

    int count = 0;

    for (int i = 0; i < arr.length; ++i) {
        for (int j = i; j < arr.length; j++) {
            int sum = arr[i] + arr[j];
            int t = (int)(Math.log(sum) / Math.log(2));
            if (Math.pow(2, t) == sum) {
                count++;
            }
        }
    }

    // Return count
    return count;
}

    public static void main (String[] args) {
    int[] arr = { 1, 8, 2, 10, 6 };
    int n = arr.length;
      System.out.println(countPair(arr, n));
    }
}

Python3

# Python Program to implement
# the above approach
import math

# Function to count all pairs
# whose sum is a power of two
def countPair(arr, k):
    count = 0;

    for i in range(0, len(arr)):
        ans = 0;
        for j in range(i, len(arr)):
            ans = arr[i] + arr[j];
            t = math.floor(math.log2(ans));
            if (math.pow(2, t) == ans):
                count += 1;

    # Return count
    return count;

# Driver Code
arr = [ 1, 8, 2, 10, 6 ];
n = len(arr);
print(countPair(arr, n))

# This code is contributed by ritaagarwal.

C#

// C# code for the above approach
using System;

class GFG
{
  // Function to count all pairs
  // whose sum is a power of two
  static int CountPair(int[] arr)
  {
    int count = 0;

    for (int i = 0; i < arr.Length; ++i)
    {
      for (int j = i; j < arr.Length; j++)
      {
        int sum = arr[i] + arr[j];
        int t = (int)(Math.Log(sum) / Math.Log(2));
        if (Math.Pow(2, t) == sum)
        {
          count++;
        }
      }
    }

    // Return count
    return count;
  }

  public static void Main (string[] args)
  {
    int[] arr = { 1, 8, 2, 10, 6 };
    int n = arr.Length;
    Console.WriteLine(CountPair(arr));
  }
}

// This code is contributed by lokeshpotta20.

Javascript

// Javascript Program to implement
// the above approach

// Function to count all pairs
// whose sum is a power of two
function countPair(arr, k)
{

    let count = 0;

    for (let i = 0; i < arr.length; ++i) {
        let sum = 0;
        for (let j = i; j < arr.length; j++) {
            let sum = arr[i] + arr[j];
            let t = Math.floor(Math.log2(sum));
            if (Math.pow(2, t) == sum) {
                count++;
            }
        }
    }

    // Return count
    return count;
}

// Driver Code
let arr = [ 1, 8, 2, 10, 6 ];
let n = arr.length;
console.log(countPair(arr, n));

 // This code is contributed by poojaagarwal2.

Output

5

Time Complexity: O(N²*log(Max)), where N is the length of the given array and Max is the maximum possible value of any pair during their summation.
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized using HashMap. Follow the steps below to solve the problem:

• Create a Map to store frequency of each element of the array arr[].
• Initialize a variable ans to store the count of pairs with sum equal to any power of 2.
• Traverse the range [0, 31] and generate all the powers of 2, i.e. 2⁰ to 2³¹.
• Traverse the given array for every power of 2 generated and check if map[key – arr[j]] exists or not, where key is equal to 2ⁱ.
• If found to be true, increase count by map[key – arr[j]], as pair(s) (arr[j], key – arr[j]) exists with sum equal to a power of 2.
• Finally, print count / 2 as the required answer.

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to count all pairs
// whose sum is a power of two
int countPair(int arr[], int n)
{
    // Stores the frequency of
    // each element of the array
    map<int, int> m;

    // Update frequency of
    // array elements
    for (int i = 0; i < n; i++)
        m[arr[i]]++;

    // Stores count of
    // required pairs
    int ans = 0;

    for (int i = 0; i < 31; i++) {

        // Current power of 2
        int key = pow(2, i);

        // Traverse the array
        for (int j = 0; j < n; j++) {

            int k = key - arr[j];

            // If pair does not exist
            if (m.find(k) == m.end())
                continue;

            // Increment count of pairs
            else
                ans += m[k];

            if (k == arr[j])
                ans++;
        }
    }

    // Return the count of pairs
    return ans / 2;
}

// Driver Code
int main()
{
    int arr[] = { 1, 8, 2, 10, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << countPair(arr, n) << endl;

    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG {
    // Function to count all pairs
    // whose sum is power of two
    static int countPair(int[] arr, int n)
    {
        // Stores the frequency of
        // each element of the array
        Map<Integer, Integer> m
            = new HashMap<>();

        // Update the frequency of
        // array elements
        for (int i = 0; i < n; i++)
            m.put(arr[i], m.getOrDefault(
                            arr[i], 0)
                            + 1);

        // Stores the count of pairs
        int ans = 0;

        // Generate powers of 2
        for (int i = 0; i < 31; i++) {

            // Generate current power of 2
            int key = (int)Math.pow(2, i);

            // Traverse the array
            for (int j = 0; j < arr.length;
                j++) {

                int k = key - arr[j];

                // Increase ans by m[k], if
                // pairs with sum 2^i exists
                ans += m.getOrDefault(k, 0);

                // Increase ans again if k = arr[j]
                if (k == arr[j])
                    ans++;
            }
        }

        // Return count of pairs
        return ans / 2;
    }

    // Driver function
    public static void main(String[] args)
    {
        int[] arr = { 1, -1, 2, 3 };
        int n = arr.length;
        System.out.println(countPair(arr, n));
    }
}

Python3

# Python3 program to implement
# the above approach
from math import pow

# Function to count all pairs
# whose sum is a power of two
def countPair(arr, n):

    # Stores the frequency of
    # each element of the array
    m = {}

    # Update frequency of
    # array elements
    for i in range(n):
        m[arr[i]] = m.get(arr[i], 0) + 1

    # Stores count of
    # required pairs
    ans = 0

    for i in range(31):

        # Current power of 2
        key = int(pow(2, i))

        # Traverse the array
        for j in range(n):
            k = key - arr[j]

            # If pair does not exist
            if k not in m:
                continue

            # Increment count of pairs
            else:
                ans += m.get(k, 0)

            if (k == arr[j]):
                ans += 1

    # Return the count of pairs
    return ans // 2

# Driver Code
if __name__ == '__main__':

    arr =  [ 1, 8, 2, 10, 6 ]
    n = len(arr)

    print(countPair(arr, n))

# This code is contributed by SURENDRA_GANGWAR

Javascript

<script>

// JavaScript program to implement
// the above approach

// Function to count all pairs
// whose sum is a power of two
function countPair(arr, n)
{
    // Stores the frequency of
    // each element of the array
    var m= new Map();

    // Update frequency of
    // array elements
    for (var i = 0; i < n; i++)
    {
        if(m.has(arr[i]))
            m.set(arr[i], m.get(arr[i])+1)
        else
            m.set(arr[i], 1)
    }

    // Stores count of
    // required pairs
    var ans = 0;

    for (var i = 0; i < 31; i++) {

        // Current power of 2
        var key = Math.pow(2, i);

        // Traverse the array
        for (var j = 0; j < n; j++) {

            var k = key - arr[j];

            // If pair does not exist
            if (!m.has(k))
                continue;

            // Increment count of pairs
            else
                ans += m.get(k);

            if (k == arr[j])
                ans++;
        }
    }

    // Return the count of pairs
    return ans / 2;
}

// Driver Code
var arr = [1, 8, 2, 10, 6]
var n = arr.length
document.write( countPair(arr, n));

</script>

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;

class GFG {

    // Function to count all pairs
    // whose sum is a power of two
    public static int countPair(int[] arr, int n)
    { // Stores the frequency of
        // each element of the array
        Dictionary<int, int> map
            = new Dictionary<int, int>();

        // Update frequency of
        // array elements
        for (int i = 0; i < n; i++) {

            if (!map.ContainsKey(arr[i])) {
                map[arr[i]] = 0;
            }

            map[arr[i]] = map[arr[i]] + 1;
        }
        // Stores count of
        // required pairs
        int ans = 0;

        for (int i = 0; i < 31; i++) {
            // Current power of 2
            int key = 1 << i;

            // Traverse the array
            for (int j = 0; j < n; j++) {
                int k = key - arr[j];

                // If pair does not exist
                if (!map.ContainsKey(k)) {
                    continue;
                }
                else {
                    // Increment count of pairs
                    ans += map[k];
                }

                if (k == arr[j]) {
                    ans++;
                }
            }
        }

        // Return the count of pairs
        return ans / 2;
    }

    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 8, 2, 10, 6 };
        int n = arr.Length;
        Console.WriteLine(countPair(arr, n));
    }
}

// This code is contributed by Naveen Shah

Output

5

Time Complexity: O(NlogN)
Auxiliary Space: O(N). We are using a map to store elements