# Count of elements which cannot form any pair whose sum is power of 2

• Last Updated : 24 May, 2021

Given an array arr[] of length N, the task is to print the number of array elements that cannot form a pair with any other array element whose sum is a power of two.
Examples:

Input: arr[] = {6, 2, 11}
Output:
Explanation:
Since 6 and 2 can form a pair with sum 8 (= 23). So only 11 has to be removed as it does not form a sum which is a power of 2.
Input: arr[] = [1, 1, 1, 1023],
Output:
Explanation:
The given array elements can be split into following two pairs:
(1, 1) with sum 2(= 21
(1, 1023) with sum 1024(= 210
Hence, no need to remove any element.

Approach:
To solve the problem mentioned above, follow the steps below:

• Store the frequencies of all array elements in a Map.
• For every array element a[i], iterate over all possible sums p = {20, 21, …., 230} and check if p – a[i] is present in the array or not.
• Either of the following two conditions needs to be satisfied:
1. Let s = p – a[i]. If s is present in the array more than once, then a pair consisting of a[i] with sum p is possible.
2. If s is present only once in the array, then s has to be different from a[i] for a possible pair.
3. If none of the above two conditions are satisfied, no pair consisting of a[i] is possible with sum p.
• If the above two conditions do not satisfy for any p for the current a[i], then increase the count as a[i] cannot form a sum which is a power of 2 with any other array element.
• Print the final value of count.

Below is the implementation of the above approach:

## C++

 `// C++ Program to count of``// array elements which do``// not form a pair with sum``// equal to a power of 2``// with any other array element` `#include ``using` `namespace` `std;` `// Function to calculate``// and return the``// count of elements` `int` `powerOfTwo(``int` `a[], ``int` `n)``{``    ``// Stores the frequencies``    ``// of every array element` `    ``map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < n; i++)``        ``mp[a[i]]++;` `    ``// Stores the count``    ``// of removals` `    ``int` `count = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``bool` `f = ``false``;` `        ``// For every element, check if``        ``// it can form a sum equal to``        ``// any power of 2 with any other``        ``// element` `        ``for` `(``int` `j = 0; j < 31; j++) {` `            ``// Store pow(2, j) - a[i]``            ``int` `s = (1 << j) - a[i];` `            ``// Check if s is present``            ``// in the array``            ``if` `(mp.count(s)` `                ``// If frequency of s``                ``// exceeds 1``                ``&& (mp[s] > 1` `                    ``// If s has frequency 1``                    ``// but is different from``                    ``// a[i]``                    ``|| mp[s] == 1 && s != a[i]))` `                ``// Pair possible``                ``f = ``true``;``        ``}` `        ``// If no pair possible for``        ``// the current element` `        ``if` `(f == ``false``)``            ``count++;``    ``}` `    ``// Return the answer``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `a[] = { 6, 2, 11 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``cout << powerOfTwo(a, n);` `    ``return` `0;``}`

## Java

 `// Java program to count of array``// elements which do not form a``// pair with sum equal to a power``// of 2 with any other array element``import` `java.util.*;` `class` `GFG{` `// Function to calculate and return``// the count of elements``static` `int` `powerOfTwo(``int` `a[], ``int` `n)``{``    ` `    ``// Stores the frequencies``    ``// of every array element``    ``HashMap mp = ``new` `HashMap();` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``       ``if``(mp.containsKey(a[i]))``       ``{``           ``mp.put(a[i], mp.get(a[i]) + ``1``);``       ``}``       ``else``       ``{``           ``mp.put(a[i], ``1``);``       ``}``    ``}``    ` `    ``// Stores the count``    ``// of removals``    ``int` `count = ``0``;` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``       ``boolean` `f = ``false``;``       ` `       ``// For every element, check if``       ``// it can form a sum equal to``       ``// any power of 2 with any other``       ``// element``       ``for``(``int` `j = ``0``; j < ``31``; j++)``       ``{``          ` `          ``// Store Math.pow(2, j) - a[i]``          ``int` `s = (``1` `<< j) - a[i];``          ` `          ``// Check if s is present``          ``// in the array``          ``if` `(mp.containsKey(s) &&``             ` `             ``// If frequency of s``             ``// exceeds 1``             ``(mp.get(s) > ``1` `||``             ` `              ``// If s has frequency 1``              ``// but is different from``              ``// a[i]``              ``mp.get(s) == ``1` `&& s != a[i]))``             ` `             ``// Pair possible``             ``f = ``true``;``       ``}``       ` `       ``// If no pair possible for``       ``// the current element``       ``if` `(f == ``false``)``           ``count++;``    ``}``    ` `    ``// Return the answer``    ``return` `count;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `a[] = { ``6``, ``2``, ``11` `};``    ``int` `n = a.length;``    ` `    ``System.out.print(powerOfTwo(a, n));``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to count of``# array elements which do``# not form a pair with sum``# equal to a power of 2``# with any other array element``from` `collections ``import` `defaultdict` `# Function to calculate``# and return the``# count of elements``def` `powerOfTwo(a, n):` `    ``# Stores the frequencies``    ``# of every array element``    ``mp ``=` `defaultdict (``int``)` `    ``for` `i ``in` `range` `(n):``        ``mp[a[i]] ``+``=` `1` `    ``# Stores the count``    ``# of removals``    ``count ``=` `0` `    ``for` `i ``in` `range` `(n):``        ``f ``=` `False` `        ``# For every element, check if``        ``# it can form a sum equal to``        ``# any power of 2 with any other``        ``# element` `        ``for` `j ``in` `range` `(``31``):` `            ``# Store pow(2, j) - a[i]``            ``s ``=` `(``1` `<< j) ``-` `a[i]` `            ``# Check if s is present``            ``# in the array``            ``if` `(s ``in` `mp` `                ``# If frequency of s``                ``# exceeds 1``                ``and` `(mp[s] > ``1` `                    ``# If s has frequency 1``                    ``# but is different from``                    ``# a[i]``                    ``or` `mp[s] ``=``=` `1` `and``                       ``s !``=` `a[i])):` `                ``# Pair possible``                ``f ``=` `True` `        ``# If no pair possible for``        ``# the current element``        ``if` `(f ``=``=` `False``):``            ``count ``+``=` `1``  ` `    ``# Return the answer``    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``a ``=` `[``6``, ``2``, ``11``]``    ``n ``=` `len``(a)``    ``print``(powerOfTwo(a, n))` `# This code is contributed by Chitranayal`

## C#

 `// C# program to count of array``// elements which do not form a``// pair with sum equal to a power``// of 2 with any other array element``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to calculate and return``// the count of elements``static` `int` `powerOfTwo(``int` `[]a, ``int` `n)``{``    ` `    ``// Stores the frequencies``    ``// of every array element``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``if``(mp.ContainsKey(a[i]))``        ``{``            ``mp[a[i]] = mp[a[i]] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(a[i], 1);``        ``}``    ``}``    ` `    ``// Stores the count``    ``// of removals``    ``int` `count = 0;` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``bool` `f = ``false``;``        ` `        ``// For every element, check if``        ``// it can form a sum equal to``        ``// any power of 2 with any other``        ``// element``        ``for``(``int` `j = 0; j < 31; j++)``        ``{``        ` `            ``// Store Math.Pow(2, j) - a[i]``            ``int` `s = (1 << j) - a[i];``            ` `            ``// Check if s is present``            ``// in the array``            ``if` `(mp.ContainsKey(s) &&``                ` `                ``// If frequency of s``                ``// exceeds 1``                ``(mp[s] > 1 ||``                ` `                ``// If s has frequency 1``                ``// but is different from``                ``// a[i]``                ``mp[s] == 1 && s != a[i]))``                ` `                ``// Pair possible``                ``f = ``true``;``        ``}``        ` `        ``// If no pair possible for``        ``// the current element``        ``if` `(f == ``false``)``            ``count++;``    ``}``    ` `    ``// Return the answer``    ``return` `count;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]a = { 6, 2, 11 };``    ``int` `n = a.Length;``    ` `    ``Console.Write(powerOfTwo(a, n));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`1`

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up