Skip to content
Related Articles

Related Articles

Improve Article

Number of ordered pairs such that (Ai & Aj) = 0

  • Difficulty Level : Hard
  • Last Updated : 17 Aug, 2021

Given an array A[] of n integers, find out the number of ordered pairs such that Ai&Aj is zero, where 0<=(i,j)<n. Consider (i, j) and (j, i) to be different. 
Constraints: 
1<=n<=104 
1<=Ai<=104
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 the 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;
}

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.

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.

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.

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

JavaScript




<script>
    // JavaScript 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
    const countPairs = (a, n) => {
        let count = 0;
 
        // check for all possible pairs
        for (let i = 0; i < n; i++) {
            for (let 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
 
    let a = [3, 4, 2];
    let n = a.length;
    document.write(countPairs(a, n));
 
    // This code is contributed by rakeshsahni
 
</script>
 
 
?>

Output: 
 

4

Time Complexity: O(n2)
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 104. 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

\oplus
 

(2i) in next (i-1) bits. Hence, 
  

DP(mask, i) = DP(mask, i-1) + DP(mask
*** QuickLaTeX cannot compile formula:
 

*** Error message:
Error: Nothing to show, formula is empty
2i, 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. 111

\oplus
 

101 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: 
 

 

C++




// 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;
}

Java




// Java program to calculate
// the number of ordered pairs
// such that their bitwise
// and is zero
import java.util.*;
class GFG{
     
static int N = 15;
   
// Efficient function to count pairs
public static int countPairs(int a[],
                             int n)
{
  // Stores the frequency of
  // each number
  HashMap<Integer,
          Integer> hash = new HashMap<>();
 
  int dp[][] = new int[1 << N][N + 1];
 
  // Initialize 0 to all
   
  // Count the frequency
  // of every element
  for (int i = 0; i < n; ++i)
  {
    if(hash.containsKey(a[i]))
    {
      hash.replace(a[i],
      hash.get(a[i]) + 1);
    }
    else
    {
      hash.put(a[i], 1);
    }
  }
 
  // Iterate for al possible
  // values that a[i] can be
  for (int mask = 0;
           mask < (1 << N); ++mask)
  {
    // If the last bit is ON
    if ((mask & 1) != 0)
    {
      if(hash.containsKey(mask))
      {
        dp[mask][0] = hash.get(mask);
      }
      if(hash.containsKey(mask ^ 1))
      {
        dp[mask][0] += hash.get(mask ^ 1);
      }
    }
    else
    {
      // is the last bit is OFF
      if(hash.containsKey(mask))
      {
        dp[mask][0] = hash.get(mask); 
      }
    }
 
    // Iterate till n
    for (int i = 1; i <= N; ++i)
    {
      // If mask's ith bit is set
      if ((mask & (1 << i)) != 0)
      {
        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];
      }
    }
  }
 
  int 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   
public static void main(String[] args)
{
  int a[] = {5, 4, 1, 6};
  int n = a.length;
  System.out.print(countPairs(a, n));
}
}
 
// This code is contributed by divyeshrabadiya07

Python3




# Python program to calculate the number
# of ordered pairs such that their bitwise
# and is zero
N = 15
 
# efficient function to count pairs
def countPairs(a, n):
 
    # stores the frequency of each number
    Hash = {}
     
    # initialize 0 to all
    dp = [[0 for i in range(N + 1)] for j in range(1 << N)]
 
    # count the frequency of every element
    for i in range(n):
        if a[i] not in Hash:
            Hash[a[i]] = 1
        else:
            Hash[a[i]] += 1
 
    # iterate for al possible values that a[i] can be
    mask = 0
    while(mask < (1 << N)):
        if mask not in Hash:
            Hash[mask] = 0
 
        # 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 i in range(1, N + 1):
 
            # 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]
 
        mask += 1
 
    ans = 0
     
    # iterate for all the array element
    # and count the number of pairs
    for i in range(n):
        ans += dp[((1 << N) - 1) ^ a[i]][N]
         
    # return answer
    return ans
 
# Driver Code
a = [5, 4, 1, 6]
n = len(a)
print(countPairs(a, n))
 
# This code is contributed by avanitrachhadiya2155

C#




// C# program to calculate
// the number of ordered pairs
// such that their bitwise
// and is zero
using System;
using System.Collections.Generic;
 
class GFG {
     
    static int N = 15;
    
    // Efficient function to count pairs
    static int countPairs(int[] a, int n)
    {
      // Stores the frequency of
      // each number
      Dictionary<int, int> hash = new Dictionary<int, int>();
      
      int[, ] dp = new int[1 << N, N + 1];
      
      // Initialize 0 to all
        
      // Count the frequency
      // of every element
      for (int i = 0; i < n; ++i)
      {
        if(hash.ContainsKey(a[i]))
        {
          hash[a[i]] += 1;
        }
        else
        {
          hash.Add(a[i], 1);
        }
      }
      
      // Iterate for al possible
      // values that a[i] can be
      for (int mask = 0;
               mask < (1 << N); ++mask)
      {
        // If the last bit is ON
        if ((mask & 1) != 0)
        {
          if(hash.ContainsKey(mask))
          {
            dp[mask, 0] = hash[mask];
          }
          if(hash.ContainsKey(mask ^ 1))
          {
            dp[mask, 0] += hash[mask ^ 1];
          }
        }
        else
        {
          // is the last bit is OFF
          if(hash.ContainsKey(mask))
          {
            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)) != 0)
          {
            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];
          }
        }
      }
      
      int 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
  static void Main()
  {
      int[] a = {5, 4, 1, 6};
      int n = a.Length;
      Console.WriteLine(countPairs(a, n));
  }
}
 
// This code is contributed by divyesh072019

Output: 

4

Time Complexity: O(N*2N) where N=15 which is a maximum number of bits possible, since Amax=104.

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 :