Count pairs having Bitwise XOR less than K from given array

Given an array arr[]of size N and an integer K, the task is to count the number of pairs from the given array such that the Bitwise XOR of each pair is less than K
 Examples:

Input: arr = {1, 2, 3, 5} , K = 5 
Output:
Explanation: 
Bitwise XOR of all possible pairs that satisfy the given conditions are: 
arr[0] ^ arr[1] = 1 ^ 2 = 3 
arr[0] ^ arr[2] = 1 ^ 3 = 2 
arr[0] ^ arr[3] = 1 ^ 5 = 4 
arr[1] ^ arr[2] = 3 ^ 5 = 1 
Therefore, the required output is 4. 

Input: arr[] = {3, 5, 6, 8}, K = 7 
Output: 3  

Naive Approach: The simplest approach to solve this problem is to traverse the given array and generate all possible pairs of the given array and for each pair, check if bitwise XOR of the pair is less than K or not. If found to be true, then increment the count of pairs having bitwise XOR less than K. Finally, print the count of such pairs obtained.

Time Complexity:O(N2)
Auxiliary Space:O(1)

Efficient Approach: The problem can be solved using Trie. The idea is to iterate over the given array and for each array element, count the number of elements present in the Trie whose bitwise XOR with the current element is less than K and insert the binary representation of the current element into the Trie. Finally, print the count of pairs having bitwise XOR less than K. Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure of Trie
struct TrieNode
{
    // Stores binary represention
    // of numbers
    TrieNode *child[2];
 
    // Stores count of elements
    // present in a node
    int cnt;
     
    // Function to initialize
    // a Trie Node
    TrieNode() {
        child[0] = child[1] = NULL;
        cnt = 0;
    }
};
 
 
// Function to insert a number into Trie
void insertTrie(TrieNode *root, int N) {
     
    // Traverse binary representation of X
    for (int i = 31; i >= 0; i--) {
         
        // Stores ith bit of N
        bool x = (N) & (1 << i);
         
        // Check if an element already
        // present in Trie having ith bit x
        if(!root->child[x]) {
             
            // Create a new node of Trie.
            root->child[x] = new TrieNode();
        }
         
        // Update count of elements
        // whose ith bit is x
        root->child[x]->cnt+= 1;
         
        // Update root
        root= root->child[x];
    }
}
 
 
// Function to count elements
// in Trie whose XOR with N
// less than K
int cntSmaller(TrieNode * root,
                int N, int K)
{
     
    // Stores count of elements
    // whose XOR with N less than K
    int cntPairs = 0;
     
    // Traverse binary representation
    // of N and K in Trie
    for (int i = 31; i >= 0 &&
                    root; i--) {
                                     
        // Stores ith bit of N                        
        bool x = N & (1 << i);
         
        // Stores ith bit of K
        bool y = K & (1 << i);
         
        // If the ith bit of K is 1
        if (y) {
             
            // If an element already
            // present in Trie having
            // ith bit (x)
            if(root->child[x]) {
                    cntPairs  +=
                    root->child[x]->cnt;
            }
         
            root =
                root->child[1 - x];
        }
         
        // If the ith bit of K is 0
        else{
             
            // Update root
            root = root->child[x];
        }
    }
    return cntPairs;
}
 
// Function to count pairs that
// satisfy the given conditions
int cntSmallerPairs(int arr[], int N,
                            int K) {
     
    // Create root node of Trie
    TrieNode *root = new TrieNode();
     
    // Stores count of pairs that
    // satisfy the given conditions
    int cntPairs = 0;
     
    // Traverse the given array
    for(int i = 0;i < N; i++){
         
        // Update cntPairs
        cntPairs += cntSmaller(root,
                        arr[i], K);
         
        // Insert arr[i] into Trie
        insertTrie(root, arr[i]);
    }
    return cntPairs;
}
 
// Driver Code
int main()
{
    int arr[] = {3, 5, 6, 8};
    int K= 7;
    int N = sizeof(arr) / sizeof(arr[0]);
     
    cout<<cntSmallerPairs(arr, N, K);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Structure of Trie
static class TrieNode
{
  // Stores binary represention
  // of numbers
  TrieNode child[] = new TrieNode[2];
 
  // Stores count of elements
  // present in a node
  int cnt;
 
  // Function to initialize
  // a Trie Node
  TrieNode()
  {
    child[0] = child[1] = null;
    cnt = 0;
  }
};
 
 
// Function to insert a number
// into Trie
static void insertTrie(TrieNode root,
                       int N)
{   
  // Traverse binary representation
  // of X
  for (int i = 31; i >= 0; i--)
  {
    // Stores ith bit of N
    int x = (N) & (1 << i);
 
    // Check if an element already
    // present in Trie having ith
    // bit x
    if(x <2 && root.child[x] ==
       null)
    {
      // Create a new node of
      // Trie.
      root.child[x] = new TrieNode();
    }
 
    // Update count of elements
    // whose ith bit is x
    if(x < 2)
      root.child[x].cnt += 1;
 
    // Update root
    if(x < 2)
      root = root.child[x];
  }
}
 
// Function to count elements
// in Trie whose XOR with N
// less than K
static int cntSmaller(TrieNode root,
                      int N, int K)
{    
  // Stores count of elements
  // whose XOR with N less
  // than K
  int cntPairs = 0;
 
  // Traverse binary
  // representation of N
  // and K in Trie
  for (int i = 31; i >= 0 &&
       root != null; i--)
  {
    // Stores ith bit of N                        
    int x = (N & (1 << i));
 
    // Stores ith bit of K
    int y = (K & (1 << i));
 
    // If the ith bit of K
    // is 1
    if (y == 1)
    {
      // If an element already
      // present in Trie having
      // ith bit (x)
      if(root.child[x] != null)
      {
        cntPairs +=
           root.child[x].cnt;
      }
 
      root = root.child[1 - x];
    }
 
    // If the ith bit of K is 0
    else
    {
      // Update root
      if(x < 2)
        root = root.child[x];
    }
  }
  return cntPairs;
}
 
// Function to count pairs that
// satisfy the given conditions
static int cntSmallerPairs(int arr[],
                           int N, int K)
{   
  // Create root node of Trie
  TrieNode root = new TrieNode();
 
  // Stores count of pairs that
  // satisfy the given conditions
  int cntPairs = 0;
 
  // Traverse the given array
  for(int i = 0; i < N; i++)
  {
    // Update cntPairs
    cntPairs += cntSmaller(root,
                           arr[i], K);
 
    // Insert arr[i] into Trie
    insertTrie(root, arr[i]);
  }
  return cntPairs;
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {3, 5, 6, 8};
  int K= 7;
  int N = arr.length;
  System.out.print(cntSmallerPairs(arr,
                                   N, K));
}
}
 
// This code is contributed by Rajput-Ji

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Structure of Trie
public class TrieNode
{
   
  // Stores binary represention
  // of numbers
  public TrieNode []child = new TrieNode[2];
 
  // Stores count of elements
  // present in a node
  public int cnt;
 
  // Function to initialize
  // a Trie Node
  public TrieNode()
  {
    child[0] = child[1] = null;
    cnt = 0;
  }
};
 
// Function to insert a number
// into Trie
static void insertTrie(TrieNode root,
                       int N)
{
   
  // Traverse binary representation
  // of X
  for(int i = 31; i >= 0; i--)
  {
     
    // Stores ith bit of N
    int x = (N) & (1 << i);
 
    // Check if an element already
    // present in Trie having ith
    // bit x
    if (x < 2 && root.child[x] == null)
    {
       
      // Create a new node of
      // Trie.
      root.child[x] = new TrieNode();
    }
 
    // Update count of elements
    // whose ith bit is x
    if (x < 2)
      root.child[x].cnt += 1;
 
    // Update root
    if (x < 2)
      root = root.child[x];
  }
}
 
// Function to count elements
// in Trie whose XOR with N
// less than K
static int cntSmaller(TrieNode root,
                      int N, int K)
{   
   
  // Stores count of elements
  // whose XOR with N less
  // than K
  int cntPairs = 0;
 
  // Traverse binary
  // representation of N
  // and K in Trie
  for(int i = 31; i >= 0 &&
      root != null; i--)
  {
     
    // Stores ith bit of N                        
    int x = (N & (1 << i));
 
    // Stores ith bit of K
    int y = (K & (1 << i));
 
    // If the ith bit of K
    // is 1
    if (y == 1)
    {
       
      // If an element already
      // present in Trie having
      // ith bit (x)
      if (root.child[x] != null)
      {
        cntPairs += root.child[x].cnt;
      }
       
      root = root.child[1 - x];
    }
 
    // If the ith bit of K is 0
    else
    {
       
      // Update root
      if (x < 2)
        root = root.child[x];
    }
  }
  return cntPairs;
}
 
// Function to count pairs that
// satisfy the given conditions
static int cntSmallerPairs(int []arr,
                           int N, int K)
{   
   
  // Create root node of Trie
  TrieNode root = new TrieNode();
 
  // Stores count of pairs that
  // satisfy the given conditions
  int cntPairs = 0;
 
  // Traverse the given array
  for(int i = 0; i < N; i++)
  {
     
    // Update cntPairs
    cntPairs += cntSmaller(root,
                           arr[i], K);
 
    // Insert arr[i] into Trie
    insertTrie(root, arr[i]);
  }
  return cntPairs;
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = { 3, 5, 6, 8 };
  int K= 7;
  int N = arr.Length;
   
  Console.Write(cntSmallerPairs(arr,
                                N, K));
}
}
 
// This code is contributed by Princi Singh

chevron_right


Output: 

3







 

Time Complexity:O(N * 32)
Auxiliary Space:O(N * 32)

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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.



Improved By : Rajput-Ji, princi singh