# 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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 ``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 mp = ``new` `HashMap();``                                      ` `    ``// 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

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up