Smallest Subarrays With Maximum Bitwise OR

Smallest Subarrays With Maximum Bitwise OR - Problem

You are given a 0-indexed array nums of length n, consisting of non-negative integers. For each index i from 0 to n - 1, you must determine the size of the minimum sized non-empty subarray of nums starting at i (inclusive) that has the maximum possible bitwise OR.

In other words, let B_ij be the bitwise OR of the subarray nums[i...j]. You need to find the smallest subarray starting at i, such that bitwise OR of this subarray is equal to max(B_ik) where i ≤ k ≤ n - 1.

The bitwise OR of an array is the bitwise OR of all the numbers in it.

Return an integer array answer of size n where answer[i] is the length of the minimum sized subarray starting at i with maximum bitwise OR.

A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Starting at index 0: maximum OR is 1|0|3|5=7, minimum length is 4 (need [1,0,3,5]). Starting at index 1: maximum OR is 0|3|5=7, minimum length is 3 (need [0,3,5]). Starting at index 2: maximum OR is 3|5=7, minimum length is 2 (need [3,5]). Starting at index 3: maximum OR is 5, minimum length is 1 (need [5]).

Example 2 — Single Element

$ Input: nums = [8]

› Output: [1]

💡 Note: Only one element, so the minimum subarray starting at index 0 has length 1 with OR=8.

Example 3 — All Same Values

$ Input: nums = [2,2,2]

› Output: [1,1,1]

💡 Note: All elements are the same, so from each position, a single element achieves the maximum OR of 2.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

M Microsoft 35 G Google 28 A Amazon 22

The key insight is that bitwise OR can only increase or stay the same as we add elements. The optimal approach pre-computes maximum OR values from each position, then finds minimum lengths efficiently. Time: O(n²), Space: O(n).

Common Approaches

✓ Bit Manipulation - Track OR Changes

⏱️ Time: O(n²) Space: O(1)

Leverage the fact that once a bit is set in the OR operation, it remains set. We can track the progression of OR values and identify when they reach their maximum efficiently.

Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

For each index i, we first find the maximum possible OR of all subarrays starting at i. Then we find the shortest subarray starting at i that achieves this maximum OR.

Optimized Approach - Single Pass with Bit Tracking

⏱️ Time: O(n²) Space: O(n)

Since bitwise OR can only increase or stay the same as we add more elements, we can process from right to left to pre-compute maximum OR values, then process left to right to find minimum lengths efficiently.

Bit Manipulation - Track OR Changes — Algorithm Steps

Track bit positions that become set as we extend subarrays
Use the monotonic property of OR to detect maximum
Optimize by recognizing when OR stabilizes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize OR

Start with OR = 0 for current subarray

Extend and Track

Add each element and track OR progression

Find Target

Stop when OR equals maximum possible value

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int currentOr = 0;
        int maxOr = 0;
        
        // Find max OR first
        int tempOr = 0;
        for (int j = i; j < numsSize; j++) {
            tempOr |= nums[j];
        }
        maxOr = tempOr;
        
        // Find minimum length to achieve max OR
        currentOr = 0;
        for (int j = i; j < numsSize; j++) {
            currentOr |= nums[j];
            if (currentOr == maxOr) {
                result[i] = j - i + 1;
                break;
            }
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position, we may need to check all remaining positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for bit tracking

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Constraints

Visualization

Related Problems

Common Approaches

Bit Manipulation - Track OR Changes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler