Open In App

Minimum Bitwise AND operations to make any two array elements equal

Given an array of integers of size ‘n’ and an integer ‘k’, 
We can perform the Bitwise AND operation between any array element and ‘k’ any number of times. 
The task is to print the minimum number of such operations required to make any two elements of the array equal. 
If it is not possible to make any two elements of the array equal after performing the above mentioned operation then print ‘-1’.
 

Examples: 

Input : k = 6 ; Array : 1, 2, 1, 2 
Output : 0 
Explanation : There are already two equal elements in the array so the answer is 0.
Input : k = 2 ; Array : 5, 6, 2, 4 
Output : 1 
Explanation : If we apply AND operation on element ‘6’, it will become 6&2 = 2 
And the array will become 5 2 2 4, 
Now, the array has two equal elements, so the answer is 1.
Input : k = 15 ; Array : 1, 2, 3 
Output : -1 
Explanation : No matter how many times we perform the above mentioned operation, 
this array will never have equal element pair. So the answer is -1

Approach: 
The key observation is that if it is possible to make the desired array then the answer will be either ‘0’, ‘1’, or ‘2’. It will never exceed ‘2’.

Because, if (x&k) = y 
then, no matter how many times you perform (y&k) 
it’ll always give ‘y’ as the result.   

Below is the implementation of the above approach: 




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the
// minimum operations required.
int minOperations(int a[], int n, int K)
{
    unordered_map<int, bool> map;
    for (int i = 0; i < n; i++) {
 
        // check if the initial array
        // already contains an equal pair
        if (map[a[i]])
            return 0;
        map[a[i]] = true;
    }
     
    // create new array with AND operations
    int b[n];
    for (int i = 0; i < n; i++)
        b[i] = a[i] & K;   
 
    // clear the map
    map.clear();
 
    // Check if the solution
    // is a single operation
    for (int i = 0; i < n; i++) {
 
        // If Bitwise operation between
        //'k' and a[i] gives
        // a number other than a[i]
        if (a[i] != b[i])
            map[b[i]] = true;
    }
 
    // Check if any of the a[i]
    // gets equal to any other element
    // of the array after the operation.
    for (int i = 0; i < n; i++)
 
        // Single operation
        // will be enough
        if (map[a[i]])
           return 1;
 
    // clear the map
    map.clear();
 
    // Check if the solution
    // is two operations
    for (int i = 0; i < n; i++) {
 
        // Check if the array 'b'
        // contains duplicates
        if (map[b[i]])
           return 2;
 
        map[b[i]] = true;
    }
 
    // otherwise it is impossible to
    // create such an array with
    // Bitwise AND operations
    return -1;
}
 
// Driver code
int main()
{
 
    int K = 3;
    int a[] = { 1, 2, 3, 7 };
    int n = sizeof(a)/sizeof(a[0]);
 
    // Function call to compute the result
    cout << minOperations(a, n, K);
 
    return 0;
}




// Java implementation of the approach
import java.util.*;
 
class geeks
{
 
    // Function to count the
    // minimum operations required.
    public static int minOperations(int[] a, int n, int K)
    {
        HashMap<Integer, Boolean> map = new HashMap<>();
         
        for (int i = 0; i < n; i++)
        {
 
            // check if the initial array
            // already contains an equal pair
            // try-catch is used so that
            // nullpointer exception can be handled
            try
            {
                if (map.get(a[i]))
                    return 1;
            }
            catch (Exception e)
            {
                //TODO: handle exception
            }
             
            try
            {
                map.put(a[i], true);
            } catch (Exception e) {}
        }
 
        // create new array with AND operations
        int[] b = new int[n];
        for (int i = 0; i < n; i++)
            b[i] = a[i] & K;
 
        // clear the map
        map.clear();
 
        // Check if the solution
        // is a single operation
        for (int i = 0; i < n; i++)
        {
 
            // If Bitwise operation between
            // 'k' and a[i] gives
            // a number other than a[i]
            if (a[i] != b[i])
            {
                try
                {
                    map.put(b[i], true);
                }
                catch (Exception e) {}
            }
        }
 
        // Check if any of the a[i]
        // gets equal to any other element
        // of the array after the operation.
        for (int i = 0; i < n; i++)
        {
 
            // Single operation
            // will be enough
            try
            {
                if (map.get(a[i]))
                    return 1;
            }
            catch (Exception e)
            {
                //TODO: handle exception
            }
        }
 
        // clear the map
        map.clear();
 
        // Check if the solution
        // is two operations
        for (int i = 0; i < n; i++)
        {
 
            // Check if the array 'b'
            // contains duplicates
            try
            {
                if (map.get(b[i]))
                    return 2;
            }
            catch (Exception e)
            {
                //TODO: handle exception
            }
 
            try
            {
                map.put(b[i], true);
            }
            catch (Exception e)
            {
                //TODO: handle exception
            }
        }
 
        // otherwise it is impossible to
        // create such an array with
        // Bitwise AND operations
        return -1;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int K = 3;
        int[] a = { 1, 2, 3, 7 };
        int n = a.length;
 
        // Function call to compute the result
        System.out.println(minOperations(a, n, K));
    }
}
 
// This code is contributed by
// sanjeev2552




# Python3 implementation of the approach
from collections import defaultdict
 
# Function to count the minimum
# operations required.
def minOperations(a, n, K):
 
    Map = defaultdict(lambda:False)
    for i in range(0, n):
 
        # check if the initial array
        # already contains an equal pair
        if Map[a[i]] == True:
            return 0
        Map[a[i]] = True
     
    # create new array with AND operations
    b = []
    for i in range(0, n):
        b.append(a[i] & K)
 
    # clear the map
    Map.clear()
 
    # Check if the solution
    # is a single operation
    for i in range(0, n):
     
        # If Bitwise operation between
        #'k' and a[i] gives
        # a number other than a[i]
        if a[i] != b[i]:
            Map[b[i]] = True
 
    # Check if any of the a[i]
    # gets equal to any other element
    # of the array after the operation.
    for i in range(0, n):
 
        # Single operation
        # will be enough
        if Map[a[i]] == True:
            return 1
 
    # clear the map
    Map.clear()
 
    # Check if the solution
    # is two operations
    for i in range(0, n):
     
        # Check if the array 'b'
        # contains duplicates
        if Map[b[i]] == True:
            return 2
 
        Map[b[i]] = True
     
    # otherwise it is impossible to
    # create such an array with
    # Bitwise AND operations
    return -1
 
# Driver code
if __name__ == "__main__":
 
    K = 3
    a = [1, 2, 3, 7]
    n = len(a)
 
    # Function call to compute the result
    print(minOperations(a, n, K))
 
# This code is contributed by Rituraj Jain




// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // Function to return the count of
    // minimum operations required
    public static int minOperations(int[] a,
                                    int n, int K)
    {
 
        Dictionary<int, Boolean> map =
                new Dictionary<int, Boolean>();
 
        for (int i = 0; i < n; i++)
        {
 
            // Check if the initial array
            // already contains an equal pair
            if (map.ContainsKey(a[i]))
                return 0;
 
            map.Add(a[i], true);
        }
 
        // Create new array with AND operations
        int[] b = new int[n];
        for (int i = 0; i < n; i++)
            b[i] = a[i] & K;
 
        // Clear the map
        map.Clear();
 
        // Check if the solution
        // is a single operation
        for (int i = 0; i < n; i++)
        {
 
            // If Bitwise OR operation between
            // 'k' and a[i] gives
            // a number other than a[i]
            if (a[i] != b[i])
                map.Add(b[i], true);
        }
 
        // Check if any of the a[i]
        // gets equal to any other element
        // of the array after the operation
        for (int i = 0; i < n; i++)
        {
 
            // Single operation
            // will be enough
            if (map.ContainsKey(a[i]))
                return 1;
        }
 
        // Clear the map
        map.Clear();
 
        // Check if the solution
        // is two operations
        for (int i = 0; i < n; i++)
        {
 
            // Check if the array 'b'
            // contains duplicates
            if (map.ContainsKey(b[i]))
                return 2;
            map.Add(b[i], true);
        }
 
        // Otherwise it is impossible to
        // create such an array with
        // Bitwise OR operations
        return -1;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int K = 3;
        int[] a = { 1, 2, 3, 7 };
        int n = a.Length;
        Console.WriteLine(minOperations(a, n, K));
    }
}
 
// This code is contributed by Rajput-Ji




<script>
 
// JavaScript implementation of the approach
 
// Function to count the
// minimum operations required.
function minOperations(a, n, K)
{
    var map = new Map();
    for (var i = 0; i < n; i++) {
 
        // check if the initial array
        // already contains an equal pair
        if (map[a[i]])
            return 0;
        map.set(a[i], true);
    }
     
    // create new array with AND operations
    var b = Array(n);
    for (var i = 0; i < n; i++)
        b[i] = a[i] & K;   
 
    // clear the map
    map = new Map();
 
    // Check if the solution
    // is a single operation
    for (var i = 0; i < n; i++) {
 
        // If Bitwise operation between
        //'k' and a[i] gives
        // a number other than a[i]
        if (a[i] != b[i])
            map.set(b[i], true);
    }
 
    // Check if any of the a[i]
    // gets equal to any other element
    // of the array after the operation.
    for (var i = 0; i < n; i++)
 
        // Single operation
        // will be enough
        if (map.get(a[i]))
           return 1;
 
    // clear the map
    map = new Map();
 
    // Check if the solution
    // is two operations
    for (var i = 0; i < n; i++) {
 
        // Check if the array 'b'
        // contains duplicates
        if (map.get(b[i]))
           return 2;
 
        map.set(b[i], true);
    }
 
    // otherwise it is impossible to
    // create such an array with
    // Bitwise AND operations
    return -1;
}
 
// Driver code
 
var K = 3;
var a = [1, 2, 3, 7];
var n = a.length;
 
// Function call to compute the result
document.write( minOperations(a, n, K));
 
 
</script>

Output: 
1

 

Time Complexity: O(n)

Auxiliary space: O(n) it is using extra space for unordere_map and array b


Article Tags :