# Minimum number of elements that should be removed to make the array good

Given an array arr[], the task is to find the minimum number of elements that must be removed to make the array good. A sequence a1, a2 … an is called good if for each element ai, there exists an element aj (i not equals to j) such that ai + aj is a power of two i.e. 2d for some non-negative integer d.

Examples:

Input: arr[] = {4, 7, 1, 5, 4, 9}
Output: 1
Remove 5 from the array to make the array good.

Input: arr[] = {1, 3, 1, 1}
Output: 0

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: We should delete only such ai for which there is no aj (i not equals to j) such that ai + aj is a power of 2.
For each value let’s find the number of its occurrences in the array. We can use the map data-structure.

Now we can easily check that ai doesn’t have a pair aj. Let’s iterate over all possible sums, S = 20, 21, …, 230 and for each S calculate S – a[i] whether it exists in the map.

Below is the implementation of the above approach :

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the minimum number ` `// of elements that must be removed ` `// to make the given array good ` `int` `minimumRemoval(``int` `n, ``int` `a[]) ` `{ ` ` `  `    ``map<``int``, ``int``> c; ` ` `  `    ``// Count frequency of each element ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``c[a[i]]++; ` ` `  `    ``int` `ans = 0; ` ` `  `    ``// For each element check if there ` `    ``// exists another element that makes ` `    ``// a valid pair ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``bool` `ok = ``false``; ` `        ``for` `(``int` `j = 0; j < 31; j++) { ` `            ``int` `x = (1 << j) - a[i]; ` `            ``if` `(c.count(x) && (c[x] > 1 ` `                       ``|| (c[x] == 1 && x != a[i]))) { ` `                ``ok = ``true``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If does not exist then ` `        ``// increment answer ` `        ``if` `(!ok) ` `            ``ans++; ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 4, 7, 1, 5, 4, 9 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `    ``cout << minimumRemoval(n, a); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to return the minimum number ` `// of elements that must be removed ` `// to make the given array good ` `static` `int` `minimumRemoval(``int` `n, ``int` `a[]) ` `{ ` ` `  `    ``Map c = ``new` `HashMap<>(); ` ` `  `    ``// Count frequency of each element ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``if``(c.containsKey(a[i])) ` `        ``{ ` `            ``c.put(a[i], c.get(a[i])+``1``); ` `        ``} ` `        ``else` `        ``{ ` `            ``c.put(a[i], ``1``); ` `        ``} ` ` `  `    ``int` `ans = ``0``; ` ` `  `    ``// For each element check if there ` `    ``// exists another element that makes ` `    ``// a valid pair ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``boolean` `ok = ``false``; ` `        ``for` `(``int` `j = ``0``; j < ``31``; j++) ` `        ``{ ` `            ``int` `x = (``1` `<< j) - a[i]; ` `            ``if` `((c.get(x) != ``null` `&& (c.get(x) > ``1``)) || ` `                ``c.get(x) != ``null` `&& (c.get(x) == ``1` `&& x != a[i]))  ` `            ``{ ` `                ``ok = ``true``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If does not exist then ` `        ``// increment answer ` `        ``if` `(!ok) ` `            ``ans++; ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `a[] = { ``4``, ``7``, ``1``, ``5``, ``4``, ``9` `}; ` `    ``int` `n = a.length; ` `    ``System.out.println(minimumRemoval(n, a)); ` `} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the minimum number  ` `# of elements that must be removed  ` `# to make the given array good  ` `def` `minimumRemoval(n, a) : ` ` `  `    ``c ``=` `dict``.fromkeys(a, ``0``); ` ` `  `    ``# Count frequency of each element  ` `    ``for` `i ``in` `range``(n) : ` `        ``c[a[i]] ``+``=` `1``;  ` ` `  `    ``ans ``=` `0``;  ` ` `  `    ``# For each element check if there  ` `    ``# exists another element that makes  ` `    ``# a valid pair  ` `    ``for` `i ``in` `range``(n) : ` `        ``ok ``=` `False``;  ` `        ``for` `j ``in` `range``(``31``) : ` `             `  `            ``x ``=` `(``1` `<< j) ``-` `a[i];  ` `            ``if` `(x ``in` `c ``and` `(c[x] > ``1` `or`  `               ``(c[x] ``=``=` `1` `and` `x !``=` `a[i]))) : ` `                 `  `                ``ok ``=` `True``;  ` `                ``break``; ` ` `  `        ``# If does not exist then  ` `        ``# increment answer  ` `        ``if` `(``not` `ok) : ` `            ``ans ``+``=` `1``;  ` `             `  `    ``return` `ans;  ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: ` `     `  `    ``a ``=` `[ ``4``, ``7``, ``1``, ``5``, ``4``, ``9` `];  ` `    ``n ``=` `len``(a) ;  ` `     `  `    ``print``(minimumRemoval(n, a)); ` `     `  `# This code is contributed by Ryuga `

## C#

 `// C# implementation of the approach ` `using` `System.Linq; ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Function to return the minimum number ` `// of elements that must be removed ` `// to make the given array good ` `static` `int` `minimumRemoval(``int` `n, ``int` `[]a) ` `{ ` ` `  `    ``int``[] c = ``new` `int``; ` ` `  `    ``// Count frequency of each element ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``c[a[i]]++; ` ` `  `    ``int` `ans = 0; ` ` `  `    ``// For each element check if there ` `    ``// exists another element that makes ` `    ``// a valid pair ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``bool` `ok = ``true``; ` `        ``for` `(``int` `j = 0; j < 31; j++)  ` `        ``{ ` `            ``int` `x = (1 << j) - a[i]; ` `            ``if` `(c.Contains(x) && (c[x] > 1 || ` `                    ``(c[x] == 1 && x != a[i])))  ` `            ``{ ` `                ``ok = ``false``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If does not exist then ` `        ``// increment answer ` `        ``if` `(!ok) ` `            ``ans++; ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `static` `void` `Main() ` `{ ` `    ``int` `[]a = { 4, 7, 1, 5, 4, 9 }; ` `    ``int` `n = a.Length; ` `    ``Console.WriteLine(minimumRemoval(n, a)); ` `} ` `} ` ` `  `// This code is contributed by mits `

Output:

```1
``` My Personal Notes arrow_drop_up pawanasipugmailcom

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.