Skip to content
Related Articles

Related Articles

Count subarrays having odd Bitwise XOR
  • Last Updated : 26 Feb, 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 <bits/stdc++.h>
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)
 
    # Prthe 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
Output: 
8

 

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

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
Recommended Articles
Page :