Skip to content
Related Articles

Related Articles

Improve Article

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:
\Sigma_{n=0}^{31}(^{bit[i]}_{\ \ \ 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 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.
    2. Add the value stored in bits[j] to the answer.
    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 <bits/stdc++.h>
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;
    }
 
    return res;
}
 
// Driver Code
int main()
{
    // Given Input
    int arr[] = { 1, 2, 3, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // 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[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
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




<script>
 
// Javascript program to implement
// the above approach
 
// Function to count pairs that
// satisfy the above condition
function cntPairs(arr, N)
{
 
    // Stores the count of pairs
    var res = 0;
 
    // Stores the count of array
    // elements having same
    // positions of MSB
    var bit  = Array(32).fill(0);
    var i;
    // Traverse the array
    for( i = 0; i < N; i++) {
        // Stores the index of
        // MSB of array elements
        var pos = Math.ceil(Math.log2(arr[i]));
        bit[pos] += 1;
    }
 
    // Calculate number of pairs
    for (i = 0; i < 32; i++) {
        res += Math.ceil((bit[i] * (bit[i] - 1)) / 2);
    }
 
    return res;
}
 
// Driver Code
    // Given Input
    arr = [1, 2, 3, 4];
    N = arr.length;
 
    // Function call to count pairs
    // satisfying the given condition
    document.write(cntPairs(arr, N));
 
</script>
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
Recommended Articles
Page :