# Count triples with Bitwise AND equal to Zero

• Last Updated : 31 May, 2021

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 & 2

Input: 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++

 `// C++ program for the above approach` `#include ``#include ``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

 `// 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 tuples = ``new` `HashMap();` `    ``// 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 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

 `# 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#

 `// 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`

## Javascript

 ``

Output:
`12`

Time Complexity: O(max(M, N2)) where M is the maximum element present in the given array
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up