Queries to check whether bitwise AND of a subarray is even or odd

Last Updated : 19 Oct, 2022

Given an array arr[] of N positive integers, the task is to answer Q queries where each query consists of a range [L, R] and you have to check whether the bitwise AND of the elements from the given index range is even or odd.
Examples:

Input: arr[] = {1, 1, 2, 3}, Q[][] = {{1, 2}, {0, 1}}
Output:
Even
Odd
(1 & 2) = 0 which is even.
(1 & 1) = 1 which is odd.

Input: arr[] = {2, 1, 5, 7, 6, 8, 9}, Q[][] = {{0, 2}, {1, 2}, {2, 3}, {3, 6}}
Output:
Even
Odd
Odd
Even

Approach:

The bitwise AND in an index range [L, R] will be odd if all the elements in that index range is odd otherwise, it will be even.
So, check whether all the elements in the index range [L, R] is odd or not.
In order to answer each query optimally, create an array and mark the positions where the value is odd and then take the prefix sum of this array.
Now, the count of odd numbers in the index range [L, R] can be calculated as pre[R] - pre[L - 1].

Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int even[MAXN], odd[MAXN];

// Function to precompute the count
// of even and odd numbers
void precompute(int arr[], int n)
{

    for (int i = 0; i < n; i++) {

        // If the current element is odd
        // then put 1 at odd[i]
        if (arr[i] % 2 == 1)
            odd[i] = 1;

        // If the current element is even
        // then put 1 at even[i]
        if (arr[i] % 2 == 0)
            even[i] = 1;
    }

    // Taking the prefix sums of these two arrays
    // so we can get the count of even and odd
    // numbers in a range [L, R] in O(1)
    for (int i = 1; i < n; i++) {
        even[i] = even[i] + even[i - 1];
        odd[i] = odd[i] + odd[i - 1];
    }
}

// Function that returns true if the bitwise
// AND of the subarray a[L...R] is odd
bool isOdd(int L, int R)
{

    // cnt will store the count of odd
    // numbers in the range [L, R]
    int cnt = odd[R];
    if (L > 0)
        cnt -= odd[L - 1];

    // Check if all the numbers in
    // the range are odd or not
    if (cnt == R - L + 1)
        return true;

    return false;
}

// Function to perform the queries
void performQueries(int a[], int n, int q[][2], int m)
{
    precompute(a, n);

    // Perform queries
    for (int i = 0; i < m; i++) {
        int L = q[i][0], R = q[i][1];
        if (isOdd(L, R))
            cout << "Odd\n";
        else
            cout << "Even\n";
    }
}

// Driver code
int main()
{
    int a[] = { 2, 1, 5, 7, 6, 8, 9 };
    int n = sizeof(a) / sizeof(a[0]);

    // Queries
    int q[][2] = { { 0, 2 }, { 1, 2 }, { 2, 3 }, { 3, 6 } };
    int m = sizeof(q) / sizeof(q[0]);

    performQueries(a, n, q, m);

    return 0;
}

Java

// Java implementation of the approach
class GFG {

    static final int MAXN = 1000005;
    static int even[] = new int[MAXN];
    static int odd[] = new int[MAXN];

    // Function to precompute the count
    // of even and odd numbers
    static void precompute(int arr[], int n)
    {

        for (int i = 0; i < n; i++) {

            // If the current element is odd
            // then put 1 at odd[i]
            if (arr[i] % 2 == 1)
                odd[i] = 1;

            // If the current element is even
            // then put 1 at even[i]
            if (arr[i] % 2 == 0)
                even[i] = 1;
        }

        // Taking the prefix sums of these two arrays
        // so we can get the count of even and odd
        // numbers in a range [L, R] in O(1)
        for (int i = 1; i < n; i++) {
            even[i] = even[i] + even[i - 1];
            odd[i] = odd[i] + odd[i - 1];
        }
    }

    // Function that returns true if the bitwise
    // AND of the subarray a[L...R] is odd
    static boolean isOdd(int L, int R)
    {

        // cnt will store the count of odd
        // numbers in the range [L, R]
        int cnt = odd[R];
        if (L > 0)
            cnt -= odd[L - 1];

        // Check if all the numbers in
        // the range are odd or not
        if (cnt == R - L + 1)
            return true;

        return false;
    }

    // Function to perform the queries
    static void performQueries(int a[], int n, int q[][],
                               int m)
    {
        precompute(a, n);

        // Perform queries
        for (int i = 0; i < m; i++) {
            int L = q[i][0], R = q[i][1];
            if (isOdd(L, R))
                System.out.println("Odd");
            else
                System.out.println("Even");
        }
    }

    // Driver code
    public static void main(String args[])
    {
        int[] a = { 2, 1, 5, 7, 6, 8, 9 };
        int n = a.length;

        // Queries
        int q[][]
            = { { 0, 2 }, { 1, 2 }, { 2, 3 }, { 3, 6 } };
        int m = q.length;

        performQueries(a, n, q, m);
    }
}

// This code is contributed by AnkitRai01

Python3

# Python implementation of the approach
MAXN = 1000005
even = [0] * MAXN
odd = [0] * MAXN

# Function to precompute the count
# of even and odd numbers


def precompute(arr, n):

    for i in range(n):

        # If the current element is odd
        # then put 1 at odd[i]
        if (arr[i] % 2 == 1):
            odd[i] = 1

        # If the current element is even
        # then put 1 at even[i]
        if (arr[i] % 2 == 0):
            even[i] = 1

    # Taking the prefix sums of these two arrays
    # so we can get the count of even and odd
    # numbers in a range [L, R] in O(1)
    for i in range(1, n):
        even[i] = even[i] + even[i - 1]
        odd[i] = odd[i] + odd[i - 1]

# Function that returns True if the bitwise
# AND of the subarray a[L...R] is odd


def isOdd(L, R):

    # cnt will store the count of odd
    # numbers in the range [L, R]
    cnt = odd[R]
    if (L > 0):
        cnt -= odd[L - 1]

    # Check if all the numbers in
    # the range are odd or not
    if (cnt == R - L + 1):
        return True

    return False

# Function to perform the queries


def performQueries(a, n, q, m):
    precompute(a, n)

    # Perform queries
    for i in range(m):
        L = q[i][0]
        R = q[i][1]
        if (isOdd(L, R)):
            print("Odd")
        else:
            print("Even")


# Driver code
if __name__ == '__main__':
    a = [2, 1, 5, 7, 6, 8, 9]
    n = len(a)

    # Queries
    q = [[0, 2], [1, 2], [2, 3], [3, 6]]
    m = len(q)

    performQueries(a, n, q, m)

# This code is contributed by PrinciRaj1992

// C# implementation of the approach
using System;

class GFG {

    static readonly int MAXN = 1000005;
    static int[] even = new int[MAXN];
    static int[] odd = new int[MAXN];

    // Function to precompute the count
    // of even and odd numbers
    static void precompute(int[] arr, int n)
    {
        for (int i = 0; i < n; i++) {

            // If the current element is odd
            // then put 1 at odd[i]
            if (arr[i] % 2 == 1)
                odd[i] = 1;

            // If the current element is even
            // then put 1 at even[i]
            if (arr[i] % 2 == 0)
                even[i] = 1;
        }

        // Taking the prefix sums of these two arrays
        // so we can get the count of even and odd
        // numbers in a range [L, R] in O(1)
        for (int i = 1; i < n; i++) {
            even[i] = even[i] + even[i - 1];
            odd[i] = odd[i] + odd[i - 1];
        }
    }

    // Function that returns true if the bitwise
    // AND of the subarray a[L...R] is odd
    static bool isOdd(int L, int R)
    {

        // cnt will store the count of odd
        // numbers in the range [L, R]
        int cnt = odd[R];
        if (L > 0)
            cnt -= odd[L - 1];

        // Check if all the numbers in
        // the range are odd or not
        if (cnt == R - L + 1)
            return true;

        return false;
    }

    // Function to perform the queries
    static void performQueries(int[] a, int n, int[, ] q,
                               int m)
    {
        precompute(a, n);

        // Perform queries
        for (int i = 0; i < m; i++) {
            int L = q[i, 0], R = q[i, 1];
            if (isOdd(L, R))
                Console.WriteLine("Odd");
            else
                Console.WriteLine("Even");
        }
    }

    // Driver code
    public static void Main(String[] args)
    {
        int[] a = { 2, 1, 5, 7, 6, 8, 9 };
        int n = a.Length;

        // Queries
        int[, ] q
            = { { 0, 2 }, { 1, 2 }, { 2, 3 }, { 3, 6 } };
        int m = q.GetLength(0);

        performQueries(a, n, q, m);
    }
}

// This code is contributed by 29AjayKumar

JavaScript

<script>

// Javascript implementation of the approach
var MAXN = 1000005;
var even = Array(MAXN).fill(0);
var odd = Array(MAXN).fill(0);

// Function to precompute the count
// of even and odd numbers
function precompute(arr, n)
{

    for (var i = 0; i < n; i++) {

        // If the current element is odd
        // then put 1 at odd[i]
        if (arr[i] % 2 == 1)
            odd[i] = 1;

        // If the current element is even
        // then put 1 at even[i]
        if (arr[i] % 2 == 0)
            even[i] = 1;
    }

    // Taking the prefix sums of these two arrays
    // so we can get the count of even and odd
    // numbers in a range [L, R] in O(1)
    for (var i = 1; i < n; i++) {
        even[i] = even[i] + even[i - 1];
        odd[i] = odd[i] + odd[i - 1];
    }
}

// Function that returns true if the bitwise
// AND of the subarray a[L...R] is odd
function isOdd(L, R)
{

    // cnt will store the count of odd
    // numbers in the range [L, R]
    var cnt = odd[R];
    if (L > 0)
        cnt -= odd[L - 1];

    // Check if all the numbers in
    // the range are odd or not
    if (cnt == R - L + 1)
        return true;

    return false;
}

// Function to perform the queries
function performQueries(a, n, q, m)
{
    precompute(a, n);

    // Perform queries
    for (var i = 0; i < m; i++)
    {
        var L = q[i][0], R = q[i][1];
        if (isOdd(L, R))
            document.write( "Odd"+"<br>");
        else
            document.write("Even"+"<br>");
    }
}

// Driver code
var a = [2, 1, 5, 7, 6, 8, 9];
var n = a.length;

// Queries
var q = [ [ 0, 2 ], [ 1, 2 ], [ 2, 3 ], [ 3, 6 ] ];
var m = q.length;
performQueries(a, n, q, m);

// This code is contributed by itsok.
</script>

Output:

Even
Odd
Odd
Even

Time Complexity: O(Q) where Q is the number of queries.
Auxiliary Space: O(MAXN)

Analysis of Algorithms

souradeep

Improve

Article Tags :

Practice Tags :

Queries to check whether bitwise AND of a subarray is even or odd

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?