# Count pairs with bitwise XOR exceeding bitwise AND from a given array

• Last Updated : 12 Aug, 2022

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 less than its bitwise XOR(^).

Examples:

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

Input: arr[] = {1, 4, 3, 7, 10}
Output:

Approach: The simplest approach is to traverse the array and generate all possible pairs from the given array. For each pair, check if its bitwise AND(&) is less than the bitwise XOR(^) of that pair 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 satisfy the condition{(X & Y) > (X ^ Y)} are:

bit[i] stores the count of array elements whose position of most significant bit(MSB) is i.

Therefore, total count of pairs that satisfy the given condition{(X & Y) < (X ^ Y)}
= [{N * (N – 1) /2} – {

}]

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.
3. Store the position of most significant bit of each element of the given array.
4. Finally, evaluate the result by the above mentioned formula and print the result.

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[32] = { 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;    }    res = (N * (N - 1)) / 2 - res;     return res;} // Driver Codeint main(){     int arr[] = { 1, 2, 3, 4, 5, 6 };    int N = sizeof(arr) / sizeof(arr[0]);    cout << cntPairs(arr, N);}

## Java

 // Java program to implement// the above approachimport 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;    }    res = (N * (N - 1)) / 2 - res;     return res;} // Driver Codepublic static void main(String[] args){    int[] arr = { 1, 2, 3, 4, 5, 6 };    int N = arr.length;         System.out.println(cntPairs(arr, N));}} // This code is contributed by akhilsaini

## Python3

 # Python3 program to implement# the above approachimport 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(0, N):                 # Stores the index of        # MSB of array elements        pos = int(math.log(arr[i], 2))        bit[pos] = bit[pos] + 1         # Calculate number of pairs    for i in range(0, 32):        res = res + int((bit[i] *                        (bit[i] - 1)) / 2)                             res = int((N * (N - 1)) / 2 - res)         return res # Driver Codeif __name__ == "__main__":         arr = [ 1, 2, 3, 4, 5, 6 ]    N = len(arr)         print(cntPairs(arr, N)) # This code is contributed by akhilsaini

## C#

 // C# program to implement// the above approachusing 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[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;    }    res = (N * (N - 1)) / 2 - res;     return res;} // Driver Codepublic static void Main(){    int[] arr = { 1, 2, 3, 4, 5, 6 };    int N = arr.Length;         Console.Write(cntPairs(arr, N));}} // This code is contributed by akhilsaini

## Javascript

 

Output:

11

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

Method 2 : Bitwise and is greater than bitwise xor if and only if most significant bit is equal.

• Create a bits[] array of size 32 (max no of bits)
• Initialize ans to 0.
• We will traverse the array from the start and for each number,
• Find its most significant bit and say it is j.
• Add the value stored in bits[j] array to the ans. (for the current element bits[j] number of pairs can be formed)
• Now increase the value of bits[j] by 1.
• Now total number of pairs = n*(n-1)/2. Subtract the ans from it.

## C++

 // C++ program for the above approach#include using namespace std; int findCount(int arr[], int N){    // For storing number of pairs    int ans = 0;     // For storing count of numbers    int bits[32] = { 0 };     // Iterate from 0 to N - 1    for (int i = 0; i < N; i++) {         // Find the most significant bit        int val = log2l(arr[i]);         ans += bits[val];        bits[val]++;    }    return N * (N - 1) / 2 - ans;} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 1, 2, 3, 4, 5, 6 };     int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    cout << findCount(arr, N);     return 0;}

## Java

 // Java program for the above approachimport java.io.*;import java.lang.*;import java.util.*; class GFG{ static int findCount(int arr[], int N){         // For storing number of pairs    int ans = 0;     // For storing count of numbers    int bits[] = new int[32];     // Iterate from 0 to N - 1    for(int i = 0; i < N; i++)    {                 // Find the most significant bit        int val = (int)(Math.log(arr[i]) /                        Math.log(2));         ans += bits[val];        bits[val]++;    }    return N * (N - 1) / 2 - ans;} // Driver Codepublic static void main(String[] args){         // Given array arr[]    int arr[] = { 1, 2, 3, 4, 5, 6 };     int N = arr.length;     // Function Call    System.out.println(findCount(arr, N));}} // This code is contributed by Kingash

## Python3

 # Python3 program for the above approachimport mathdef findCount(arr, N):     # For storing number of pairs    ans = 0     # For storing count of numbers    bits = [0] * 32     # Iterate from 0 to N - 1    for i in range(N):         # Find the most significant bit        val = int(math.log2(arr[i]))         ans += bits[val]        bits[val] += 1    return (N * (N - 1) // 2 - ans) # Driver Codeif __name__ == "__main__":     # Given array arr[]    arr = [1, 2, 3, 4, 5, 6]     N = len(arr)     # Function Call    print(findCount(arr, N))     # This code is contributed by ukasp.

## C#

 // C# program for the above approachusing System; class GFG{ static int findCount(int[] arr, int N){         // For storing number of pairs    int ans = 0;     // For storing count of numbers    int[] bits = new int[32];     // Iterate from 0 to N - 1    for(int i = 0; i < N; i++)    {                 // Find the most significant bit        int val = (int)(Math.Log(arr[i]) /                        Math.Log(2));         ans += bits[val];        bits[val]++;    }    return N * (N - 1) / 2 - ans;} // Driver Codepublic static void Main(){         // Given array arr[]    int[] arr = { 1, 2, 3, 4, 5, 6 };     int N = arr.Length;     // Function Call    Console.Write(findCount(arr, N));}} // This code is contributed by subhammahato348

## Javascript

 

Output

11

Time Complexity: O(N)

Space Complexity : O(32) = O(1)

My Personal Notes arrow_drop_up