Given an array A[] of n integers, find out the number of ordered pairs such that A_{i}&A_{j} is zero, where 0<=(i,j)<n. Consider (i, j) and (j, i) to be different.

**Constraints: **

1<=n<=10^{4}

1<=A_{i}<=10^{4}

Examples:

Input : A[] = {3, 4, 2} Output : 4 Explanation : The pairs are (3, 4) and (4, 2) which are counted as 2 as (4, 3) and (2, 4) are considered different. Input : A[]={5, 4, 1, 6} Output : 4 Explanation : (4, 1), (1, 4), (6, 1) and (1, 6) are the pairs

**Simple approach **: A simple approach is to check for all possible pairs and count the number of ordered pairs whose bitwise & returns 0.

Below is the implementation of above idea:

## C++

`// CPP program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Naive function to count the number ` `// of ordered pairs such that their ` `// bitwise and is 0 ` `int` `countPairs(` `int` `a[], ` `int` `n) ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `for` `(` `int` `j = i + 1; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `count += 2; ` ` ` `} ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `a[] = { 3, 4, 2 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` `cout << countPairs(a, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` ` ` `class` `GFG { ` ` ` ` ` `// Naive function to count the number ` ` ` `// of ordered pairs such that their ` ` ` `// bitwise and is 0 ` ` ` `static` `int` `countPairs(` `int` `a[], ` `int` `n) ` ` ` `{ ` ` ` `int` `count = ` `0` `; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) { ` ` ` `for` `(` `int` `j = i + ` `1` `; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == ` `0` `) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `count += ` `2` `; ` ` ` `} ` ` ` ` ` `return` `count; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String arg[]) ` ` ` `{ ` ` ` `int` `a[] = { ` `3` `, ` `4` `, ` `2` `}; ` ` ` `int` `n = a.length; ` ` ` `System.out.print(countPairs(a, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Anant Agarwal. ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to calculate the number ` `# of ordered pairs such that their ` `# bitwise and is zero ` ` ` `# Naive function to count the number ` `# of ordered pairs such that their ` `# bitwise and is 0 ` `def` `countPairs(a, n): ` ` ` `count ` `=` `0` ` ` ` ` `# check for all possible pairs ` ` ` `for` `i ` `in` `range` `(` `0` `, n): ` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `, n): ` ` ` `if` `(a[i] & a[j]) ` `=` `=` `0` `: ` ` ` ` ` `# add 2 as (i, j) and (j, i) are ` ` ` `# considered different ` ` ` `count ` `+` `=` `2` ` ` `return` `count ` ` ` `# Driver Code ` `a ` `=` `[ ` `3` `, ` `4` `, ` `2` `] ` `n ` `=` `len` `(a) ` `print` `(countPairs(a, n)) ` ` ` `# This code is contributed ` `# by Shreyanshi Arun. ` |

*chevron_right*

*filter_none*

## C#

`// C# program to calculate the number ` `// of ordered pairs such that their ` `// bitwise and is zero ` `using` `System; ` ` ` `class` `GFG { ` ` ` ` ` `// Naive function to count the number ` ` ` `// of ordered pairs such that their ` ` ` `// bitwise and is 0 ` ` ` `static` `int` `countPairs(` `int` `[]a, ` `int` `n) ` ` ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j = i + 1; j < n; j++) ` ` ` `if` `((a[i] & a[j]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) ` ` ` `// arev considered different ` ` ` `count += 2; ` ` ` `} ` ` ` ` ` `return` `count; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[]a = { 3, 4, 2 }; ` ` ` `int` `n = a.Length; ` ` ` `Console.Write(countPairs(a, n)); ` ` ` `} ` `} ` ` ` `// This code is contributed by nitin mittal. ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to calculate the number ` `// of ordered pairs such that their ` `// bitwise and is zero ` ` ` `// Naive function to count the number ` `// of ordered pairs such that their ` `// bitwise and is 0 ` `function` `countPairs(` `$a` `, ` `$n` `) ` `{ ` ` ` `$count` `= 0; ` ` ` ` ` `// check for all possible pairs ` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++) ` ` ` `{ ` ` ` `for` `(` `$j` `= ` `$i` `+ 1; ` `$j` `< ` `$n` `; ` `$j` `++) ` ` ` `if` `((` `$a` `[` `$i` `] & ` `$a` `[` `$j` `]) == 0) ` ` ` ` ` `// add 2 as (i, j) and (j, i) are ` ` ` `// considered different ` ` ` `$count` `+= 2; ` ` ` `} ` ` ` ` ` `return` `$count` `; ` `} ` ` ` `// Driver Code ` `{ ` ` ` `$a` `= ` `array` `(3, 4, 2); ` ` ` `$n` `= sizeof(` `$a` `) / sizeof(` `$a` `[0]); ` ` ` `echo` `countPairs(` `$a` `, ` `$n` `); ` ` ` `return` `0; ` `} ` ` ` `// This code is contributed by nitin mittal ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

4

**Time Complexity:** O(n^{2})

**Efficient approach**: An efficient approach is to use Sum over Subsets Dynamic Programming method and count the number of ordered pairs. In the SOS DP we find out the pairs whose bitwise & returned 0. Here we need to count the number of pairs.

Some key observations are the constraints, the maximum that an array element can be is 10^{4}. Calculating the mask up to (1<<15) will give us our answer. Use hashing to count the occurrence of every element. If the last bit is OFF, then relating to SOS dp, we will have a base case since there is only one possibility of OFF bit.

dp[mask][0] = freq(mask)

If the last bit is set ON, then we will have the base case as:

dp[mask][0] = freq(mask) + freq(mask^1)

We add freq(mask^1) to add the other possibility of OFF bit.

**Iterate over N=15 bits, which is the maximum possible.**

Let’s consider the** i-th bit to be 0**, then no subset can differ from the mask in the i-th bit as it would mean that the numbers will have a 1 at i-th bit where the mask has a 0 which would mean that it is not a subset of the mask. Thus we conclude that the numbers now differ in the first (i-1) bits only. Hence,

DP(mask, i) = DP(mask, i-1)

Now the **second case, if the i-th bit is 1, ** it can be divided into two non-intersecting sets. One containing numbers with i-th bit as 1 and differing from mask in the next (i-1) bits. Second containing numbers with ith bit as 0 and differing from mask(2^{i}) in next (i-1) bits. Hence,

DP(mask, i) = DP(mask, i-1) + DP(mask2^{i}, i-1).

**DP[mask][i] **stores the number of subsets of mask which differ from mask only in first i bits. Iterate for all array elements, and for every array element add the number of subsets (dp[ ( ( 1<<N ) – 1 ) ^ a[i] ][ N ]) to the number of pairs. N = maximum number of bits.

**Explanation of addition of dp[ ( ( 1<<N ) – 1 ) ^ a[i] ][N] to the number of pairs: **Take an example of A[i] being 5, which is 101 in binary. For better understanding, assume N=3 in this case, therefore, the reverse of 101 will be 010 which on applying bitwise & gives 0. So (1<<3) gives 1000 which on subtraction from 1 gives 111. 111101 gives 010 which is the reversed bit.So dp[((1<<N)-1)^a[i]][N] will have the number of subsets that returns 0 on applying bitwise & operator.

Below is the implementation of the above idea:

`// CPP program to calculate the number ` `// of ordered pairs such that their bitwise ` `// and is zero ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `N = 15; ` ` ` `// efficient function to count pairs ` `long` `long` `countPairs(` `int` `a[], ` `int` `n) ` `{ ` ` ` `// stores the frequency of each number ` ` ` `unordered_map<` `int` `, ` `int` `> hash; ` ` ` ` ` `long` `long` `dp[1 << N][N + 1]; ` ` ` ` ` `memset` `(dp, 0, ` `sizeof` `(dp)); ` `// initialize 0 to all ` ` ` ` ` `// count the frequency of every element ` ` ` `for` `(` `int` `i = 0; i < n; ++i) ` ` ` `hash[a[i]] += 1; ` ` ` ` ` `// iterate for al possible values that a[i] can be ` ` ` `for` `(` `long` `long` `mask = 0; mask < (1 << N); ++mask) { ` ` ` ` ` `// if the last bit is ON ` ` ` `if` `(mask & 1) ` ` ` `dp[mask][0] = hash[mask] + hash[mask ^ 1]; ` ` ` `else` `// is the last bit is OFF ` ` ` `dp[mask][0] = hash[mask]; ` ` ` ` ` `// iterate till n ` ` ` `for` `(` `int` `i = 1; i <= N; ++i) { ` ` ` ` ` `// if mask's ith bit is set ` ` ` `if` `(mask & (1 << i)) ` ` ` `{ ` ` ` `dp[mask][i] = dp[mask][i - 1] + ` ` ` `dp[mask ^ (1 << i)][i - 1]; ` ` ` `} ` ` ` `else` `// if mask's ith bit is not set ` ` ` `dp[mask][i] = dp[mask][i - 1]; ` ` ` `} ` ` ` `} ` ` ` ` ` `long` `long` `ans = 0; ` ` ` ` ` `// iterate for all the array element ` ` ` `// and count the number of pairs ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `ans += dp[((1 << N) - 1) ^ a[i]][N]; ` ` ` ` ` `// return answer ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `a[] = { 5, 4, 1, 6 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` `cout << countPairs(a, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

4

**Time Complexity:** O(N*2^{N}) where N=15 which is maximum number of bits possible, since A_{max}=10^{4}.

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.

## Recommended Posts:

- Find a positive number M such that gcd(N^M, N&M) is maximum
- Count the number of ordered sets not containing consecutive numbers
- Count no. of ordered subsets having a particular XOR value
- Count pairs (A, B) such that A has X and B has Y number of set bits and A+B = C
- Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
- Ways to fill N positions using M colors such that there are exactly K pairs of adjacent different colors
- Number of Co-prime pairs obtained from the sum of digits of elements in the given range
- Find the number of distinct pairs of vertices which have a distance of exactly k in a tree
- Number of ways to select equal sized subarrays from two arrays having atleast K equal pairs of elements
- Count of pairs in an Array with same number of set bits
- Count total number of N digit numbers such that the difference between sum of even and odd digits is 1
- Sum of elements of all partitions of number such that no element is less than K
- Minimum number N such that total set bits of all numbers from 1 to N is at-least X
- Possible cuts of a number such that maximum parts are divisible by 3
- Number of ways to make binary string of length N such that 0s always occur together in groups of size K
- Find number of edges that can be broken in a tree such that Bitwise OR of resulting two trees are equal
- Minimum number of sub-strings of a string such that all are power of 5
- Number of ways to choose elements from the array such that their average is K
- Number of sub-sequence such that it has one consecutive element with difference less than or equal to 1
- Smallest number greater or equals to N such that it has no odd positioned bit set

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.