Related Articles

# Bitwise OR of Bitwise AND of all subsets of an Array for Q queries

• Last Updated : 13 Jul, 2021

Given two arrays arr[] of size N and queries[] of size Q, the task is to find the OR of AND of subsets of the array. In each query, you are given an index and a value, you have to replace the value at the given index of the arrays with a given value and print the OR of AND of all subsets of the array after each query.

Examples:

Input: arr[] = {3, 5, 7}, N = 3, queries[] = {{1, 2}, {2, 1}}, Q = 2
Output:
3
Explanation:
For the first query replace the value at index 1 with value 2, updated array arr[] is {3, 2, 7}.
Then take AND of all subsets i.e. AND(3) = 3, AND(2) = 2, AND(7) = 7, AND(3, 2) = 2, AND(3, 7) = 3, AND(3, 2, 7) = 2.
OR of the AND of all subsets are OR(3, 2, 7, 2, 3, 2) = 7.
Now, for the second query replace the value at index 2 with value 1, updated array arr[] is {3, 2, 1}.
Then take AND of all subsets i.e. AND(3) = 3, AND(2) = 2, AND(1) = 1, AND(3, 2) = 2, AND(3, 1) = 1, AND(3, 2, 1) = 0.
OR of the AND of all subsets OR(3, 2, 1, 2, 1, 0) = 3.

Input: arr[] = {1, 2, 3}, N = 3, queries[] = {{2, 4}, {1, 8}}, Q = 2
Output: 7
13

Approach: This problem can be solved using greedy algorithm. Follow the steps below to solve the problem:

• Initialize an array bits[] of size 32 and store the count of set bits of all the elements.
• Iterate in the range [0, Q-1] using the variable p:
• First subtract the bits of previous value and then add the bits of new value.
• Iterate in the range [0, 31] using the variable i:
• If the current bit is set for the previous value, then subtract one bit to the bits[] array at ith index.
• If the current bit is set for the new value, then add one bit to the bits[] array at ith index.
• Replace the new value from the previous value in given array arr[].
• Initialize a variable ans to store the OR of the bits array.
• Iterate in the range [0, 31] using the variable i:
• If the current bit is not equal to 0, then add the OR of the current bit into ans.
• After completing the above steps, print the ans as the required answer for each query.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the OR of AND of all``// subsets of the array for each query``void` `Or_of_Ands_for_each_query(``int` `arr[], ``int` `n,``                               ``int` `queries[], ``int` `q)``{``    ``// An array to store the bits``    ``int` `bits = { 0 };` `    ``// Itearte for all the bits``    ``for` `(``int` `i = 0; i < 32; i++) {``        ``// Iterate over all the numbers and``        ``// store the bits in bits[] array``        ``for` `(``int` `j = 0; j < n; j++) {``            ``if` `((1 << i) & arr[j]) {``                ``bits[i]++;``            ``}``        ``}``    ``}` `    ``// Itearte over all the queries``    ``for` `(``int` `p = 0; p < q; p++) {` `        ``// Replace the bits of the value``        ``// at arr[queries[p]] with the bits``        ``// of queries[p]``        ``for` `(``int` `i = 0; i < 32; i++) {``            ``if` `((1 << i) & arr[queries[p]]) {``                ``bits[i]--;``            ``}``            ``if` `(queries[p] & (1 << i)) {``                ``bits[i]++;``            ``}``        ``}` `        ``// Substitute the value in the array``        ``arr[queries[p]] = queries[p];``        ``int` `ans = 0;` `        ``// Find OR of the bits[] array``        ``for` `(``int` `i = 0; i < 32; i++) {``            ``if` `(bits[i] != 0) {``                ``ans |= (1 << i);``            ``}``        ``}``        ``// Print the answer``        ``cout << ans << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `n = 3, q = 2;``    ``int` `arr[] = { 3, 5, 7 };``    ``int` `queries = { { 1, 2 }, { 2, 1 } };` `    ``// Function Call``    ``Or_of_Ands_for_each_query(arr, n, queries, q);` `    ``return` `0;``}`

## Java

 `// java program for the above approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the OR of AND of all``    ``// subsets of the array for each query``    ``static` `void` `Or_of_Ands_for_each_query(``int` `arr[], ``int` `n,``                                          ``int` `queries[][],``                                          ``int` `q)``    ``{``        ``// An array to store the bits``        ``int` `bits[] = ``new` `int``[``32``];``        ``Arrays.fill(bits, ``0``);` `        ``// Itearte for all the bits``        ``for` `(``int` `i = ``0``; i < ``32``; i++) {``            ``// Iterate over all the numbers and``            ``// store the bits in bits[] array``            ``for` `(``int` `j = ``0``; j < n; j++) {``                ``if` `(((``1` `<< i) & arr[j]) != ``0``) {``                    ``bits[i]++;``                ``}``            ``}``        ``}` `        ``// Itearte over all the queries``        ``for` `(``int` `p = ``0``; p < q; p++) {` `            ``// Replace the bits of the value``            ``// at arr[queries[p]] with the bits``            ``// of queries[p]``            ``for` `(``int` `i = ``0``; i < ``32``; i++) {``                ``if` `(((``1` `<< i) & arr[queries[p][``0``]]) != ``0``) {``                    ``bits[i]--;``                ``}``                ``if` `((queries[p][``1``] & (``1` `<< i)) != ``0``) {``                    ``bits[i]++;``                ``}``            ``}` `            ``// Substitute the value in the array``            ``arr[queries[p][``0``]] = queries[p][``1``];``            ``int` `ans = ``0``;` `            ``// Find OR of the bits[] array``            ``for` `(``int` `i = ``0``; i < ``32``; i++) {``                ``if` `(bits[i] != ``0``) {``                    ``ans |= (``1` `<< i);``                ``}``            ``}` `            ``// Print the answer``            ``System.out.println(ans);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Given Input``        ``int` `n = ``3``, q = ``2``;``        ``int` `arr[] = { ``3``, ``5``, ``7` `};``        ``int` `queries[][] = { { ``1``, ``2` `}, { ``2``, ``1` `} };` `        ``// Function Call``        ``Or_of_Ands_for_each_query(arr, n, queries, q);``    ``}``}` `// This code is contributed by subhammahato348.`

## Python3

 `# Python3 program for the above approach` `# Function to find the OR of AND of all``# subsets of the array for each query`  `def` `Or_of_Ands_for_each_query(arr, n, queries, q):` `    ``# An array to store the bits``    ``bits ``=` `[``0` `for` `x ``in` `range``(``32``)]` `    ``# Itearte for all the bits``    ``for` `i ``in` `range``(``0``, ``32``):` `        ``# Iterate over all the numbers and``        ``# store the bits in bits[] array``        ``for` `j ``in` `range``(``0``, n):``            ``if` `((``1` `<< i) & arr[j]):``                ``bits[i] ``+``=` `1` `    ``# Itearte over all the queries``    ``for` `p ``in` `range``(``0``, q):` `        ``# Replace the bits of the value``        ``# at arr[queries[p]] with the bits``        ``# of queries[p]``        ``for` `i ``in` `range``(``0``, ``32``):``            ``if` `((``1` `<< i) & arr[queries[p][``0``]]):``                ``bits[i] ``-``=` `1``            ``if` `(queries[p][``1``] & (``1` `<< i)):``                ``bits[i] ``+``=` `1` `        ``# Substitute the value in the array``        ``arr[queries[p][``0``]] ``=` `queries[p][``1``]``        ``ans ``=` `0` `        ``# Find OR of the bits[] array``        ``for` `i ``in` `range``(``0``, ``32``):``            ``if` `(bits[i] !``=` `0``):``                ``ans |``=` `(``1` `<< i)` `        ``# Print the answer``        ``print``(ans)` `#  Driver Code`  `#  Given Input``n ``=` `3``q ``=` `2``arr ``=` `[``3``, ``5``, ``7``]``queries ``=` `[[``1``, ``2``], [``2``, ``1``]]` `# Function Call``Or_of_Ands_for_each_query(arr, n, queries, q)` `# This code is contributed by amreshkumar3`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the OR of AND of all``// subsets of the array for each query``static` `void` `Or_of_Ands_for_each_query(``int``[] arr, ``int` `n,``                                      ``int``[,] queries,``                                      ``int` `q)``{``    ` `    ``// An array to store the bits``    ``int``[] bits = ``new` `int``;``    ``for``(``int` `i = 0; i < 32; i++)``    ``{``        ``bits[i] = 0;``    ``}` `    ``// Itearte for all the bits``    ``for``(``int` `i = 0; i < 32; i++)``    ``{``        ` `        ``// Iterate over all the numbers and``        ``// store the bits in bits[] array``        ``for``(``int` `j = 0; j < n; j++)``        ``{``            ``if` `(((1 << i) & arr[j]) != 0)``            ``{``                ``bits[i]++;``            ``}``        ``}``    ``}` `    ``// Itearte over all the queries``    ``for``(``int` `p = 0; p < q; p++)``    ``{``        ` `        ``// Replace the bits of the value``        ``// at arr[queries[p]] with the bits``        ``// of queries[p]``        ``for``(``int` `i = 0; i < 32; i++)``        ``{``            ``if` `(((1 << i) & arr[queries[p, 0]]) != 0)``            ``{``                ``bits[i]--;``            ``}``            ``if` `((queries[p, 1] & (1 << i)) != 0)``            ``{``                ``bits[i]++;``            ``}``        ``}` `        ``// Substitute the value in the array``        ``arr[queries[p, 0]] = queries[p, 1];``        ``int` `ans = 0;` `        ``// Find OR of the bits[] array``        ``for``(``int` `i = 0; i < 32; i++)``        ``{``            ``if` `(bits[i] != 0)``            ``{``                ``ans |= (1 << i);``            ``}``        ``}` `        ``// Print the answer``        ``Console.WriteLine(ans);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given Input``    ``int` `n = 3, q = 2;``    ``int``[] arr = { 3, 5, 7 };``    ``int``[,] queries = { { 1, 2 }, { 2, 1 } };``    ` `    ``// Function Call``    ``Or_of_Ands_for_each_query(arr, n, queries, q);``}``}` `// This code is contributed by target_2`

## Javascript

 ``
Output
```7
3```

Time Complexity: O(max(N, Q))
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.  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.

My Personal Notes arrow_drop_up