Skip to content
Related Articles

Related Articles

Count distinct possible Bitwise XOR values of subsets of an array
  • Last Updated : 26 Mar, 2021

Given an array arr[] consisting of N integers, the task is to find the size of the set S such that Bitwise XOR of any subset of the array arr[] exists in the set S.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: 8
Explanation:
All possible Bitwise XOR values of subsets of the array arr[] are {0, 1, 2, 3, 4, 5, 6, 7}.
Therefore, the size of the required set is 8.

Input: arr[] = {6}
Output: 1

Naive Approach: The simplest approach is to generate all possible non-empty subsets of the given array arr[] and store the Bitwise XOR of all subsets in a set. After generating all the subsets, print the size of the set obtained as the result.



Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Stores the Bitwise XOR
// of every possible subset
unordered_set<int> s;
 
// Function to generate all
// combinations of subsets and
// store their Bitwise XOR in set S
void countXOR(int arr[], int comb[],
              int start, int end,
              int index, int r)
{
    // If the end of the
    // subset is reached
    if (index == r) {
 
        // Stores the Bitwise XOR
        // of the current subset
        int new_xor = 0;
 
        // Iterate comb[] to find XOR
        for (int j = 0; j < r; j++) {
            new_xor ^= comb[j];
        }
 
        // Insert the Bitwise
        // XOR of R elements
        s.insert(new_xor);
        return;
    }
 
    // Otherwise, iterate to
    // generate all possible subsets
    for (int i = start;
         i <= end && end - i + 1 >= r - index; i++) {
        comb[index] = arr[i];
 
        // Recursive call for next index
        countXOR(arr, comb, i + 1, end,
                 index + 1, r);
    }
}
 
