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: 11
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: 9
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:
- Initialize a variable, say res, to store the count of pairs that satisfy the given condition.
- Traverse the given array.
- Store the position of most significant bit of each element of the given array.
- 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 <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; } res = (N * (N - 1)) / 2 - res; return res; } // Driver Code int 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 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 ; } res = (N * (N - 1 )) / 2 - res; return res; } // Driver Code public 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 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 ( 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 Code if __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 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; } res = (N * (N - 1)) / 2 - res; return res; } // Driver Code public 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 |
11
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.