# Minimum Bitwise OR operations to make any two array elements equal

Given an array arr[] of integers and an integer K, we can perform the Bitwise OR 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: arr[] = {1, 9, 4, 3}, K = 3
Output: 1
We can OR a with x, which makes it 3 which is equal to a

Input : arr[] = {13, 26, 21, 15}, K = 13
Output : -1

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

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.

• The answer will be 0, if there are already equal elements in the array.
• For the answer to be 1, we will create a new array b[] which holds b[i] = (a[i] | K),
Now, for each a[i] we will check if there is any index j such that i != j and a[i] = b[j].
If yes, then the answer will be 1.
• For the answer to be 2, we will check for an index i in the new array b[],
if there is any index j such that i != j and b[i] = b[j].
If yes, then the answer will be 2.
• If any of the above conditions is not satisfied then the answer will be -1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count of ` `// 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 OR 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 OR 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 OR operations ` `    ``return` `-1; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``int` `K = 3; ` `    ``int` `a[] = { 1, 9, 4, 3 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` ` `  `    ``// Function call to compute the result ` `    ``cout << minOperations(a, n, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.HashMap; ` ` `  `class` `GFG  ` `{ ` `     `  `    ``// Function to return the count of ` `    ``// minimum operations required ` `    ``public` `static` `int` `minOperations(``int``[] a, ``int` `n, ``int` `K)  ` `    ``{ ` ` `  `        ``HashMap map = ``new` `HashMap<>(); ` ` `  `        ``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.put(a[i], ``true``); ` `        ``} ` ` `  `        ``// Create new array with OR 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.put(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.put(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``, ``9``, ``4``, ``3` `}; ` `        ``int` `n = a.length; ` `        ``System.out.println(minOperations(a, n, K)); ` `    ``} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to return the count of  ` `# minimum operations required  ` `def` `minOperations(a, n, K) : ` `     `  `    ``map` `=` `dict``.fromkeys(a,``0``) ;  ` `     `  `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# Check if the initial array  ` `        ``# already contains an equal pair  ` `        ``if` `(``map``[a[i]]) : ` `            ``return` `0``; ` `             `  `        ``map``[a[i]] ``=` `True``; ` `         `  `    ``# Create new array with OR operations ` `    ``b ``=` `[``0``]``*``n;  ` `     `  `    ``for` `i ``in` `range``(n) : ` `        ``b[i] ``=` `a[i] | K;  ` ` `  `    ``# Clear the map  ` `    ``map``.clear();  ` ` `  `    ``# Check if the solution  ` `    ``# is a single operation  ` `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# If Bitwise OR 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``(n) : ` ` `  `        ``# Single operation  ` `        ``# will be enough  ` `        ``if` `a[i] ``not` `in` `map` `: ` `            ``pass` `         `  `        ``elif` `(``map``[a[i]]) : ` `            ``return` `1``;  ` ` `  `    ``# Clear the map  ` `    ``map``.clear();  ` ` `  `    ``# Check if the solution  ` `    ``# is two operations  ` `    ``for` `i ``in` `range``(n) : ` ` `  `        ``# 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 OR operations  ` `    ``return` `-``1``;  ` ` `  ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``K ``=` `3``;  ` `    ``a ``=` `[ ``1``, ``9``, ``4``, ``3` `];  ` `    ``n ``=` `len``(a);  ` ` `  `    ``# Function call to compute the result  ` `    ``print``(minOperations(a, n, K));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// 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 OR 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, 9, 4, 3 }; ` `        ``int` `n = a.Length; ` `        ``Console.WriteLine(minOperations(a, n, K)); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```1
```

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.