# 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 5 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.

Implementation:

## 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[0]);``    ``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 point i of subarrays``    ``for` `i ``in` `range``(``0``,n):``        ` `        ``xorSum ``=` `0` `# Store XOR of current subarray`` ` `        ``# Pick ending point 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

 ``

## Javascript

 ``

Output
`Number of subarrays having given XOR is 4`

Time Complexity: O(n2)

Auxiliary Space: O(1)

Efficient Approach:

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.```

Implementation:

## 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[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 + ((``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[0]);``    ``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[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[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`

## Javascript

 ``

Output
`Number of subarrays having given XOR is 4`

Time Complexity: O(n)

Auxiliary Space: O(n)

Alternate Approach: Using Python Dictionary to store Prefix XOR

Implementation:

## C++

 `#include ` `using` `namespace` `std;`  `//Function to return the XOR of all subarrays``int` `subarrayXor(``int` `arr[], ``int` `n, ``int` `m)``{``      ``//declaring the hashtable``      ``//and initializing it with a count of 1 ``      ``//for 0``    ``unordered_map <``int``, ``int``> HashTable;``    ``HashTable[0] = 1;``    ``int` `count = 0, curSum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``curSum ^= arr[i];``        ``if` `(HashTable[curSum ^ m] > 0)``            ``count += HashTable[curSum ^ m];``        ``HashTable[curSum]++;``    ``}``    ``return``(count);``}``        `  `// Driver program to test above function ``int` `main()``{``    ``int` `arr[] = { 5, 6, 7, 8, 9 }; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `m = 5;``    ` `    ``//Function call``    ``cout << ``"Number of subarrays having given XOR is "` `<< subarrayXor(arr, n, m);``}`  `// This code is contributed by phasing17`

## Java

 `// Java program to implement the approach``import` `java.util.*;` `class` `GFG ``{` `  ``// Function to return the XOR of all subarrays``  ``static` `int` `subarrayXor(``int``[] arr, ``int` `n, ``int` `m)``  ``{` `    ``// declaring the hashtable``    ``// and initializing it with a count of 1``    ``// for 0``    ``HashMap HashTable``      ``= ``new` `HashMap<>();` `    ``HashTable.put(``0``, ``1``);``    ``int` `count = ``0``, curSum = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``curSum ^= arr[i];``      ``if` `(HashTable.containsKey(curSum ^ m))``        ``count += HashTable.get(curSum ^ m);``      ``if` `(!HashTable.containsKey(curSum))``        ``HashTable.put(curSum, ``0``);``      ``HashTable.put(curSum,``                    ``HashTable.get(curSum) + ``1``);``    ``}``    ``return` `(count);``  ``}` `  ``// Driver program to test above function``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] arr = { ``5``, ``6``, ``7``, ``8``, ``9` `};``    ``int` `n = arr.length;``    ``int` `m = ``5``;` `    ``// Function call``    ``System.out.println(``      ``"Number of subarrays having given XOR is "``      ``+ subarrayXor(arr, n, m));``  ``}``}` `// This code is contributed by phasing17`

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

## C#

 `// Include namespace system``using` `System;``using` `System.Collections.Generic;``using` `System.Collections;` `public` `class` `GFG``{``  ` `    ``// Function to return the XOR of all subarrays``    ``public` `static` `int` `subarrayXor(``int``[] arr, ``int` `n, ``int` `m)``    ``{``      ` `        ``// declaring the hashtable``        ``// and initializing it with a count of 1``        ``// for 0``        ``var` `HashTable = ``new` `Dictionary<``int``, ``int``>();``        ``HashTable[0] = 1;``        ``var` `count = 0;``        ``var` `curSum = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``curSum ^= arr[i];``            ``if` `(HashTable.ContainsKey(curSum ^ m))``            ``{``                ``count += HashTable[curSum ^ m];``            ``}``            ``if` `(!HashTable.ContainsKey(curSum))``            ``{``                ``HashTable[curSum] = 0;``            ``}``            ``HashTable[curSum] = HashTable[curSum] + 1;``        ``}``        ``return` `(count);``    ``}``  ` `    ``// Driver program to test above function``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = {5, 6, 7, 8, 9};``        ``var` `n = arr.Length;``        ``var` `m = 5;``      ` `        ``// Function call``        ``Console.WriteLine(``"Number of subarrays having given XOR is "` `+ GFG.subarrayXor(arr, n, m).ToString());``    ``}``}` `// This code is contributed by aadityaburujwale.`

## Javascript

 ``

Output
`Number of subarrays having given XOR is 2`

Time Complexity: O(n)

Auxiliary Space: O(n)

Previous
Next
Share your thoughts in the comments
Similar Reads