Open In App

Count distinct possible Bitwise XOR values of subsets of an array

Improve
Improve
Like Article
Like
Save
Share
Report

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 over 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 over 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


Python3




# Python3 program for the above approach
 
# Stores the Bitwise XOR
# of every possible subset
s = set([])
  
# Function to generate all
# combinations of subsets and
# store their Bitwise XOR in set S
def countXOR(arr, comb, start, end, index, r):
 
    # If the end of the
    # subset is reached
    if (index == r) :
  
        # Stores the Bitwise XOR
        # of the current subset
        new_xor = 0
  
        # Iterate comb[] to find XOR
        for j in range(r):
            new_xor ^= comb[j]
  
        # Insert the Bitwise
        # XOR of R elements
        s.add(new_xor)
        return
  
    # Otherwise, iterate to
    # generate all possible subsets
    i = start
    while i <= end and (end - i + 1) >= (r - index):
        comb[index] = arr[i]
  
        # Recursive call for next index
        countXOR(arr, comb, i + 1, end, index + 1, r)
        i += 1
  
# Function to find the size of the
# set having Bitwise XOR of all the
# subsets of the given array
def maxSizeSet(arr, N):
 
    # Iterate over the given array
    for r in range(2, N + 1):
        comb = [0]*(r + 1)
  
        # Generate all possible subsets
        countXOR(arr, comb, 0, N - 1, 0, r)
  
    # Print the size of the set
    print(len(s))
 
arr = [ 1, 2, 3, 4, 5 ]
N = len(arr)
 
# Function Call
maxSizeSet(arr, N)
 
# This code is contributed by decode2207.


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
public class GFG
{
 
// Stores the Bitwise XOR
// of every possible subset
static HashSet<int> 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 over 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
    Console.WriteLine(s.Count);
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3, 4, 5 };
    int N = arr.Length;
 
    // Initialize set
    s = new HashSet<int>();
 
    // Function Call
    maxSizeSet(arr, N);
}
}
 
// This code is contributed by Amit Katiyar


Javascript




<script>
 
// JavaScript program for the above approach
 
// Stores the Bitwise XOR
// of every possible subset
let s;
 
// Function to generate all
// combinations of subsets and
// store their Bitwise XOR in set S
function countXOR(arr,comb,start,end,index,r)
{
    // If the end of the
    // subset is reached
    if (index == r)
    {
          
        // Stores the Bitwise XOR
        // of the current subset
        let new_xor = 0;
  
        // Iterate comb[] to find XOR
        for(let 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(let 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
function maxSizeSet(arr,N)
{
    // Iterate over the given array
    for(let r = 1; r <= N; r++)
    {
        let comb = new Array(r + 1);
  
        // Generate all possible subsets
        countXOR(arr, comb, 0, N - 1, 0, r);
    }
  
    // Print the size of the set
    document.write(s.size);
}
 
// Driver Code
let arr=[1, 2, 3, 4, 5 ];
let N = arr.length;
 
// Initialize set
s = new Set();
 
// Function Call
maxSizeSet(arr, N);
 
// This code is contributed by avanitrachhadiya2155
 
</script>


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 position 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 position 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 position 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])
 
    # Print the 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 position 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


Javascript




<script>
 
// Javascript program for the above approach
let size = 20;
 
// Stores the mask of the vector
var dp = new Array(size).fill(0);
 
// Stores the current size of dp[]
let ans = 0;
 
// Function to store the
// mask of given integer
function insertVector(mask)
{
     
    // Iterate over the range [0, 20]
    for(let 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 position 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
function maxSizeSet(arr, N)
{
     
    // Traverse the array
    for(let i = 0; i < N; i++)
    {
        insertVector(arr[i]);
    }
     
    // Print the answer
    document.write(1<<ans);
}
 
// Driver Code
let arr = [ 1, 2, 3, 4, 5 ];
let N = arr.length;
 
// Function Call
maxSizeSet(arr, N);
 
// This code is contributed by nitin_sharma   
     
</script>


Output: 

8

 

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



Last Updated : 28 Feb, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads