# Count the number of subarrays having a given XOR

Given an array of integers arr[] and a number m, count the number of subarrays having XOR of their elements as m.
Examples:

```Input : arr[] = {4, 2, 2, 6, 4}, m = 6
Output : 4
Explanation : The subarrays having XOR of
their elements as 6 are {4, 2},
{4, 2, 2, 6, 4}, {2, 2, 6},
and {6}

Input : arr[] = {5, 6, 7, 8, 9}, m = 5
Output : 2
Explanation : The subarrays having XOR of
their elements as 2 are {5}
and {5, 6, 7, 8, 9}

```

A Simple Solution is to use two loops to go through all possible subarrays of arr[] and count the number of subarrays having XOR of their elements as m.

## C++

 `// A simple C++ Program to count all subarrays having` `// XOR of elements as given value m` `#include ` `using` `namespace` `std;`   `// Simple function that returns count of subarrays` `// of arr with XOR value equals to m` `long` `long` `subarrayXor(``int` `arr[], ``int` `n, ``int` `m)` `{` `    ``long` `long` `ans = 0; ``// Initialize ans`   `    ``// Pick starting point i of subarrays` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `xorSum = 0; ``// Store XOR of current subarray`   `        ``// Pick ending point j of subarray for each i` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``// calculate xorSum` `            ``xorSum = xorSum ^ arr[j];`   `            ``// If xorSum is equal to given value,` `            ``// increase ans by 1.` `            ``if` `(xorSum == m)` `                ``ans++;` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `arr[] = { 4, 2, 2, 6, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `m = 6;`   `    ``cout << ``"Number of subarrays having given XOR is "` `         ``<< subarrayXor(arr, n, m);` `    ``return` `0;` `}`

## Java

 `// A simple Java Program to count all` `// subarrays having XOR of elements ` `// as given value m` `public` `class` `GFG {`   `    ``// Simple function that returns` `    ``// count of subarrays of arr with` `    ``// XOR value equals to m` `    ``static` `long` `subarrayXor(``int` `arr[],` `                             ``int` `n, ``int` `m)` `    ``{` `        `  `        ``// Initialize ans` `        ``long` `ans = ``0``;`   `        ``// Pick starting point i of` `        ``// subarrays` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{` `            `  `            ``// Store XOR of current` `            ``// subarray` `            ``int` `xorSum = ``0``;`   `            ``// Pick ending point j of ` `            ``// subarray for each i` `            ``for` `(``int` `j = i; j < n; j++)` `            ``{` `                `  `                ``// calculate xorSum` `                ``xorSum = xorSum ^ arr[j];`   `                ``// If xorSum is equal to` `                ``// given value, increase` `                ``// ans by 1.` `                ``if` `(xorSum == m)` `                    ``ans++;` `            ``}` `        ``}` `        `  `        ``return` `ans;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{`   `        ``int``[] arr = { ``4``, ``2``, ``2``, ``6``, ``4` `};` `        ``int` `n = arr.length;` `        ``int` `m = ``6``;`   `        ``System.out.println(``"Number of subarrays"` `                       ``+ ``" having given XOR is "` `                       ``+ subarrayXor(arr, n, m));` `    ``}` `}`   `// This code is contributed by Sam007.`

## Python3

 `    `  `# A simple Python3 Program to count all subarrays having` `# XOR of elements as given value m` ` `  `# Simple function that returns count of subarrays` `# of arr with XOR value equals to m` `def` `subarrayXor(arr, n, m):` `    ``ans ``=` `0` `# Initialize ans` ` `  `    ``# Pick starting po i of subarrays` `    ``for` `i ``in` `range``(``0``,n):` `        `  `        ``xorSum ``=` `0` `# Store XOR of current subarray` ` `  `        ``# Pick ending po j of subarray for each i` `        ``for` `j  ``in` `range``(i,n):` `            ``# calculate xorSum` `            ``xorSum ``=` `xorSum ^ arr[j]` ` `  `            ``# If xorSum is equal to given value,` `            ``# increase ans by 1.` `            ``if` `(xorSum ``=``=` `m):` `                ``ans``+``=``1` `    ``return` `ans` ` `  `# Driver program to test above function` `def` `main():` `    ``arr ``=` `[ ``4``, ``2``, ``2``, ``6``, ``4` `]` `    ``n ``=` `len``(arr)` `    ``m ``=` `6` ` `  `    ``print``(``"Number of subarrays having given XOR is "` `         ``, subarrayXor(arr, n, m))`   `if` `__name__ ``=``=` `'__main__'``:` `    ``main()` `    `  `#this code contributed by 29AjayKumar`

## C#

 `// A simple C# Program to count all` `// subarrays having XOR of elements` `// as given value m` `using` `System;`   `class` `GFG {` `    `  `    ``// Simple function that returns` `    ``// count of subarrays of arr ` `    ``// with XOR value equals to m` `    ``static` `long` `subarrayXor(``int``[] arr,` `                            ``int` `n, ``int` `m)` `    ``{` `        `  `        ``// Initialize ans` `        ``long` `ans = 0;`   `        ``// Pick starting point i of ` `        ``// subarrays` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            `  `            ``// Store XOR of current` `            ``// subarray` `            ``int` `xorSum = 0;`   `            ``// Pick ending point j of ` `            ``// subarray for each i` `            ``for` `(``int` `j = i; j < n; j++)` `            ``{` `                `  `                ``// calculate xorSum` `                ``xorSum = xorSum ^ arr[j];`   `                ``// If xorSum is equal to` `                ``// given value, increase` `                ``// ans by 1.` `                ``if` `(xorSum == m)` `                    ``ans++;` `            ``}` `        ``}` `        `  `        ``return` `ans;` `    ``}`   `    ``// Driver Program` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 4, 2, 2, 6, 4 };` `        ``int` `n = arr.Length;` `        ``int` `m = 6;`   `        ``Console.Write(``"Number of subarrays"` `                  ``+ ``" having given XOR is "` `                  ``+ subarrayXor(arr, n, m));` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 ``

Output:

```Number of subarrays having given XOR is 4
```

The Time Complexity of the above solution is O(n2).

An Efficient Solution solves the above problem in O(n) time. Let us call the XOR of all elements in the range [i+1, j] as A, in the range [0, i] as B, and in the range [0, j] as C. If we do XOR of B with C, the overlapping elements in [0, i] from B and C zero out, and we get XOR of all elements in the range [i+1, j], i.e. A. Since A = B XOR C, we have B = A XOR C. Now, if we know the value of C and we take the value of A as m, we get the count of A as the count of all B satisfying this relation. Essentially, we get the count of all subarrays having XOR-sum m for each C. As we take the sum of this count overall C, we get our answer.

```1) Initialize ans as 0.
2) Compute xorArr, the prefix xor-sum array.
3) Create a map mp in which we store count of
all prefixes with XOR as a particular value.
4) Traverse xorArr and for each element in xorArr
(A) If m^xorArr[i] XOR exists in map, then
there is another previous prefix with
same XOR, i.e., there is a subarray ending
at i with XOR equal to m. We add count of
all such subarrays to result.
(B) If xorArr[i] is equal to m, increment ans by 1.
(C) Increment count of elements having XOR-sum
xorArr[i] in map by 1.
5) Return ans.

```

## C++

 `// C++ Program to count all subarrays having` `// XOR of elements as given value m with` `// O(n) time complexity.` `#include ` `using` `namespace` `std;`   `// Returns count of subarrays of arr with XOR` `// value equals to m` `long` `long` `subarrayXor(``int` `arr[], ``int` `n, ``int` `m)` `{` `    ``long` `long` `ans = 0; ``// Initialize answer to be returned`   `    ``// Create a prefix xor-sum array such that` `    ``// xorArr[i] has value equal to XOR` `    ``// of all elements in arr[0 ..... i]` `    ``int``* xorArr = ``new` `int``[n];`   `    ``// Create map that stores number of prefix array` `    ``// elements corresponding to a XOR value` `    ``unordered_map<``int``, ``int``> mp;`   `    ``// Initialize first element of prefix array` `    ``xorArr = arr;`   `    ``// Computing the prefix array.` `    ``for` `(``int` `i = 1; i < n; i++)` `        ``xorArr[i] = xorArr[i - 1] ^ arr[i];`   `    ``// Calculate the answer` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Find XOR of current prefix with m.` `        ``int` `tmp = m ^ xorArr[i];`   `        ``// If above XOR exists in map, then there` `        ``// is another previous prefix with same` `        ``// XOR, i.e., there is a subarray ending` `        ``// at i with XOR equal to m.` `        ``ans = ans + ((``long` `long``)mp[tmp]);`   `        ``// If this subarray has XOR equal to m itself.` `        ``if` `(xorArr[i] == m)` `            ``ans++;`   `        ``// Add the XOR of this subarray to the map` `        ``mp[xorArr[i]]++;` `    ``}`   `    ``// Return total count of subarrays having XOR of` `    ``// elements as given value m` `    ``return` `ans;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `arr[] = { 4, 2, 2, 6, 4 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `m = 6;`   `    ``cout << ``"Number of subarrays having given XOR is "` `         ``<< subarrayXor(arr, n, m);` `    ``return` `0;` `}`

## Java

 `// Java Program to count all subarrays having` `// XOR of elements as given value m with` `// O(n) time complexity.` `import` `java.util.*;`   `class` `GFG` `{`   `    ``// Returns count of subarrays of arr with XOR` `    ``// value equals to m` `    ``static` `long` `subarrayXor(``int` `arr[], ``int` `n, ``int` `m)` `    ``{` `        ``long` `ans = ``0``; ``// Initialize answer to be returned`   `        ``// Create a prefix xor-sum array such that` `        ``// xorArr[i] has value equal to XOR` `        ``// of all elements in arr[0 ..... i]` `        ``int``[] xorArr = ``new` `int``[n];`   `        ``// Create map that stores number of prefix array` `        ``// elements corresponding to a XOR value` `        ``HashMap mp = ``new` `HashMap();`   `        ``// Initialize first element of prefix array` `        ``xorArr[``0``] = arr[``0``];`   `        ``// Computing the prefix array.` `        ``for` `(``int` `i = ``1``; i < n; i++)` `            ``xorArr[i] = xorArr[i - ``1``] ^ arr[i];`   `        ``// Calculate the answer` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{` `            ``// Find XOR of current prefix with m.` `            ``int` `tmp = m ^ xorArr[i];`   `            ``// If above XOR exists in map, then there` `            ``// is another previous prefix with same` `            ``// XOR, i.e., there is a subarray ending` `            ``// at i with XOR equal to m.` `            ``ans = ans + (mp.containsKey(tmp) == ``false` `? ``0` `: ((``long``) mp.get(tmp)));`   `            ``// If this subarray has XOR equal to m itself.` `            ``if` `(xorArr[i] == m)` `                ``ans++;`   `            ``// Add the XOR of this subarray to the map` `            ``if` `(mp.containsKey(xorArr[i]))` `                ``mp.put(xorArr[i], mp.get(xorArr[i]) + ``1``);` `            ``else` `                ``mp.put(xorArr[i], ``1``);` `        ``}`   `        ``// Return total count of subarrays having XOR of` `        ``// elements as given value m` `        ``return` `ans;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `arr[] = { ``4``, ``2``, ``2``, ``6``, ``4` `};` `        ``int` `n = arr.length;` `        ``int` `m = ``6``;`   `        ``System.out.print(``"Number of subarrays having given XOR is "` `        ``+ subarrayXor(arr, n, m));` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 Program to count all subarrays ` `# having XOR of elements as given value m ` `# with O(n) time complexity.`   `# Returns count of subarrays of arr ` `# with XOR value equals to m` `def` `subarrayXor(arr, n, m):`   `    ``ans ``=` `0` `# Initialize answer to be returned`   `    ``# Create a prefix xor-sum array such that` `    ``# xorArr[i] has value equal to XOR` `    ``# of all elements in arr[0 ..... i]` `    ``xorArr ``=``[``0` `for` `_ ``in` `range``(n)]`   `    ``# Create map that stores number of prefix array` `    ``# elements corresponding to a XOR value` `    ``mp ``=` `dict``()`   `    ``# Initialize first element ` `    ``# of prefix array` `    ``xorArr[``0``] ``=` `arr[``0``]`   `    ``# Computing the prefix array.` `    ``for` `i ``in` `range``(``1``, n):` `        ``xorArr[i] ``=` `xorArr[i ``-` `1``] ^ arr[i]`   `    ``# Calculate the answer` `    ``for` `i ``in` `range``(n):` `        `  `        ``# Find XOR of current prefix with m.` `        ``tmp ``=` `m ^ xorArr[i]`   `        ``# If above XOR exists in map, then there` `        ``# is another previous prefix with same` `        ``# XOR, i.e., there is a subarray ending` `        ``# at i with XOR equal to m.` `        ``if` `tmp ``in` `mp.keys():` `            ``ans ``=` `ans ``+` `(mp[tmp])`   `        ``# If this subarray has XOR ` `        ``# equal to m itself.` `        ``if` `(xorArr[i] ``=``=` `m):` `            ``ans ``+``=` `1`   `        ``# Add the XOR of this subarray to the map` `        ``mp[xorArr[i]] ``=` `mp.get(xorArr[i], ``0``) ``+` `1`   `    ``# Return total count of subarrays having ` `    ``# XOR of elements as given value m` `    ``return` `ans`   `# Driver Code` `arr ``=` `[``4``, ``2``, ``2``, ``6``, ``4``]` `n ``=` `len``(arr)` `m ``=` `6`   `print``(``"Number of subarrays having given XOR is"``,` `                        ``subarrayXor(arr, n, m))`   `# This code is contributed by mohit kumar`

## C#

 `    `  `// C# Program to count all subarrays having` `// XOR of elements as given value m with` `// O(n) time complexity.` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `    ``// Returns count of subarrays of arr with XOR` `    ``// value equals to m` `    ``static` `long` `subarrayXor(``int` `[]arr, ``int` `n, ``int` `m)` `    ``{` `        ``long` `ans = 0; ``// Initialize answer to be returned`   `        ``// Create a prefix xor-sum array such that` `        ``// xorArr[i] has value equal to XOR` `        ``// of all elements in arr[0 ..... i]` `        ``int``[] xorArr = ``new` `int``[n];`   `        ``// Create map that stores number of prefix array` `        ``// elements corresponding to a XOR value` `        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();`   `        ``// Initialize first element of prefix array` `        ``xorArr = arr;`   `        ``// Computing the prefix array.` `        ``for` `(``int` `i = 1; i < n; i++)` `            ``xorArr[i] = xorArr[i - 1] ^ arr[i];`   `        ``// Calculate the answer` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``// Find XOR of current prefix with m.` `            ``int` `tmp = m ^ xorArr[i];`   `            ``// If above XOR exists in map, then there` `            ``// is another previous prefix with same` `            ``// XOR, i.e., there is a subarray ending` `            ``// at i with XOR equal to m.` `            ``ans = ans + (mp.ContainsKey(tmp) == ``false` `? 0 : ((``long``) mp[tmp]));`   `            ``// If this subarray has XOR equal to m itself.` `            ``if` `(xorArr[i] == m)` `                ``ans++;`   `            ``// Add the XOR of this subarray to the map` `            ``if` `(mp.ContainsKey(xorArr[i]))` `                ``mp[xorArr[i]] = mp[xorArr[i]] + 1;` `            ``else` `                ``mp.Add(xorArr[i], 1);` `        ``}`   `        ``// Return total count of subarrays having XOR of` `        ``// elements as given value m` `        ``return` `ans;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``int` `[]arr = { 4, 2, 2, 6, 4 };` `        ``int` `n = arr.Length;` `        ``int` `m = 6;`   `        ``Console.Write(``"Number of subarrays having given XOR is "` `        ``+ subarrayXor(arr, n, m));` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```Number of subarrays having given XOR is 4

```

Time Complexity: O(n)

Alternate Approach: Using Python Dictionary to store Prefix XOR

## Python3

 `from` `collections ``import` `defaultdict` `def` `subarrayXor(arr, n, m): ` `    ``HashTable``=``defaultdict(``bool``)` `    ``HashTable[``0``]``=``1` `    ``count``=``0` `    ``curSum``=``0` `    ``for` `i ``in` `arr:` `        ``curSum^``=``i` `        ``if` `HashTable[curSum^m]:` `            ``count``+``=``HashTable[curSum^m]` `        ``HashTable[curSum]``+``=``1` `    ``return``(count)` `        `    `# Driver program to test above function ` `def` `main(): ` `    ``arr ``=` `[ ``5``, ``6``, ``7``, ``8``, ``9` `] ` `    ``n ``=` `len``(arr) ` `    ``m ``=` `5`   `    ``print``(``"Number of subarrays having given XOR is "` `        ``, subarrayXor(arr, n, m)) `   `if` `__name__ ``=``=` `'__main__'``: ` `    ``main() ` `    `  ` ``# This code is contributed by mrmechanical26052000`

Output:

`Number of subarrays having given XOR is 4`

Time Complexity: O(n)

Space Complexity: O(n)

This article is contributed by Anmol Ratnam. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

30

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.