# Find pair whose bitwise OR and bitwise AND follows the given condition

• Difficulty Level : Hard
• Last Updated : 02 Dec, 2022

Given 2 arrays arr1[] and arr2[], of size N and M respectively, the task is to find a pair of value (say a and b) such that the following conditions are satisfied:

1. (a | b) â‰¤ arr1[i] for all values of i in the range [0, N-1].
2. (a & b) â‰¥ arr2[j] for all values of j in the range [0, M-1].

Examples:

Input: arr1[] = { 6, 9, 7, 8}, arr2[] = {2, 1, 3, 4}
Output: 4 5
Explanation:  4 | 5= 5 and 4 & 5 = 4
Since values of their bitwise OR <= is less than arr1[] elements and also value of their bitwise AND â‰¥ less than arr2[] elements.Hence it forms a valid pair. other possible output may be :
4 | 6 = 6 and 4 & 6 =4 Again since 6 is less than arr1[] elements and 4 >= all other arr2[] elements. Hence it also forms a valid pair.

Input: arr1[] = {1, 9, 7}, arr2[] = {2, 4, 3}
Output: -1
Explanation: No such pair exists.

Approach: To solve the problem follow the below idea:

Since we know that: (a | b) â‰¥ max(a, b) (a & b) â‰¤ min(a, b). If we can prove that there exists a pair {a, b} (assuming b > a)such that b â‰¤ minimum of all other array OR elements and a â‰¥ maximum of all array AND elements then it would also satisfy all other elements

Follow the below steps to solve the problem:

• Find the minimum element of the first array and the maximum element of the second array.
• Then check the condition, if b â‰¥ a then print b and a.
• Otherwise, print “-1”.

Below is the implementation of the above approach.

## C++

 `// C++ to implement the approach` `#include ``using` `namespace` `std;` `// Function to find pair``// Satisfying the condition` `void` `findPair(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m)``{``    ``// Initializing to maximum value``    ``int` `minimum_or_element = INT_MAX;``    ``// Initializing to minimum value``    ``int` `maximum_and_element = INT_MIN;` `    ``// Finding the minimum element in arr1``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr1[i] < minimum_or_element) {``            ``minimum_or_element = arr1[i];``        ``}``    ``}` `    ``// Finding the maximum element in arr2``    ``for` `(``int` `i = 0; i < m; i++) {``        ``if` `(arr2[i] > maximum_and_element) {``            ``maximum_and_element = arr2[i];``        ``}``    ``}` `    ``// Checking the condition that b>=a``    ``if` `(minimum_or_element >= maximum_and_element) {``        ``cout << maximum_and_element << ``" "``             ``<< minimum_or_element << endl;``    ``}``    ``else` `{` `        ``// If a>b print -1``        ``cout << -1 << endl;``    ``}``}` `// Driver code``int` `main()``{` `    ``// Denoting bitwise OR elements``    ``int` `arr1[] = { 1, 9, 7 };``    ``// Denoting bitwise AND elements``    ``int` `arr2[] = { 2, 4, 3 };``    ``int` `n = ``sizeof``(arr1) / ``sizeof``(``int``);``    ``int` `m = ``sizeof``(arr2) / ``sizeof``(``int``);``    ``// Function call``    ``findPair(arr1, arr2, n, m);` `    ``return` `0;``}`

## Java

 `// Java Code for the above approach``import` `java.io.*;` `class` `GFG {` `  ``// Function to find pair``  ``// Satisfying the condition``  ``public` `static` `void` `findPair(``int``[] arr1, ``int``[] arr2,``                              ``int` `n, ``int` `m)``  ``{` `    ``// Initializing to maximum value``    ``int` `minimum_or_element = Integer.MAX_VALUE;` `    ``// Initializing to minimum value``    ``int` `maximum_and_element = Integer.MIN_VALUE;` `    ``// Finding the minimum element in arr1``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``if` `(arr1[i] < minimum_or_element) {``        ``minimum_or_element = arr1[i];``      ``}``    ``}` `    ``// Finding the maximum element in arr2``    ``for` `(``int` `i = ``0``; i < m; i++) {``      ``if` `(arr2[i] > maximum_and_element) {``        ``maximum_and_element = arr2[i];``      ``}``    ``}` `    ``// Checking the condition that b>=a``    ``if` `(minimum_or_element >= maximum_and_element) {``      ``System.out.println(maximum_and_element + ``" "``                         ``+ minimum_or_element);``    ``}``    ``else` `{` `      ``// If a>b print -1``      ``System.out.println(-``1``);``    ``}``  ``}` `  ``public` `static` `void` `main (String[] args)``  ``{``    ` `    ``// Denoting bitwise OR elements``    ``int``[] arr1 = { ``1``, ``9``, ``7` `};` `    ``// Denoting bitwise AND elements``    ``int``[] arr2 = { ``2``, ``4``, ``3` `};``    ``int` `n = arr1.length;` `    ``int` `m = arr2.length;` `    ``// Function call``    ``findPair(arr1, arr2, n, m);``  ``}``}` `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python to implement the approach` `# Function to find pair``# Satisfying the condition``def` `findPair(arr1, arr2, n, m):` `    ``# Initializing to maximum value``    ``minimum_or_element ``=` `1e9` `+` `7``    ``# Initializing to minimum value``    ``maximum_and_element ``=` `-``(``1e9` `+` `7``)` `    ``# Finding the minimum element in arr1``    ``for` `i ``in` `range``(``0``, n):``        ``if` `(arr1[i] < minimum_or_element):``            ``minimum_or_element ``=` `arr1[i]` `    ``# Finding the maximum element in arr2``    ``for` `i ``in` `range``(``0``, m):``        ``if` `(arr2[i] > maximum_and_element):``            ``maximum_and_element ``=` `arr2[i]` `    ``# Checking the condition that b>=a``    ``if` `(minimum_or_element >``=` `maximum_and_element):``        ``print``(maximum_and_element, end``=``" "``)``        ``print``(minimum_or_element)` `    ``else``:` `        ``# If a>b print -1``        ``print``(``-``1``)` `# Driver code`  `# Denoting bitwise OR elements``arr1 ``=` `[``1``, ``9``, ``7``]``# Denoting bitwise AND elements``arr2 ``=` `[``2``, ``4``, ``3``]``n ``=` `len``(arr1)``m ``=` `len``(arr2)``# Function call``findPair(arr1, arr2, n, m)` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# implementation``using` `System;` `public` `class` `GFG {` `    ``// Function to find pair``    ``// Satisfying the condition``    ``public` `static` `void` `findPair(``int``[] arr1, ``int``[] arr2,``                                ``int` `n, ``int` `m)``    ``{``      ` `        ``// Initializing to maximum value``        ``int` `minimum_or_element = Int32.MaxValue;``      ` `        ``// Initializing to minimum value``        ``int` `maximum_and_element = Int32.MinValue;` `        ``// Finding the minimum element in arr1``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(arr1[i] < minimum_or_element) {``                ``minimum_or_element = arr1[i];``            ``}``        ``}` `        ``// Finding the maximum element in arr2``        ``for` `(``int` `i = 0; i < m; i++) {``            ``if` `(arr2[i] > maximum_and_element) {``                ``maximum_and_element = arr2[i];``            ``}``        ``}` `        ``// Checking the condition that b>=a``        ``if` `(minimum_or_element >= maximum_and_element) {``            ``Console.WriteLine(maximum_and_element + ``" "``                              ``+ minimum_or_element);``        ``}``        ``else` `{` `            ``// If a>b print -1``            ``Console.WriteLine(-1);``        ``}``    ``}` `    ``static` `public` `void` `Main()``    ``{``        ``// Denoting bitwise OR elements``        ``int``[] arr1 = { 1, 9, 7 };``      ` `        ``// Denoting bitwise AND elements``        ``int``[] arr2 = { 2, 4, 3 };``        ``int` `n = arr1.Length;` `        ``int` `m = arr2.Length;``      ` `        ``// Function call``        ``findPair(arr1, arr2, n, m);``    ``}``}``// This code is contributed by ksam24000`

## Javascript

 `// JavaScript to implement the approach``const INT_MAX = 2147483647;``const INT_MIN = -2147483647 - 1;` `// Function to find pair``// Satisfying the condition` `const findPair = (arr1, arr2, n, m) => {``    ``// Initializing to maximum value``    ``let minimum_or_element = INT_MAX;``    ``// Initializing to minimum value``    ``let maximum_and_element = INT_MIN;` `    ``// Finding the minimum element in arr1``    ``for` `(let i = 0; i < n; i++) {``        ``if` `(arr1[i] < minimum_or_element) {``            ``minimum_or_element = arr1[i];``        ``}``    ``}` `    ``// Finding the maximum element in arr2``    ``for` `(let i = 0; i < m; i++) {``        ``if` `(arr2[i] > maximum_and_element) {``            ``maximum_and_element = arr2[i];``        ``}``    ``}` `    ``// Checking the condition that b>=a``    ``if` `(minimum_or_element >= maximum_and_element) {``        ``console.log(`\${maximum_and_element} \${minimum_or_element}
`);``    ``}``    ``else` `{` `        ``// If a>b print -1``        ``console.log(``"-1
"``);``    ``}``}` `// Driver code` `// Denoting bitwise OR elements``let arr1 = [1, 9, 7];``// Denoting bitwise AND elements``let arr2 = [2, 4, 3];``let n = arr1.length;``let m = arr2.length;``// Function call``findPair(arr1, arr2, n, m);` `// This code is contributed by rakeshsahni`

Output

`-1`

Time Complexity: O(N + M) to traverse both arrays and find the minimum and maximum values respectively.
Auxiliary Space: O(N + M) storing both array elements.

Related Articles:

My Personal Notes arrow_drop_up