Length of the longest subarray whose Bitwise XOR is K

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.

Naive Approach

The idea is to generate all subarrays and find that subarray whose bitwise XOR of all elements is equal to K and has a maximum length

 Steps to Implement:

• Initialize a variable “ans” with 0 because if no such subarray exists then it will be the answer
• Run two for loops from 0 to N-1 to generate all subarray
• For each subarray find the XOR of all elements and its length
• If any XOR value got equal to K then update “ans” as the maximum of “ans” and the length of that subarray
• In the last print/return value in ans

Code-

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)
{
    //To store final answer
    int ans=0;

    //Find all subarray
    for(int i=0;i<N;i++){
        //To store length of subarray
        int length=0;
        //To store XOR of all elements of subarray
        int temp=0;
        for(int j=i;j<N;j++){
            temp=temp^arr[j];
            length++;

            //When XOR of all elements of subarray equal to K
            if(temp==K){
                //Update ans
                ans=max(ans,length);
            }
        }
    }

    return ans;
}

// 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)
    {
        // To store the final answer
        int ans = 0;

        // Find all subarrays
        for (int i = 0; i < N; i++) {
            // To store the length of the subarray
            int length = 0;
            // To store XOR of all elements of the subarray
            int temp = 0;
            for (int j = i; j < N; j++) {
                temp = temp ^ arr[j];
                length++;

                // When XOR of all elements of subarray is
                // equal to K
                if (temp == K) {
                    // Update ans
                    ans = Math.max(ans, length);
                }
            }
        }

        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 4, 7, 2 };
        int N = arr.length;
        int K = 1;
        System.out.println(LongestLenXORK(arr, N, K));
    }
}

Python3

# Python 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):
    # To store final answer
    ans = 0

    # Find all subarray
    for i in range(N):
        # To store length of subarray
        length = 0
        # To store XOR of all elements of subarray
        temp = 0
        for j in range(i, N):
            temp ^= arr[j]
            length += 1

            # When XOR of all elements of subarray equal to K
            if temp == K:
                # Update ans
                ans = max(ans, length)

    return ans

# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 4, 7, 2]
    N = len(arr)
    K = 1
    print(LongestLenXORK(arr, N, K))

C#

using System;

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)
    {
        // To store the final answer
        int ans = 0;

        // Find all subarrays
        for (int i = 0; i < N; i++)
        {
            // To store the length of the subarray
            int length = 0;

            // To store the XOR of all elements of the subarray
            int temp = 0;

            for (int j = i; j < N; j++)
            {
                temp ^= arr[j];
                length++;

                // When XOR of all elements of the subarray is equal to K
                if (temp == K)
                {
                    // Update ans
                    ans = Math.Max(ans, length);
                }
            }
        }

        return ans;
    }

    // Driver Code
    static void Main(string[] args)
    {
        int[] arr = { 1, 2, 4, 7, 2 };
        int N = arr.Length;
        int K = 1;
        Console.WriteLine(LongestLenXORK(arr, N, K));
    }
}

// This code is contributed by Dwaipayan Bandyopadhyay

Javascript

// 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) {
 //To store final answer
    let ans = 0;
//Find all subarray
    for (let i = 0; i < N; i++) {
        let length = 0;
        //To store XOR of all elements of subarray
        let temp = 0;
        for (let j = i; j < N; j++) {
            temp ^= arr[j];
            length += 1;
//When XOR of all elements of subarray equal to K
            if (temp === K) {
            //Update ans
                ans = Math.max(ans, length);
            }
        }
    }
    return ans;
}

// Driver Code
const arr = [1, 2, 4, 7, 2];
const N = arr.length;
const K = 1;
console.log(LongestLenXORK(arr, N, K));

Output-

3

Time Complexity: O(N²), because of two nested loops from 0 to N-1
Auxiliary Space: O(1), because no extra space has been used

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

a₁ ^ a₂ ^ a₃ ^ ….. ^ a_n = K

=> a₂ ^ a₃ ^ ….. ^ a_n ^ K = a₁

Follow the steps below to solve the problem:

• Initialize a variable, say prefixXOR, to store the Bitwise XOR of all elements up to the i^th 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 i^th 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
    unordered_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)