Smallest Subarrays With Maximum Bitwise OR

Smallest Subarrays With Maximum Bitwise OR - Problem

Imagine you're a data analyst working with bit patterns, and you need to find the most powerful combination starting from each position in your dataset.

Given a 0-indexed array nums of length n containing non-negative integers, your task is to find the shortest subarray starting at each index that achieves the maximum possible bitwise OR.

Here's what you need to do:

For each starting position i, find all possible subarrays nums[i...j] where j >= i
Calculate the bitwise OR of each subarray
Find the maximum OR value achievable from position i
Return the length of the shortest subarray that achieves this maximum

Key insight: The bitwise OR operation only adds bits (never removes them), so longer subarrays can only have greater or equal OR values. Your challenge is finding the shortest path to the maximum!

Example: If nums = [1, 0, 2, 1, 3], starting from index 0, the maximum OR we can achieve is 3 (from subarray [1,0,2,1,3]), but we might achieve it sooner with a shorter subarray.

Input & Output

example_1.py — Basic Example

$ Input: nums = [1, 0, 2, 1, 3]

› Output: [5, 4, 3, 2, 1]

💡 Note: From index 0: maximum OR is 3 (achieved by [1,0,2,1,3]), shortest length is 5. From index 1: maximum OR is 3 (achieved by [0,2,1,3]), shortest length is 4. And so on.

example_2.py — Decreasing Array

$ Input: nums = [8, 4, 2, 1]

› Output: [1, 1, 1, 1]

💡 Note: Each element by itself gives the maximum OR from its position since the array is decreasing and OR cannot exceed the first element in any subarray.

example_3.py — Single Element

$ Input: nums = [5]

› Output: [1]

💡 Note: With only one element, the shortest (and only) subarray has length 1.

Visualization

Tap to expand

Understanding the Visualization

Scan your music library

Look at all songs from current position to the end

Track audio features

Remember which songs have bass, treble, vocals, etc. (different bits)

Find essential songs

Identify the last song that contributes a unique audio feature

Create shortest playlist

Your playlist must reach that essential song to get maximum richness

Key Takeaway

🎯 Key Insight: By processing from right to left and tracking the rightmost position of each bit, we can efficiently determine the minimum playlist length needed to capture all unique audio features (maximum OR) from any starting song.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we check up to n ending positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Each element fits in a 32-bit integer

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses bit manipulation by processing the array from right to left and tracking the rightmost position of each bit. This allows us to determine the shortest subarray needed to achieve maximum OR from each position in O(n × log(max_value)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays starting from each position
Bit Manipulation with Reverse Processing	O(n × log(max_value))	O(log(max_value))	Process array from right to left, tracking bit positions efficiently

Brute Force (Nested Loops) — Algorithm Steps

For each starting index i from 0 to n-1
Find the maximum OR achievable from position i by checking all subarrays nums[i...j]
Find the shortest subarray starting at i that achieves this maximum OR
Store the length in the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from position i

Begin checking subarrays from index i

Extend subarray

Add elements one by one, calculating OR

Track maximum

Keep track of the maximum OR seen so far

Find shortest

Identify the shortest subarray achieving maximum OR

Code -

solution.c — C

int* smallestSubarrays(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int maxOr = 0;
        int currentOr = 0;
        
        // First pass: find maximum OR from position i
        for (int j = i; j < numsSize; j++) {
            currentOr |= nums[j];
            if (currentOr > maxOr) {
                maxOr = currentOr;
            }
        }
        
        // Second pass: find shortest subarray with maximum OR
        currentOr = 0;
        for (int j = i; j < numsSize; j++) {
            currentOr |= nums[j];
            if (currentOr == maxOr) {
                result[i] = j - i + 1;
                break;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we check up to n ending positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
Each element fits in a 32-bit integer

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler