# Count subarrays having odd Bitwise XOR

• Last Updated : 03 Jun, 2021

Given an array arr[] of size N, the task is to count the number of subarrays from the given array having odd Bitwise XOR value.

Examples:

Input: arr[] = {1, 4, 7, 9, 10}
Output: 8
Explanation: The subarrays having odd Bitwise XOR are {1}, {1, 4}, {1, 4, 7, 9}, {1, 4, 7, 9, 10}, {7}, {9}, {4, 7}, {9, 10}.

Input: arr[] ={1, 5, 6}
Output: 3
Explanation: The subarrays having odd Bitwise XOR are {1}, {1, 5}, {1, 5, 6}.

Naive Approach: The simplest approach to solve this problem is to check for every subarray whether its Bitwise XOR is odd or not. If found to be odd, then increase the count. Finally, print the count as the result.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is based on the observation that the Bitwise XOR of the subarray is odd only if the number of odd elements in that subarray is odd. To solve the problem, find the number of subarrays starting from the index 0 and satisfying the given conditions. Then, Traverse the array and update the number of subarrays starting at index i that satisfy the given condition. Follow the steps below to solve the problem:

• Initialize variables Odd, C_odd as 0, to store the number of odd numbers up to ith index and the number of required subarrays starting at ith index respectively.
• Traverse the array arr[] using the variable i and check for the following steps:
• Again, traverse the array arr[] using the variable i and perform the following:
• After completing the above steps, print the value of res as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to count the number of subarrays` `// of the given array having odd Bitwise XOR` `void` `oddXorSubarray(``int` `a[], ``int` `n)` `{` `    ``// Stores number of odd` `    ``// numbers upto i-th index` `    ``int` `odd = 0;`   `    ``// Stores number of required` `    ``// subarrays starting from i-th index` `    ``int` `c_odd = 0;`   `    ``// Store the required result` `    ``int` `result = 0;`   `    ``// Find the number of subarrays having odd` `    ``// Bitwise XOR values starting at 0-th index` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Check if current element is odd` `        ``if` `(a[i] & 1) {` `            ``odd = !odd;` `        ``}`   `        ``// If the current value of odd is not` `        ``// zero, increment c_odd by 1` `        ``if` `(odd) {` `            ``c_odd++;` `        ``}` `    ``}`   `    ``// Find the number of subarrays having odd` `    ``// bitwise XOR value starting at ith index` `    ``// and add to result` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Add c_odd to result` `        ``result += c_odd;` `        ``if` `(a[i] & 1) {` `            ``c_odd = (n - i - c_odd);` `        ``}` `    ``}`   `    ``// Print the result` `    ``cout << result;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array` `    ``int` `arr[] = { 1, 4, 7, 9, 10 };`   `    ``// Stores the size of the array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``oddXorSubarray(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG` `{` `       `  `// Function to count the number of subarrays` `// of the given array having odd Bitwise XOR` `static` `void` `oddXorSubarray(``int` `a[], ``int` `n)` `{` `  `  `    ``// Stores number of odd` `    ``// numbers upto i-th index` `    ``int` `odd = ``0``;`   `    ``// Stores number of required` `    ``// subarrays starting from i-th index` `    ``int` `c_odd = ``0``;`   `    ``// Store the required result` `    ``int` `result = ``0``;`   `    ``// Find the number of subarrays having odd` `    ``// Bitwise XOR values starting at 0-th index` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{`   `        ``// Check if current element is odd` `        ``if` `(a[i] % ``2` `!= ``0``)` `        ``{` `            ``odd = (odd == ``0``) ? ``1` `: ``0``;` `        ``}`   `        ``// If the current value of odd is not` `        ``// zero, increment c_odd by 1` `        ``if` `(odd != ``0``)` `        ``{` `            ``c_odd++;` `        ``}` `    ``}`   `    ``// Find the number of subarrays having odd` `    ``// bitwise XOR value starting at ith index` `    ``// and add to result` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{`   `        ``// Add c_odd to result` `        ``result += c_odd;` `        ``if` `(a[i] % ``2` `!= ``0``)` `        ``{` `            ``c_odd = (n - i - c_odd);` `        ``}` `    ``}`   `    ``// Print the result` `    ``System.out.println(result);` `}`   `// Driver Code` `public` `static` `void` `main (String[] args)` `{` `    `  `      ``// Given array` `    ``int` `arr[] = { ``1``, ``4``, ``7``, ``9``, ``10` `};`   `    ``// Stores the size of the array` `    ``int` `N = arr.length;` `    ``oddXorSubarray(arr, N);` `}` `}`   `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python3 program for the above approach`   `# Function to count the number of subarrays` `# of the given array having odd Bitwise XOR` `def` `oddXorSubarray(a, n):` `  `  `    ``# Stores number of odd` `    ``# numbers upto i-th index` `    ``odd ``=` `0`   `    ``# Stores number of required` `    ``# subarrays starting from i-th index` `    ``c_odd ``=` `0`   `    ``# Store the required result` `    ``result ``=` `0`   `    ``# Find the number of subarrays having odd` `    ``# Bitwise XOR values starting at 0-th index` `    ``for` `i ``in` `range``(n):`   `        ``# Check if current element is odd` `        ``if` `(a[i] & ``1``):` `            ``odd ``=` `not` `odd` `        `  `        ``# If the current value of odd is not` `        ``# zero, increment c_odd by 1` `        ``if` `(odd):` `            ``c_odd ``+``=` `1`   `    ``# Find the number of subarrays having odd` `    ``# bitwise XOR value starting at ith index` `    ``# and add to result` `    ``for` `i ``in` `range``(n):`   `        ``# Add c_odd to result` `        ``result ``+``=` `c_odd` `        ``if` `(a[i] & ``1``):` `            ``c_odd ``=` `(n ``-` `i ``-` `c_odd)`   `    ``# Print the result` `    ``print` `(result)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array` `    ``arr ``=` `[``1``, ``4``, ``7``, ``9``, ``10``]`   `    ``# Stores the size of the array` `    ``N ``=` `len``(arr)` `    ``oddXorSubarray(arr, N)`   `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{` `       `  `// Function to count the number of subarrays` `// of the given array having odd Bitwise XOR` `static` `void` `oddXorSubarray(``int` `[]a, ``int` `n)` `{` `    `  `    ``// Stores number of odd` `    ``// numbers upto i-th index` `    ``int` `odd = 0;`   `    ``// Stores number of required` `    ``// subarrays starting from i-th index` `    ``int` `c_odd = 0;`   `    ``// Store the required result` `    ``int` `result = 0;`   `    ``// Find the number of subarrays having ` `    ``// odd Bitwise XOR values starting at` `    ``// 0-th index` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        `  `        ``// Check if current element is odd` `        ``if` `(a[i] % 2 != 0)` `        ``{` `            ``odd = (odd == 0) ? 1 : 0;` `        ``}`   `        ``// If the current value of odd is not` `        ``// zero, increment c_odd by 1` `        ``if` `(odd != 0)` `        ``{` `            ``c_odd++;` `        ``}` `    ``}`   `    ``// Find the number of subarrays having odd` `    ``// bitwise XOR value starting at ith index` `    ``// and add to result` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        `  `        ``// Add c_odd to result` `        ``result += c_odd;` `        `  `        ``if` `(a[i] % 2 != 0)` `        ``{` `            ``c_odd = (n - i - c_odd);` `        ``}` `    ``}`   `    ``// Print the result` `    ``Console.WriteLine(result);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Given array` `    ``int` `[]arr = { 1, 4, 7, 9, 10 };`   `    ``// Stores the size of the array` `    ``int` `N = arr.Length;` `    ``oddXorSubarray(arr, N);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`8`

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

My Personal Notes arrow_drop_up
Related Articles