Given an array **A** of non-negative integers, where . The task is to count number of distinct possible results obtained by taking the bitwise OR of all the elements in all possible Subarrays.

**Examples:**

Input: A = [1, 2] Output: 3 Explanation: The possible subarrays are [1], [2], [1, 2]. These Bitwise OR of subarrays are 1, 2, 3. There are 3 distinct values, so the answer is 3. Input: A = [1, 2, 4] Output: 6 Explanation: The possible distinct values are 1, 2, 3, 4, 6, and 7.

**Approach:**

The Naive approach is to generate all possible subarrays and take bitwise OR of all elements in the subarray. Store each result in **set** and return **length of the set**.**Efficient Approach:**

We can make the above approach better. The Naive approach is to calculate all possible result where, **res(i, j) = A[i] | A[i+1] | … | A[j]**. However we can speed this up by taking note of the fact that **res(i, j+1) = res(i, j) | A[j+1]**. At the **kth** step, say we have all of the **res(i, k)** in some set **pre**. Then we can find the next **pre** set **(for k -> k+1)** by using **res(i, k+1) = res(i, k) | A[k+1]**.

However, the number of unique values in this set **pre** is atmost 32, since the list **res(k, k), res(k-1, k), res(k-2, k), …** is **monotone increasing**, and any subsequent values that are different from previous must have more 1’s in it’s binary representation which can have maximum of **32 ones**.

**Below is the implementation of above approach.**

## Python

`# Python implementation of the above approach` ` ` `# function to return count of distinct bitwise OR` `def` `subarrayBitwiseOR(A):` ` ` ` ` `# res contains distinct values` ` ` `res ` `=` `set` `()` ` ` ` ` `pre ` `=` `{` `0` `}` ` ` ` ` `for` `x ` `in` `A:` ` ` `pre ` `=` `{x | y ` `for` `y ` `in` `pre} | {x}` ` ` `res |` `=` `pre` ` ` ` ` `return` `len` `(res)` ` ` ` ` `# Driver program` `A ` `=` `[` `1` `, ` `2` `, ` `4` `]` ` ` `# print required answer` `print` `(subarrayBitwiseOR(A))` ` ` `# This code is written by` `# Sanjit_Prasad` |

Output:

6

**Time Complexity:** O(N*log(K)), where N is the length of A, and K is the maximum size of elements in A.