Skip to content
Related Articles
Queries to check whether bitwise AND of a subarray is even or odd
• Last Updated : 25 May, 2021

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 ``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[], ``int` `m)``{``    ``precompute(a, n);` `    ``// Perform queries``    ``for` `(``int` `i = 0; i < m; i++) {``        ``int` `L = q[i], R = q[i];``        ``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);` `    ``// Queries``    ``int` `q[] = { { 0, 2 }, { 1, 2 }, { 2, 3 }, { 3, 6 } };``    ``int` `m = ``sizeof``(q) / ``sizeof``(q);` `    ``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#

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

 ``
Output:
```Even
Odd
Odd
Even```

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

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up