// Function to find the size of the
// set having Bitwise XOR of all the
// subsets of the given array
void maxSizeSet(int arr[], int N)
{
    // Iterate ove the given array
    for (int r = 2; r <= N; r++) {
        int comb[r + 1];
 
        // Generate all possible subsets
        countXOR(arr, comb, 0, N - 1,
                 0, r);
    }
 
    // Print the size of the set
    cout << s.size() << endl;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    maxSizeSet(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Stores the Bitwise XOR
// of every possible subset
static HashSet<Integer> s;
 
// Function to generate all
// combinations of subsets and
// store their Bitwise XOR in set S
static void countXOR(int arr[], int comb[],
                     int start, int end,
                     int index, int r)
{
     
    // If the end of the
    // subset is reached
    if (index == r)
    {
         
        // Stores the Bitwise XOR
        // of the current subset
        int new_xor = 0;
 
        // Iterate comb[] to find XOR
        for(int j = 0; j < r; j++)
        {
            new_xor ^= comb[j];
        }
 
        // Insert the Bitwise
        // XOR of R elements
        s.add(new_xor);
        return;
    }
 
    // Otherwise, iterate to
    // generate all possible subsets
    for(int i = start;
            i <= end && end - i + 1 >= r - index;
            i++)
    {
        comb[index] = arr[i];
 
        // Recursive call for next index
        countXOR(arr, comb, i + 1, end, index + 1, r);
    }
}
 
// Function to find the size of the
// set having Bitwise XOR of all the
// subsets of the given array
static void maxSizeSet(int arr[], int N)
{
     
    // Iterate ove the given array
    for(int r = 1; r <= N; r++)
    {
        int comb[] = new int[r + 1];
 
        // Generate all possible subsets
        countXOR(arr, comb, 0, N - 1, 0, r);
    }
 
    // Print the size of the set
    System.out.println(s.size());
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = arr.length;
 
    // Initialize set
    s = new HashSet<>();
 
    // Function Call
    maxSizeSet(arr, N);
}
}
 
// This code is contributed by Kingash
Output: 
8

 

Time Complexity: O(NN)
Auxiliary Space: O(N)

Efficient approach: The above approach can be optimized by using the Greedy Approach and Gaussian Elimination. Follow the steps below to solve the problem: 

  • Initialize an auxiliary array, say dp[] of size 20, that stores the mask of each array element and initializes it with 0.
  • Initialize a variable, say ans as 0, to store the size of the array dp[].
  • Traverse the given array arr[] and for each array element arr[], perform the following steps:
    • Initialize a variable, say mask as arr[i], to check the position of the most significant set bit.
    • If the ith bit from the right of arr[i] is set and dp[i] is 0, then update the array dp[i] as 2i and increment the value of ans by 1 and break out of the loop.
    • Otherwise, update the value of the mask as the Bitwise XOR of the mask and dp[i].
  • After completing the above steps, print the value of 2ans as the resultant size of the required set of elements.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
int const size = 20;
 
// Stores the mask of the vector
int dp[size];
 
// Stores the current size of dp[]
int ans;
 
// Function to store the
// mask of given integer
void insertVector(int mask)
{
    // Iterate over the range [0, 20]
    for (int i = 0; i < 20; i++) {
 
        // If i-th bit 0
        if ((mask & 1 << i) == 0)
            continue;
 
        // If dp[i] is zero
        if (!dp[i]) {
 
            // Store the postion in dp
            dp[i] = mask;
 
            // Increment the answer
            ++ans;
 
            // Return from the loop
            return;
        }
 
        // mask = mask XOR dp[i]
        mask ^= dp[i];
    }
}
 
// Function to find the size of the
// set having Bitwise XOR of all the
// subset of the given array
void maxSizeSet(int arr[], int N)
{
    // Traverse the array
    for (int i = 0; i < N; i++) {
        insertVector(arr[i]);
    }
 
    // Print the answer
    cout << (1 << ans) << endl;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    maxSizeSet(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
class GFG{
  final static int size = 20;
 
  // Stores the mask of the vector
  static int[] dp = new int[size];
 
  // Stores the current size of dp[]
  static int ans;
 
  // Function to store the
  // mask of given integer
  static void insertVector(int mask)
  {
    // Iterate over the range [0, 20]
    for (int i = 0; i < 20; i++) {
 
      // If i-th bit 0
      if ((mask & 1 << i) == 0)
        continue;
 
      // If dp[i] is zero
      if (dp[i]==0) {
 
        // Store the postion in dp
        dp[i] = mask;
 
        // Increment the answer
        ++ans;
 
        // Return from the loop
        return;
      }
 
      // mask = mask XOR dp[i]
      mask ^= dp[i];
    }
  }
 
  // Function to find the size of the
  // set having Bitwise XOR of all the
  // subset of the given array
  static void maxSizeSet(int[] arr, int N)
  {
     
    // Traverse the array
    for (int i = 0; i < N; i++) {
      insertVector(arr[i]);
    }
 
    // Print the answer
    System.out.println(1<<ans);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int[] arr = { 1, 2, 3, 4, 5 };
    int N = arr.length;
 
    // Function Call
    maxSizeSet(arr, N);
  }
}
 
//This code is contributed by Hritik Dwivedi

Python3




# Python3 program for the above approach
 
# Stores the mask of the vector
dp = [0]*20
 
# Stores the current 20 of dp[]
ans = 0
 
# Function to store the
# mask of given integer
def insertVector(mask):
    global dp, ans
     
    # Iterate over the range [0, 20]
    for i in range(20):
 
        # If i-th bit 0
        if ((mask & 1 << i) == 0):
            continue
 
        # If dp[i] is zero
        if (not dp[i]):
 
            # Store the postion in dp
            dp[i] = mask
 
            # Increment the answer
            ans += 1
 
            # Return from the loop
            return
 
        # mask = mask XOR dp[i]
        mask ^= dp[i]
 
# Function to find the 20 of the
# set having Bitwise XOR of all the
# subset of the given array
def maxSizeSet(arr, N):
   
    # Traverse the array
    for i in range(N):
        insertVector(arr[i])
 
    # Prthe answer
    print ((1 << ans))
 
# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5]
    N = len(arr)
 
    # Function Call
    maxSizeSet(arr, N)
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
 
class GFG{
     
static int size = 20;
 
// Stores the mask of the vector
static int[] dp = new int[size];
 
// Stores the current size of dp[]
static int ans;
 
// Function to store the
// mask of given integer
static void insertVector(int mask)
{
     
    // Iterate over the range [0, 20]
    for(int i = 0; i < 20; i++)
    {
         
        // If i-th bit 0
        if ((mask & 1 << i) == 0)
            continue;
 
        // If dp[i] is zero
        if (dp[i] == 0)
        {
             
            // Store the postion in dp
            dp[i] = mask;
 
            // Increment the answer
            ++ans;
 
            // Return from the loop
            return;
        }
 
        // mask = mask XOR dp[i]
        mask ^= dp[i];
    }
}
 
// Function to find the size of the
// set having Bitwise XOR of all the
// subset of the given array
static void maxSizeSet(int[] arr, int N)
{
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        insertVector(arr[i]);
    }
 
    // Print the answer
    Console.WriteLine(1 << ans);
}
 
// Driver code
public static void Main(string[] args)
{
    int[] arr = { 1, 2, 3, 4, 5 };
    int N = arr.Length;
 
    // Function Call
    maxSizeSet(arr, N);
}
}
 
// This code is contributed by ukasp
Output: 
8

 

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :