Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Length of the longest subarray whose Bitwise XOR is K

  • Difficulty Level : Basic
  • Last Updated : 17 May, 2021

Given an array arr[] of size N and an integer K, the task is to find the length of the longest subarray having Bitwise XOR of all its elements equal to K.

Examples:

Input: arr[] = { 1, 2, 4, 7, 2 }, K = 1
Output: 3
Explanation: 
Subarray having Bitwise XOR equal to K(= 1) are { { 1 }, { 2, 4, 7 }, { 1 } }.
Therefore, the length of longest subarray having bitwise XOR equal to K(= 1) is 3

Input: arr[] = { 2, 5, 6, 1, 0, 3, 5, 6 }, K = 4
Output: 6
Explanation:
Subarray having Bitwise XOR equal to K(= 4) are { { 6, 1, 0, 3 }, { 5, 6, 1, 0, 3, 5 } }.
Therefore, the length of longest subarray having bitwise XOR equal to K(= 4) is 6.

Approach: The problem can be solved using Hashing and Prefix Sum technique. Following are the observation:

a1 ^ a2 ^ a3 ^ ….. ^ an = K

=> a2 ^ a3 ^ ….. ^ an ^ K = a1

Follow the steps below to solve the problem:

  • Initialize a variable, say prefixXOR, to store the Bitwise XOR of all elements up to the ith index of the given array.
  • Initialize a Map, say mp, to store the indices of the computed prefix XORs of the array.
  • Initialize a variable, say maxLen, to store the length of the longest subarray whose Bitwise XOR is equal to K.
  • Traverse the array arr[] using variable i. For every ith index, update prefixXOR = prefixXOR ^ arr[i] and check if (prefixXOR ^ K) is present in the Map or not. If found to be true, then update maxLen = max(maxLen, i – mp[prefixXOR ^ K]).
  • If prefixXOR is not present in the Map, then insert prefixXOR into the Map.
  • Finally, print the value of maxLen.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the length of the longest
// subarray whose bitwise XOR is equal to K
int LongestLenXORK(int arr[], int N, int K)
{
     
    // Stores prefix XOR
    // of the array
    int prefixXOR = 0;
 
    // Stores length of longest subarray
    // having bitwise XOR equal to K
    int maxLen = 0;
 
    // Stores index of prefix
    // XOR of the array
    map<int, int> mp;
     
     
    // Insert 0 into the map
    mp[0] = -1;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update prefixXOR
        prefixXOR ^= arr[i];
 
        // If (prefixXOR ^ K) present
        // in the map
        if (mp.count(prefixXOR ^ K)) {
 
            // Update maxLen
            maxLen = max(maxLen,
               (i - mp[prefixXOR ^ K]));
        }
         
        // If prefixXOR not present
        // in the Map
        if (!mp.count(prefixXOR)) {
 
            // Insert prefixXOR
            // into the map
            mp[prefixXOR] = i;
        }
    }
     
    return maxLen;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 4, 7, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 1;
    cout<< LongestLenXORK(arr, N, K);
 
    return 0;
}
Java



// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to find the length of the longest
// subarray whose bitwise XOR is equal to K
static int LongestLenXORK(int arr[],
                          int N, int K)
{
     
    // Stores prefix XOR
    // of the array
    int prefixXOR = 0;
 
    // Stores length of longest subarray
    // having bitwise XOR equal to K
    int maxLen = 0;
 
    // Stores index of prefix
    // XOR of the array
    HashMap<Integer,
            Integer> mp = new HashMap<Integer,
                                      Integer>();
                                       
    // Insert 0 into the map
    mp.put(0, -1);
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update prefixXOR
        prefixXOR ^= arr[i];
 
        // If (prefixXOR ^ K) present
        // in the map
        if (mp.containsKey(prefixXOR ^ K))
        {
             
            // Update maxLen
            maxLen = Math.max(maxLen,
               (i - mp.get(prefixXOR ^ K)));
        }
         
        // If prefixXOR not present
        // in the Map
        if (!mp.containsKey(prefixXOR))
        {
             
            // Insert prefixXOR
            // into the map
            mp.put(prefixXOR, i);
        }
    }
    return maxLen;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 4, 7, 2 };
    int N = arr.length;
    int K = 1;
     
    System.out.print(LongestLenXORK(arr, N, K));
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program to implement
# the above approach
 
# Function to find the length of the longest
# subarray whose bitwise XOR is equal to K
def LongestLenXORK(arr, N, K):
     
    # Stores prefix XOR
    # of the array
    prefixXOR = 0
 
    # Stores length of longest subarray
    # having bitwise XOR equal to K
    maxLen = 0
 
    # Stores index of prefix
    # XOR of the array
    mp = {}
 
    # Insert 0 into the map
    mp[0] = -1
 
    # Traverse the array
    for i in range(N):
         
        # Update prefixXOR
        prefixXOR ^= arr[i]
 
        # If (prefixXOR ^ K) present
        # in the map
        if (prefixXOR ^ K) in mp:
             
            # Update maxLen
            maxLen = max(maxLen,
                        (i - mp[prefixXOR ^ K]))
 
        # If prefixXOR not present
        # in the Map
        else:
             
            # Insert prefixXOR
            # into the map
            mp[prefixXOR] = i
       
    return maxLen
 
# Driver Code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 4, 7, 2 ]
    N = len(arr)
    K = 1
     
    print(LongestLenXORK(arr, N, K))
 
# This code is contributed by AnkThon
C#



// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG
{
 
// Function to find the length of the longest
// subarray whose bitwise XOR is equal to K
static int longestLenXORK(int []arr,
                          int N, int K)
{
     
    // Stores prefix XOR
    // of the array
    int prefixXOR = 0;
 
    // Stores length of longest subarray
    // having bitwise XOR equal to K
    int maxLen = 0;
 
    // Stores index of prefix
    // XOR of the array
    Dictionary<int,
            int> mp = new Dictionary<int,
                                      int>();
                                       
    // Insert 0 into the map
    mp.Add(0, -1);
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update prefixXOR
        prefixXOR ^= arr[i];
 
        // If (prefixXOR ^ K) present
        // in the map
        if (mp.ContainsKey(prefixXOR ^ K))
        {
             
            // Update maxLen
            maxLen = Math.Max(maxLen,
               (i - mp[prefixXOR ^ K]));
        }
         
        // If prefixXOR not present
        // in the Map
        if (!mp.ContainsKey(prefixXOR))
        {
             
            // Insert prefixXOR
            // into the map
            mp.Add(prefixXOR, i);
        }
    }
    return maxLen;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = {1, 2, 4, 7, 2};
    int N = arr.Length;
    int K = 1;
     
    Console.Write(longestLenXORK(arr, N, K));
}
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
 
// JavaScript program to implement
// the above approach
 
// Function to find the length of the longest
// subarray whose bitwise XOR is equal to K
function LongestLenXORK(arr, N, K)
{
     
    // Stores prefix XOR
    // of the array
    var prefixXOR = 0;
 
    // Stores length of longest subarray
    // having bitwise XOR equal to K
    var maxLen = 0;
 
    // Stores index of prefix
    // XOR of the array
    var mp = new Map();
     
     
    // Insert 0 into the map
    mp.set(0, -1);
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Update prefixXOR
        prefixXOR ^= arr[i];
 
        // If (prefixXOR ^ K) present
        // in the map
        if (mp.has(prefixXOR ^ K)) {
 
            // Update maxLen
            maxLen = Math.max(maxLen,
               (i - mp.get(prefixXOR ^ K)));
        }
         
        // If prefixXOR not present
        // in the Map
        if (!mp.has(prefixXOR)) {
 
            // Insert prefixXOR
            // into the map
            mp.set(prefixXOR, i);
        }
    }
     
    return maxLen;
}
 
// Driver Code
var arr = [1, 2, 4, 7, 2];
var N =  arr.length;
var K = 1;
document.write( LongestLenXORK(arr, N, K));
 
</script>
Output:
3
Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes
arrow_drop_up
Next

Minimize cost to reduce array to a single element by replacing K consecutive elements by their sum
Recommended Articles
Page :
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
07, May 19
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array
18, Mar 21
Find a K-length subarray having Bitwise XOR equal to that of remaining array elements
17, Jan 21
Length of longest subsequence whose XOR value is odd
15, Jul 20
Count ways to generate pairs having Bitwise XOR and Bitwise AND equal to X and Y respectively
16, Sep 20
Count pairs with bitwise XOR exceeding bitwise AND from a given array
04, Oct 20
Find all possible pairs with given Bitwise OR and Bitwise XOR values
31, May 21
Find the triplet from given Bitwise XOR and Bitwise AND values of all its pairs
10, Dec 20
Count pairs with odd Bitwise XOR that can be removed and replaced by their Bitwise OR
25, Mar 21
Bitwise XOR of Bitwise AND of all pairs from two given arrays
06, May 21
Split an array into subarrays with maximum Bitwise XOR of their respective Bitwise OR values
14, Jun 21
Find size of largest subset with bitwise AND greater than their bitwise XOR
25, Nov 21
Leftover element after performing alternate Bitwise OR and Bitwise XOR operations on adjacent pairs
01, Apr 18
Length of longest subarray whose sum is not divisible by integer K
14, Jul 20
Find maximum product of Bitwise AND and Bitwise OR of K-size subarray
06, Dec 21
Bitwise XOR of same indexed array elements after rearranging an array to make XOR of same indexed elements of two arrays equal
05, Aug 21
Count pairs from an array whose Bitwise OR is greater than Bitwise AND
08, Feb 21
Queries to update each element in subarray to Bitwise XOR with a given value
17, Jul 20
Count of subarrays in range [L, R] having XOR + 1 equal to XOR (XOR) 1 for M queries
26, Oct 21
Length of longest subarray of length at least 2 with maximum GCD
07, May 20
Find N distinct numbers whose Bitwise XOR is equal to K
10, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
papansarkar101
@papansarkar101
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!