# Bitwise OR of bitwise AND of all possible non-empty subarrays after Q query updates

• Last Updated : 26 Aug, 2021

Given an array arr[] consisting of N positive integers and an array of queries Q[] of type [L, R], the task is to find the Bitwise OR of the bitwise AND of all the possible non-empty subarrays of the array after updating array element at index L to R for each query.

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[ ] = {1, 2, 3}, Q[ ] = {{1, 4}, {3, 0}}
Output: 7 6
Explanation:
All subarrays are {1}, {2}, {3}, {1, 2}, {2, 3} and {1, 2, 3}
For query 1: Update arr = 4, then new array is {4, 2, 3}. The bitwise & of all subarrays are 4, 2, 3, 0, 2, 0 and the bitwise OR( {4, 2, 3, 0, 2, 0}) equals 7.
For query 2: Update arr = 0, then new array is {4, 2, 0}. The bitwise & of all subarrays are 4, 2, 0, 0, 0, 0 and the bitwise OR( {4, 2, 0, 0, 0, 0}) equals 6.

Input: arr[ ] = {1, 2, 1}, Q[ ] = {{2, 1}}
Output: 1

Naive Approach: The simplest approach to solve the problem is to traverse the array Q[] and for each query update the array element arr[L] to R and find all the subarrays and their bitwise AND and store them in the new array. After storing the Bitwise AND, find the bitwise OR of the new array formed.

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

Efficient Approach: The above approach can also be optimized by using the fact that the bitwise OR of the resulting bitwise AND of all the generated subarrays are the same as the resulting bitwise OR of all the elements present in the array.

Therefore, the idea is to perform the queries and print the value of Bitwise OR of all array elements after updating the array each time.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;`  `    ``// Function to find the Bitwise OR``    ``// of Bitwise AND of all possible``    ``// subarrays after performing the``    ``// every query``  ``void` `performQuery(vector<``int``> arr,``                             ``vector> Q)``    ``{``        ``// Traversing each pair``        ``// of the query``        ``for` `(``int` `i = 0; i < Q.size(); i++) {` `            ``// Stores the Bitwise OR``            ``int` `or1 = 0;` `            ``// Updating the array``            ``int` `x = Q[i];``            ``arr[x - 1] = Q[i];` `            ``// Find the Bitwise OR of``            ``// new updated array``            ``for` `(``int` `j = 0; j < arr.size(); j++) {``                ``or1 = or1 | arr[j];``            ``}` `            ``// Print the ans``            ``cout< arr({ 1, 2, 3 });``        ``vector<``int``> v1({1,4});``        ``vector<``int``> v2({3,0});``        ``vector> Q;``        ``Q.push_back(v1);``        ``Q.push_back(v2);``        ``performQuery(arr, Q);``    ``}` `// This code is contributed by ipg2016107.`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to find the Bitwise OR``    ``// of Bitwise AND of all possible``    ``// subarrays after performing the``    ``// every query``    ``static` `void` `performQuery(``int` `arr[],``                             ``int` `Q[][])``    ``{``        ``// Traversing each pair``        ``// of the query``        ``for` `(``int` `i = ``0``; i < Q.length; i++) {` `            ``// Stores the Bitwise OR``            ``int` `or = ``0``;` `            ``// Updating the array``            ``int` `x = Q[i][``0``];``            ``arr[x - ``1``] = Q[i][``1``];` `            ``// Find the Bitwise OR of``            ``// new updated array``            ``for` `(``int` `j = ``0``; j < arr.length; j++) {``                ``or = or | arr[j];``            ``}` `            ``// Print the ans``            ``System.out.print(or + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3` `};``        ``int` `Q[][] = { { ``1``, ``4` `}, { ``3``, ``0` `} };``        ``performQuery(arr, Q);``    ``}``}`

## Python3

 `# Python program for the above approach``# Function to find the Bitwise OR``# of Bitwise AND of all possible``# subarrays after performing the``# every query``def` `performQuery(arr, Q):``    ` `    ``# Traversing each pair``    ``# of the query``    ``for` `i ``in` `range` `(``0``, ``len``(Q)):``      ` `        ``# Stores the Bitwise OR``        ``orr ``=` `0``        ` `        ``# Updating the array``        ``x ``=` `Q[i][``0``]``        ``arr[x ``-` `1``] ``=` `Q[i][``1``]``        ` `        ``# Find the Bitwise OR of``        ``# new updated array``        ``for` `j ``in` `range``(``0``,``len``(arr)):``            ``orr ``=` `orr | arr[j]``            ` `        ``# Print the ans``        ``print``(orr ,end``=` `" "``)` `# Driver Code``arr ``=` `[``1``, ``2``, ``3``]``Q ``=` `[[``1``, ``4``] , [``3``, ``0``]]``performQuery(arr, Q)``    ` `# This code is contributed by shivanisinghss2110`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `    ``// Function to find the Bitwise OR``    ``// of Bitwise AND of all possible``    ``// subarrays after performing the``    ``// every query``    ``static` `void` `performQuery(``int` `[]arr, ``int` `[,]Q)``    ``{``        ``// Traversing each pair``        ``// of the query``        ``for` `(``int` `i = 0; i < Q.Length; i++) {` `            ``// Stores the Bitwise OR``            ``int` `or = 0;` `            ``// Updating the array``            ``int` `x = Q[i,0];``            ``arr[x - 1] = Q[i,1];` `            ``// Find the Bitwise OR of``            ``// new updated array``            ``for` `(``int` `j = 0; j < arr.Length; j++) {``                ``or = or | arr[j];``            ``}` `            ``// Print the ans``            ``Console.Write(or + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]arr = { 1, 2, 3 };``        ``int` `[,]Q = { { 1, 4 }, { 3, 0 } };``        ``performQuery(arr, Q);``    ``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:
`7 6`

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

My Personal Notes arrow_drop_up