Bitwise ORs of Subarrays - Practice Coding Problems

Bitwise ORs of Subarrays - Problem

Find all unique bitwise OR values across every possible subarray of an integer array.

Given an integer array arr, you need to calculate the bitwise OR of every contiguous subarray and count how many distinct values you get.

For example, with array [1, 1, 2]:
• Subarrays: [1], [1], [2], [1,1], [1,2], [1,1,2]
• Their ORs: 1, 1, 2, 1, 3, 3
• Distinct values: {1, 2, 3} → Answer: 3

Challenge: Can you solve this efficiently without checking every subarray individually?

Input & Output

example_1.py — Small Array

$ Input: [1, 1, 2]

› Output: 3

💡 Note: Subarrays and their ORs: [1]→1, [1]→1, [2]→2, [1,1]→1, [1,2]→3, [1,1,2]→3. Unique values: {1, 2, 3}, so answer is 3.

example_2.py — Powers of 2

$ Input: [1, 2, 4]

› Output: 6

💡 Note: All subarrays: [1]→1, [2]→2, [4]→4, [1,2]→3, [2,4]→6, [1,2,4]→7. All ORs are distinct: {1,2,3,4,6,7}, giving answer 6.

example_3.py — Single Element

$ Input: [0]

› Output: 1

💡 Note: Only one subarray [0] with OR value 0, so there's exactly 1 distinct value.

Visualization

Tap to expand

Understanding the Visualization

Start with first paint

Begin with paint bucket containing color 1

Add second paint

Mixing paint 1 with paint 1 still gives color 1

Add third paint

Mixing with paint 2 creates new colors: pure 2 and mixed 3

Count unique colors

Final palette contains 3 distinct colors: {1, 2, 3}

Key Takeaway

🎯 Key Insight: Bitwise OR can only set bits (add colors), never unset them. With 32 bits maximum, each position contributes at most 32 distinct values, making the solution surprisingly efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n × 32)

Each position processes at most 32 distinct OR values from previous position, leading to linear time in practice

✓ Linear Growth

Space Complexity

O(32)

Sets store at most 32 distinct OR values at any point, plus the result set

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 5 × 10⁴
0 ≤ arr[i] ≤ 10⁹
Each integer fits in 32 bits (key insight for optimization)

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 23

The optimal solution uses dynamic programming with sets leveraging the key insight that each position contributes at most 32 distinct OR values (one per bit). This reduces time complexity from O(n²) to O(n × 32) which is effectively linear. The algorithm maintains sets of OR values ending at each position and efficiently computes all unique values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Subarrays)	O(n²)	O(min(n², 32))	Check every possible subarray and calculate its bitwise OR
Dynamic Programming with Sets (Optimal)	O(n × 32)	O(32)	Use the key insight that each position contributes at most 32 distinct OR values

Brute Force (All Subarrays) — Algorithm Steps

Use outer loop for subarray start position
Use inner loop for subarray end position
Calculate OR incrementally for each subarray
Add each OR result to a set to track uniqueness
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin with arr[0] as single-element subarray

Extend subarray

Add arr[1], arr[2], ... to create longer subarrays

Move to next start

Repeat process starting from arr[1], then arr[2], etc.

Collect unique ORs

Store all distinct OR values in a set

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 50000
#define HASH_SIZE 1000000

typedef struct HashNode {
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hash(int value) {
    return abs(value) % HASH_SIZE;
}

void insert(int value) {
    int index = hash(value);
    HashNode* current = hashTable[index];
    while (current) {
        if (current->value == value) return;
        current = current->next;
    }
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->value = value;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

int countUnique() {
    int count = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* current = hashTable[i];
        while (current) {
            count++;
            current = current->next;
        }
    }
    return count;
}

int subarrayBitwiseORs(int* arr, int n) {
    memset(hashTable, 0, sizeof(hashTable));
    
    for (int i = 0; i < n; i++) {
        int currentOr = 0;
        for (int j = i; j < n; j++) {
            currentOr |= arr[j];
            insert(currentOr);
        }
    }
    
    return countUnique();
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int arr[MAX_SIZE];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL && n < MAX_SIZE) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    printf("%d\n", subarrayBitwiseORs(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate through all possible subarray start and end positions

⚠ Quadratic Growth

Space Complexity

O(min(n², 32))

Set stores unique OR values, bounded by either number of subarrays or maximum possible distinct OR values (32 bits)

⚠ Quadratic Space

Constraints

1 ≤ arr.length ≤ 5 × 10⁴
0 ≤ arr[i] ≤ 10⁹
Each integer fits in 32 bits (key insight for optimization)

68.5K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler