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 a₁, a₂ … a_n is called good if for each element a_i, there exists an element a_j (i not equals to j) such that a_i + a_j is a power of two i.e. 2^d 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 a_i for which there is no a_j (i not equals to j) such that a_i + a_j 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 a_i doesn’t have a pair a_j. Let’s iterate over all possible sums, S = 2⁰, 2¹, …, 2³⁰ 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 <bits/stdc++.h> 
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[0]); 
    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<Integer,Integer> 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[1000]; 
  
    // 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:

My Personal Notes

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

C++

Java

Python3

C#

Recommended Posts: