Related Articles

# Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array

• Last Updated : 19 Apr, 2021

Given an array arr[] of size N, the task is to count the number of pairs from the given array such that the Bitwise AND (&) of each pair is greater than its Bitwise XOR(^).

Examples :

Input: arr[] = {1, 2, 3, 4}
Output:1
Explanation:
Pairs that satisfy the given conditions are:
(2 & 3) > (2 ^ 3)
Therefore, the required output is 1.

Input: arr[] = {1, 4, 3, 7}
Output: 1
Explanation:
Pairs that satisfy the given conditions are:
(4 & 7) > (4 ^ 3)
Therefore, the required output is 1.

Naive Approach: The simplest approach to solve the problem is to traverse the array and generate all possible pairs from the given array. For each pair, check if its Bitwise AND( & ) is greater than its Bitwise XOR( ^ ) or not. If found to be true, then increment the count of pairs by 1. Finally, print the count of such pairs obtained.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient approach: To optimize the above approach, follow the properties of the Bitwise Operators:

1 ^ 0 = 1
0 ^ 1 = 1
1 & 1 = 1
X = b31b30…..b1b0
Y = a31b30….a1a0
If the expression {(X & Y) > (X ^ Y)} is true, then the Most Significant Bit (MSB) of both X and Y must be equal.
Total count of pairs that satisfying the condition {(X & Y) > (X ^ Y)} is equal to: Follow the steps below to solve the problem:

1. Initialize a variable, say res, to store the count of pairs that satisfy the given condition.
2. Traverse the given array arr[].
3. Store the positions of the Most Significant Bit (MSB) of each element of the given array.
4. Initialize an array bits[], of size 32 (max no of bits)
5. Iterate over each array element and perform the following steps:
1. Find the Most Significant Bit (MSB) of the current array element, say j.
3. Increase the value of bits[j] by 1.

Below is the implementation of the above approach

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to count pairs that``// satisfy the above condition``int` `cntPairs(``int` `arr[], ``int` `N)``{` `    ``// Stores the count of pairs``    ``int` `res = 0;` `    ``// Stores the count of array``    ``// elements having same``    ``// positions of MSB``    ``int` `bit = { 0 };` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Stores the index of``        ``// MSB of array elements``        ``int` `pos = log2(arr[i]);``        ``bit[pos]++;``    ``}` `    ``// Calculate number of pairs``    ``for` `(``int` `i = 0; i < 32; i++) {``        ``res += (bit[i] * (bit[i] - 1)) / 2;``    ``}` `    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `arr[] = { 1, 2, 3, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function call to count pairs``    ``// satisfying the given condition``    ``cout << cntPairs(arr, N);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;` `class` `GFG{` `// Function to count pairs that``// satisfy the above condition``static` `int` `cntPairs(``int` `arr[], ``int` `N)``{` `    ``// Stores the count of pairs``    ``int` `res = ``0``;` `    ``// Stores the count of array``    ``// elements having same``    ``// positions of MSB``    ``int` `bit[] = ``new` `int``[``32``];` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Stores the index of``        ``// MSB of array elements``        ``int` `pos = (``int``)(Math.log(arr[i]) / Math.log(``2``));``        ``bit[pos]++;``    ``}` `    ``// Calculate number of pairs``    ``for``(``int` `i = ``0``; i < ``32``; i++)``    ``{``        ``res += (bit[i] * (bit[i] - ``1``)) / ``2``;``    ``}``    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Input``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};``    ``int` `N = arr.length;` `    ``// Function call to count pairs``    ``// satisfying the given condition``    ``System.out.println(cntPairs(arr, N));``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python3 program to implement``# the above approach``import` `math` `# Function to count pairs that``# satisfy the above condition``def` `cntPairs(arr, N):` `    ``# Stores the count of pairs``    ``res ``=` `0` `    ``# Stores the count of array``    ``# elements having same``    ``# positions of MSB``    ``bit ``=` `[``0``] ``*` `32` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ` `        ``# Stores the index of``        ``# MSB of array elements``        ``pos ``=` `(``int``)(math.log2(arr[i]))``        ``bit[pos] ``+``=` `1` `    ``# Calculate number of pairs``    ``for` `i ``in` `range``(``32``):``        ``res ``+``=` `(bit[i] ``*` `(bit[i] ``-` `1``)) ``/``/` `2``        ` `    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given Input``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``]``    ``N ``=` `len``(arr)` `    ``# Function call to count pairs``    ``# satisfying the given condition``    ``print``(cntPairs(arr, N))` `# This code is contributed by ukasp`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to count pairs that``// satisfy the above condition``static` `int` `cntPairs(``int``[] arr, ``int` `N)``{` `    ``// Stores the count of pairs``    ``int` `res = 0;` `    ``// Stores the count of array``    ``// elements having same``    ``// positions of MSB``    ``int``[] bit = ``new` `int``;` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Stores the index of``        ``// MSB of array elements``        ``int` `pos = (``int``)(Math.Log(arr[i]) / Math.Log(2));``        ``bit[pos]++;``    ``}` `    ``// Calculate number of pairs``    ``for``(``int` `i = 0; i < 32; i++)``    ``{``        ``res += (bit[i] * (bit[i] - 1)) / 2;``    ``}``    ``return` `res;``}` `// Driver Code``static` `public` `void` `Main ()``{``    ` `    ``// Given Input``    ``int``[] arr = { 1, 2, 3, 4 };``    ``int` `N = arr.Length;` `    ``// Function call to count pairs``    ``// satisfying the given condition``    ``Console.Write(cntPairs(arr, N));``}``}` `// This code is contributed by avijitmondal1998`

## Javascript

 ``
Output:
`1`

Time Complexity: O(N)
Auxiliary Space: O(1)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up