# Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first

Given two arrays arr1[] and arr2[], the task is to take an element from first array (say a) and one element from second array (say b). If the number formed by inverting the bits of a is equal to b, then the pair (a, b) is a valid pair.

Inversion Of bits example:
11 is written as 1011 in binary. After inverting it’s bits, 0100 is obtained which is 4 in decimal. Hence (11, 4) is a valid pair but (4, 11) is not as 11 cannot be obtained after inverting the digits of 4 i.e. 100 -> 011 which is 3.

Examples:

Input: arr1[] = {11, 5, 4}, arr2[] = {1, 4, 3, 11}
Output: 2
(11, 4) and (4, 3) are the only valid pairs.

Input: arr1[] = {43, 7, 1, 99}, arr2 = {5, 1, 28, 20}
Output: 2

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

Approach:

• Take two empty sets s1 and s2.
• Insert all the elements of the arr2[] in s2.
• Iterate the first array. If the element is not present in the first set and the number formed by inverting it’s bits is present in the second set then increment the count and insert the current element in s1 so that it doesn’t get counted again.
• Print the value of count in the end.

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the number formed ` `// by inverting bits the bits of num ` `int` `invertBits(``int` `num) ` `{ ` `    ``// Number of bits in num ` `    ``int` `x = log2(num) + 1; ` ` `  `    ``// Inverting the bits one by one ` `    ``for` `(``int` `i = 0; i < x; i++) ` `        ``num = (num ^ (1 << i)); ` ` `  `    ``return` `num; ` `} ` ` `  `// Function to return the total valid pairs ` `int` `totalPairs(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m) ` `{ ` ` `  `    ``// Set to store the elements of the arrays ` `    ``unordered_set<``int``> s1, s2; ` ` `  `    ``// Insert all the elements of arr2[] in the set ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``s2.insert(arr2[i]); ` ` `  `    ``// Initialize count variable to 0 ` `    ``int` `count = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Check if element of the first array ` `        ``// is not in the first set ` `        ``if` `(s1.find(arr1[i]) == s1.end()) { ` ` `  `            ``// Check if the element formed by inverting bits ` `            ``// is in the second set ` `            ``if` `(s2.find(invertBits(arr1[i])) != s2.end()) { ` ` `  `                ``// Increment the count of valid pairs and insert ` `                ``// the element in the first set so that ` `                ``// it doesn't get counted again ` `                ``count++; ` `                ``s1.insert(arr1[i]); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Return the total number of pairs ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr1[] = { 43, 7, 1, 99 }; ` `    ``int` `arr2[] = { 5, 1, 28, 20 }; ` `    ``int` `n = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `m = ``sizeof``(arr2) / ``sizeof``(arr2); ` ` `  `    ``cout << totalPairs(arr1, arr2, n, m); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation of the approach  ` `import` `java.util.*;  ` `import` `java.io.*;  ` `import` `java.lang.*;  ` ` `  `class` `GFG  ` `{  ` ` `  `static` `int` `log2(``int` `N)  ` `{  ` `    ``// calculate log2 N indirectly  ` `    ``// using log() method  ` `    ``int` `result = (``int``)(Math.log(N) / Math.log(``2``));  ` ` `  `    ``return` `result;  ` `} ` ` `  `// Function to return the number formed  ` `// by inverting bits the bits of num  ` `static` `int` `invertBits(``int` `num)  ` `{  ` `    ``// Number of bits in num  ` `    ``int` `x = log2(num) + ``1``;  ` ` `  `    ``// Inverting the bits one by one  ` `    ``for` `(``int` `i = ``0``; i < x; i++)  ` `        ``num = (num ^ (``1` `<< i));  ` ` `  `    ``return` `num;  ` `}  ` ` `  `// Function to return the total valid pairs  ` `static` `int` `totalPairs(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m)  ` `{  ` ` `  `    ``// Set to store the elements of the arrays  ` `    ``HashSet s1 = ``new` `HashSet();  ` `    ``HashSet s2 = ``new` `HashSet();  ` ` `  `    ``// add all the elements of arr2[] in the set  ` `    ``for` `(``int` `i = ``0``; i < m; i++)  ` `        ``s2.add(arr2[i]);  ` ` `  `    ``// Initialize count variable to 0  ` `    ``int` `count = ``0``;  ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{  ` ` `  `        ``// Check if element of the first array  ` `        ``// is not in the first set  ` `        ``if` `(!s1.contains(arr1[i]))  ` `        ``{  ` ` `  `            ``// Check if the element formed by inverting bits  ` `            ``// is in the second set  ` `            ``if` `(s2.contains(invertBits(arr1[i]))) ` `            ``{  ` ` `  `                ``// Increment the count of valid pairs and add  ` `                ``// the element in the first set so that  ` `                ``// it doesn't get counted again  ` `                ``count++;  ` `                ``s1.add(arr1[i]);  ` `            ``}  ` `        ``}  ` `    ``}  ` ` `  `    ``// Return the total number of pairs  ` `    ``return` `count;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``int` `arr1[] = { ``43``, ``7``, ``1``, ``99` `};  ` `    ``int` `arr2[] = { ``5``, ``1``, ``28``, ``20` `};  ` `    ``int` `n = arr1.length;  ` `    ``int` `m = arr2.length;  ` ` `  `    ``System.out.println(totalPairs(arr1, arr2, n, m));  ` `}  ` `} ` ` `  `// This code is contributed by SHUBHAMSINGH10 `

 `# Python3 implementation of the approach  ` `from` `math ``import` `log2; ` ` `  `# Function to return the number formed  ` `# by inverting bits the bits of num  ` `def` `invertBits(num) :  ` `     `  `    ``# Number of bits in num  ` `    ``x ``=` `log2(num) ``+` `1``;  ` ` `  `    ``# Inverting the bits one by one  ` `    ``for` `i ``in` `range``(``int``(x)) :  ` `        ``num ``=` `(num ^ (``1` `<< i));  ` ` `  `    ``return` `num;  ` ` `  `# Function to return the total valid pairs  ` `def` `totalPairs(arr1, arr2, n, m) :  ` ` `  `    ``# Set to store the elements of the arrays  ` `    ``s1, s2 ``=` `set``(), ``set``(); ` `     `  `    ``# Insert all the elements of  ` `    ``# arr2[] in the set ` `    ``for` `i ``in` `range``(m) : ` `        ``s2.add(arr2[i]); ` `         `  `    ``# Initialize count variable to 0  ` `    ``count ``=` `0``; ` `    ``for` `i ``in` `range``(n) : ` `         `  `        ``# Check if element of the first array  ` `        ``# is not in the first set ` `        ``if` `arr1[i] ``not` `in` `s1 : ` `             `  `            ``# Check if the element formed by  ` `            ``# inverting bits is in the second set  ` `            ``if` `invertBits(arr1[i]) ``in` `s2 : ` `                 `  `                ``# Increment the count of valid pairs  ` `                ``# and insert the element in the first  ` `                ``# set so that it doesn't get counted again  ` `                ``count ``+``=` `1``; ` `                ``s1.add(arr1[i]); ` `     `  `    ``# Return the total number of pairs ` `    ``return` `count; ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``arr1 ``=` `[ ``43``, ``7``, ``1``, ``99` `];  ` `    ``arr2 ``=` `[ ``5``, ``1``, ``28``, ``20` `];  ` `    ``n ``=` `len``(arr1); ` `    ``m ``=` `len``(arr2); ` ` `  `    ``print``(totalPairs(arr1, arr2, n, m));  ` ` `  `# This code is contributed by Ryuga `

 `// C# implementation of the approach  ` `using` `System;  ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{  ` `  `  `static` `int` `log2(``int` `N)  ` `{  ` `    ``// calculate log2 N indirectly  ` `    ``// using log() method  ` `    ``int` `result = (``int``)(Math.Log(N) / Math.Log(2));  ` `  `  `    ``return` `result;  ` `} ` `  `  `// Function to return the number formed  ` `// by inverting bits the bits of num  ` `static` `int` `invertBits(``int` `num)  ` `{  ` `    ``// Number of bits in num  ` `    ``int` `x = log2(num) + 1;  ` `  `  `    ``// Inverting the bits one by one  ` `    ``for` `(``int` `i = 0; i < x; i++)  ` `        ``num = (num ^ (1 << i));  ` `  `  `    ``return` `num;  ` `}  ` `  `  `// Function to return the total valid pairs  ` `static` `int` `totalPairs(``int` `[]arr1, ``int` `[]arr2, ``int` `n, ``int` `m)  ` `{  ` `  `  `    ``// Set to store the elements of the arrays  ` `    ``HashSet<``int``> s1 = ``new` `HashSet<``int``>();  ` `    ``HashSet<``int``> s2 = ``new` `HashSet<``int``>();  ` `  `  `    ``// add all the elements of arr2[] in the set  ` `    ``for` `(``int` `i = 0; i < m; i++)  ` `        ``s2.Add(arr2[i]);  ` `  `  `    ``// Initialize count variable to 0  ` `    ``int` `count = 0;  ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{  ` `  `  `        ``// Check if element of the first array  ` `        ``// is not in the first set  ` `        ``if` `(!s1.Contains(arr1[i]))  ` `        ``{  ` `  `  `            ``// Check if the element formed by inverting bits  ` `            ``// is in the second set  ` `            ``if` `(s2.Contains(invertBits(arr1[i]))) ` `            ``{  ` `  `  `                ``// Increment the count of valid pairs and add  ` `                ``// the element in the first set so that  ` `                ``// it doesn't get counted again  ` `                ``count++;  ` `                ``s1.Add(arr1[i]);  ` `            ``}  ` `        ``}  ` `    ``}  ` `  `  `    ``// Return the total number of pairs  ` `    ``return` `count;  ` `}  ` `  `  `// Driver code  ` `public` `static` `void` `Main()  ` `{  ` `    ``int` `[]arr1 = { 43, 7, 1, 99 };  ` `    ``int` `[]arr2 = { 5, 1, 28, 20 };  ` `    ``int` `n = arr1.Length;  ` `    ``int` `m = arr2.Length;  ` `  `  `    ``Console.Write(totalPairs(arr1, arr2, n, m));  ` `}  ` `} ` `  `  `// This code is contribute by chitranayal `

Output:
```2
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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 :