Shortest Subarray With OR at Least K II - Practice Coding Problems

Shortest Subarray With OR at Least K II - Problem

You are given an array nums of non-negative integers and an integer k. Your goal is to find the shortest contiguous subarray whose bitwise OR is at least k.

A subarray is called special if the bitwise OR of all its elements is greater than or equal to k. The bitwise OR operation combines bits from multiple numbers - if any number has a 1 in a particular bit position, the result will have a 1 in that position.

Return the length of the shortest special non-empty subarray of nums, or return -1 if no special subarray exists.

Example: For nums = [1, 2, 3] and k = 2, the subarray [2] has OR value 2 ≥ 2, so the answer is 1.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: The subarray [2] has bitwise OR of 2, which equals k. This is the shortest possible with length 1.

example_2.py — Multiple Elements Needed

$ Input: nums = [2,1,8], k = 10

› Output: 3

💡 Note: We need all three elements: 2|1|8 = 11 ≥ 10. No shorter subarray achieves OR ≥ 10.

example_3.py — Impossible Case

$ Input: nums = [1,2], k = 5

› Output: -1

💡 Note: The maximum possible OR is 1|2 = 3, which is less than k = 5. No subarray can achieve the required OR.

Visualization

Tap to expand

Understanding the Visualization

Initialize bit counts

Count how many numbers have each bit set in the current window

Calculate current OR

If any bit has count > 0, that bit is set in the OR result

Slide the window

Add new element's bits, remove old element's bits, update OR accordingly

Check condition

If current OR ≥ k, this window length works

Key Takeaway

🎯 Key Insight: Binary search on length + sliding window with bit counting gives us O(n log n) time complexity. The bit counting technique allows us to efficiently maintain the OR value as we slide the window, avoiding recalculation.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search (log n) with sliding window check (O(n)) for each candidate length

⚡ Linearithmic

Space Complexity

O(1)

Only using arrays to track bit counts (constant size for 32 bits)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁵
0 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
All elements are non-negative integers

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses binary search on the answer combined with sliding window technique. We binary search on the length (1 to n) and for each candidate length, use a sliding window with bit counting to efficiently check if any subarray of that length has OR ≥ k. The key insight is that bitwise OR is monotonic - adding elements can only increase the OR value, never decrease it.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Length	O(n log n)	O(1)	Binary search on the answer length, check if any subarray of that length has OR ≥ k
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays and find the shortest one with OR ≥ k

Binary Search on Length — Algorithm Steps

Binary search on the length from 1 to n
For each candidate length, use sliding window to check all subarrays of that length
Maintain bit counts to efficiently calculate OR when sliding the window
If any subarray of current length works, try smaller lengths; otherwise try larger lengths

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

Left = 1, Right = array length

Try middle length

Check if any subarray of this length works

Adjust bounds

If works, try shorter; else try longer

Code -

solution.c — C

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

bool canAchieveOR(int* nums, int numsSize, int k, int length) {
    int bitCount[32] = {0};
    int currentOr = 0;
    
    // Check first window
    for (int i = 0; i < length; i++) {
        for (int bit = 0; bit < 32; bit++) {
            if (nums[i] & (1 << bit)) {
                bitCount[bit]++;
                if (bitCount[bit] == 1) {
                    currentOr |= (1 << bit);
                }
            }
        }
    }
    
    if (currentOr >= k) return true;
    
    // Slide the window
    for (int i = length; i < numsSize; i++) {
        // Add new element
        for (int bit = 0; bit < 32; bit++) {
            if (nums[i] & (1 << bit)) {
                bitCount[bit]++;
                if (bitCount[bit] == 1) {
                    currentOr |= (1 << bit);
                }
            }
        }
        
        // Remove old element
        int oldIdx = i - length;
        for (int bit = 0; bit < 32; bit++) {
            if (nums[oldIdx] & (1 << bit)) {
                bitCount[bit]--;
                if (bitCount[bit] == 0) {
                    currentOr &= ~(1 << bit);
                }
            }
        }
        
        if (currentOr >= k) return true;
    }
    
    return false;
}

int minimumSubarrayLength(int* nums, int numsSize, int k) {
    if (k == 0) return 1;
    
    int left = 1, right = numsSize;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveOR(nums, numsSize, k, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", minimumSubarrayLength(nums, count, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search (log n) with sliding window check (O(n)) for each candidate length

⚡ Linearithmic

Space Complexity

O(1)

Only using arrays to track bit counts (constant size for 32 bits)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁵
0 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
All elements are non-negative integers

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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

Binary Search on Length — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler