Given an array of integers A[] consisting of N integers, find the number of triples of indices (i, j, k) such that A[i] & A[j] & A[k] is 0(<0 ? i, j, k ? N and & denotes Bitwise AND operator.
Examples:
Input: A[]={2, 1, 3}
Output: 12
Explanation: The following i, j, k triples can be chosen whose bitwise AND is zero:
(i=0, j=0, k=1) : 2 & 2 & 1
(i=0, j=1, k=0) : 2 & 1 & 2
(i=0, j=1, k=1) : 2 & 1 & 1
(i=0, j=1, k=2) : 2 & 1 & 3
(i=0, j=2, k=1) : 2 & 3 & 1
(i=1, j=0, k=0) : 1 & 2 & 2
(i=1, j=0, k=1) : 1 & 2 & 1
(i=1, j=0, k=2) : 1 & 2 & 3
(i=1, j=1, k=0) : 1 & 1 & 2
(i=1, j=2, k=0) : 1 & 3 & 2
(i=2, j=0, k=1) : 3 & 2 & 1
(i=2, j=1, k=0) : 3 & 1 & 2Input: A[]={21, 15, 6}
Output: 0
Explanation: No such triplets exist.
Approach: The idea to solve this problem is to use a Map to process the array solving elements. Follow the steps below to solve the problem:
- Initialize a Map to store frequencies of every possible value of A[i] & A[j]. Also, initialize a variable answer with 0, to store the required count.
- Traverse the array and for each array element, traverse the map and check for each map if key, if it’s Bitwise AND with the current array element is 0 or not. For every array element for which it is found to be true, increase answer by frequency of the key.
- After completing the traversal of the array, print answer.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> #include <iostream> using namespace std;
// Function to find the number of // triplets whose Bitwise AND is 0. int countTriplets(vector< int >& A)
{ // Stores the count of triplets
// having bitwise AND equal to 0
int cnt = 0;
// Stores frequencies of all possible A[i] & A[j]
unordered_map< int , int > tuples;
// Traverse the array
for ( auto a : A)
// Update frequency of Bitwise AND
// of all array elements with a
for ( auto b : A)
++tuples[a & b];
// Traverse the array
for ( auto a : A)
// Iterate the map
for ( auto t : tuples)
// If bitwise AND of triplet
// is zero, increment cnt
if ((t.first & a) == 0)
cnt += t.second;
// Return the number of triplets
// whose Bitwise AND is 0.
return cnt;
} // Driver Code int main()
{ // Input Array
vector< int > A = { 2, 1, 3 };
// Function Call
cout << countTriplets(A);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG
{ // Function to find the number of // triplets whose Bitwise AND is 0. static int countTriplets( int []A)
{ // Stores the count of triplets
// having bitwise AND equal to 0
int cnt = 0 ;
// Stores frequencies of all possible A[i] & A[j]
HashMap<Integer,Integer> tuples = new HashMap<Integer,Integer>();
// Traverse the array
for ( int a : A)
// Update frequency of Bitwise AND
// of all array elements with a
for ( int b : A)
{
if (tuples.containsKey(a & b))
tuples.put(a & b, tuples.get(a & b) + 1 );
else
tuples.put(a & b, 1 );
}
// Traverse the array
for ( int a : A)
// Iterate the map
for (Map.Entry<Integer, Integer> t : tuples.entrySet())
// If bitwise AND of triplet
// is zero, increment cnt
if ((t.getKey() & a) == 0 )
cnt += t.getValue();
// Return the number of triplets
// whose Bitwise AND is 0.
return cnt;
} // Driver Code public static void main(String[] args)
{ // Input Array
int []A = { 2 , 1 , 3 };
// Function Call
System.out.print(countTriplets(A));
} } // This code is contributed by shikhasingrajput |
# Python3 program for the above approach # Function to find the number of # triplets whose Bitwise AND is 0. def countTriplets(A) :
# Stores the count of triplets
# having bitwise AND equal to 0
cnt = 0 ;
# Stores frequencies of all possible A[i] & A[j]
tuples = {};
# Traverse the array
for a in A:
# Update frequency of Bitwise AND
# of all array elements with a
for b in A:
if (a & b) in tuples:
tuples[a & b] + = 1 ;
else :
tuples[a & b] = 1 ;
# Traverse the array
for a in A:
# Iterate the map
for t in tuples:
# If bitwise AND of triplet
# is zero, increment cnt
if ((t & a) = = 0 ):
cnt + = tuples[t];
# Return the number of triplets
# whose Bitwise AND is 0.
return cnt;
# Driver Code if __name__ = = "__main__" :
# Input Array
A = [ 2 , 1 , 3 ];
# Function Call
print (countTriplets(A));
# This code is contributed by AnkThon
|
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG
{ // Function to find the number of // triplets whose Bitwise AND is 0. static int countTriplets( int []A)
{ // Stores the count of triplets
// having bitwise AND equal to 0
int cnt = 0;
// Stores frequencies of all possible A[i] & A[j]
Dictionary< int , int > tuples = new Dictionary< int , int >();
// Traverse the array
foreach ( int a in A)
// Update frequency of Bitwise AND
// of all array elements with a
foreach ( int b in A)
{
if (tuples.ContainsKey(a & b))
tuples[a & b] = tuples[a & b] + 1;
else
tuples.Add(a & b, 1);
}
// Traverse the array
foreach ( int a in A)
// Iterate the map
foreach (KeyValuePair< int , int > t in tuples)
// If bitwise AND of triplet
// is zero, increment cnt
if ((t.Key & a) == 0)
cnt += t.Value;
// Return the number of triplets
// whose Bitwise AND is 0.
return cnt;
} // Driver Code public static void Main(String[] args)
{ // Input Array
int []A = { 2, 1, 3 };
// Function Call
Console.Write(countTriplets(A));
} } // This code is contributed by 29AjayKumar |
<script> // Javascript program for the above approach // Function to find the number of // triplets whose Bitwise AND is 0. function countTriplets(A)
{ // Stores the count of triplets
// having bitwise AND equal to 0
var cnt = 0;
// Stores frequencies of all possible A[i] & A[j]
var tuples = new Map();
// Traverse the array
A.forEach(a => {
// Update frequency of Bitwise AND
// of all array elements with a
A.forEach(b => {
if (tuples.has(a & b))
tuples.set(a & b, tuples.get(a & b)+1)
else
tuples.set(a & b, 1)
});
});
// Traverse the array
A.forEach(a => {
// Update frequency of Bitwise AND
// of all array elements with a
tuples.forEach((value, key) => {
// If bitwise AND of triplet
// is zero, increment cnt
if ((key & a) == 0)
cnt += value;
});
});
// Return the number of triplets
// whose Bitwise AND is 0.
return cnt;
} // Driver Code // Input Array var A = [2, 1, 3];
// Function Call document.write( countTriplets(A)); </script> |
12
Time Complexity: O(max(M*N, N2)) where M is the maximum element present in the given array
Auxiliary Space: O(M)