Shortest Subarray With OR at Least K II

Shortest Subarray With OR at Least K II - Problem

You are given an array nums of non-negative integers and an integer k.

An array is called special if the bitwise OR of all of its elements is at least k.

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

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: The subarray [2] has OR = 2 ≥ 2, and [3] has OR = 3 ≥ 2. Both have length 1, which is minimum.

Example 2 — Need Multiple Elements

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

› Output: 3

💡 Note: No single element ≥ 10. [2,1] gives OR = 3 < 10. Need all three: [2,1,8] gives OR = 2|1|8 = 11 ≥ 10.

Example 3 — No Solution

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

› Output: -1

💡 Note: Maximum possible OR is 1|2 = 3, which is less than k = 5. No special subarray exists.

Constraints

1 ≤ nums.length ≤ 2 × 10⁵
0 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is that bitwise OR only increases (never decreases) when adding elements, making sliding window techniques applicable. The optimal approach uses bit frequency tracking to efficiently maintain OR values in O(n × log(max_value)) time. Best approach: Bit manipulation sliding window. Time: O(n × log(max_value)), Space: O(log(max_value)).

Common Approaches

✓ Bit Manipulation with Frequency Tracking

⏱️ Time: O(n × log(max_value)) Space: O(log(max_value))

Instead of recalculating OR repeatedly, maintain a frequency count of each bit position in the current window. The window OR has a bit set if any element in the window has that bit set.

Brute Force - Check All Subarrays

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

Generate all possible subarrays, calculate their bitwise OR, and track the minimum length where OR ≥ k. For each starting position, extend the subarray one element at a time.

Optimized Sliding Window

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

Instead of recalculating OR from scratch for each subarray, maintain running OR as we extend the window. When OR ≥ k, try to shrink from left while maintaining the condition.

Bit Manipulation with Frequency Tracking — Algorithm Steps

Maintain bit frequency array for current window
Expand window by incrementing bit counts
Shrink window by decrementing bit counts
OR is set if frequency > 0 for that bit

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Bits

Maintain frequency of each bit position

Expand Window

Add new element's bits to frequency count

Shrink Window

Remove left element's bits when OR ≥ k

Code -

solution.c — C

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

void updateBitCount(int* bitCount, int num, int delta) {
    for (int i = 0; i < 30; i++) {
        if (num & (1 << i)) {
            bitCount[i] += delta;
        }
    }
}

int getCurrentOr(int* bitCount) {
    int result = 0;
    for (int i = 0; i < 30; i++) {
        if (bitCount[i] > 0) {
            result |= (1 << i);
        }
    }
    return result;
}

int solution(int* nums, int numsSize, int k) {
    int minLength = INT_MAX;
    
    // Bit frequency array for up to 30 bits
    int bitCount[30] = {0};
    
    int left = 0;
    for (int right = 0; right < numsSize; right++) {
        // Expand window
        updateBitCount(bitCount, nums[right], 1);
        
        // Shrink window while maintaining OR >= k
        while (getCurrentOr(bitCount) >= k) {
            int length = right - left + 1;
            if (length < minLength) {
                minLength = length;
            }
            updateBitCount(bitCount, nums[left], -1);
            left++;
        }
    }
    
    return minLength == INT_MAX ? -1 : minLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_value))

Each element processed once, OR calculation takes O(log max_value) time

⚠ Quadratic Growth

Space Complexity

O(log(max_value))

Bit frequency array has 30-32 elements for 32-bit integers

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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 with Frequency Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler