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

Shortest Subarray With OR at Least K I - Problem

You're tasked with finding the shortest contiguous subarray within an array of non-negative integers where the bitwise OR of all elements equals or exceeds a given threshold k.

A subarray is considered "special" if when you perform the bitwise OR operation on all its elements, the result is at least k. The bitwise OR operation combines bits using the rule: if either bit is 1, the result is 1.

Your goal: Return the length of the shortest special non-empty subarray, or -1 if no such subarray exists.

Example: For array [2, 1, 8] and k = 10, the subarray [2, 8] has OR value 2 | 8 = 10, which meets our threshold with length 2.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The subarray [2, 1, 8] has OR value 2|1|8 = 11, which is >= 10. This is the shortest possible subarray with the required property.

example_2.py — Shorter Subarray

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

› Output: 1

💡 Note: The subarray [2] has OR value 2, which equals k = 2. Length is 1, which is optimal.

example_3.py — No Valid Subarray

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

› Output: -1

💡 Note: No subarray has OR value >= 5. The maximum possible OR is 1|2 = 3, which is less than k = 5.

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with empty window, prepare to expand

Expand & Calculate

Add elements and calculate OR incrementally

Shrink When Valid

When OR >= k, try to reduce window size from left

Track Minimum

Always remember the shortest valid window found

Key Takeaway

🎯 Key Insight: OR operations are monotonic, making sliding window perfect for finding the shortest valid subarray efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_value))

Each element visited twice, but OR recalculation for shrinking adds log factor

⚡ Linearithmic

Space Complexity

O(1)

Only using pointer variables and OR accumulator

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
0 ≤ nums[i] ≤ 50
0 ≤ k ≤ 50
All array elements are non-negative integers

Asked in

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

The optimal approach uses sliding window technique to efficiently find the shortest subarray. Key insight: OR operations are monotonic - adding elements can only increase the OR value, making it perfect for window-based solutions with O(n×log(max_value)) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Two Pointers)	O(n × log(max_value))	O(1)	Use expandable window with left and right pointers to find minimum length subarray
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays by trying every starting position and expanding until OR reaches k

Sliding Window (Two Pointers) — Algorithm Steps

Initialize left and right pointers at the start of array
Expand right pointer and include elements in current OR
When OR >= k, try to shrink window from left side
Update minimum length whenever we find a valid window
Continue until right pointer reaches end of array

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix right pointer

Start with right pointer at each position

Expand backwards

Move left pointer backwards while calculating OR

Update minimum

When OR >= k, update minimum length and continue

Code -

solution.c — C

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

int shortestSubarray(int* nums, int numsSize, int k) {
    int minLength = INT_MAX;
    
    for (int right = 0; right < numsSize; right++) {
        int currentOr = 0;
        for (int left = right; left >= 0; left--) {
            currentOr |= nums[left];
            if (currentOr >= k) {
                if (right - left + 1 < minLength) {
                    minLength = right - left + 1;
                }
                break;
            }
        }
    }
    
    return minLength == INT_MAX ? -1 : minLength;
}

int main() {
    int nums[] = {2, 1, 8};
    int k = 10;
    printf("%d\n", shortestSubarray(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_value))

Each element visited twice, but OR recalculation for shrinking adds log factor

⚡ Linearithmic

Space Complexity

O(1)

Only using pointer variables and OR accumulator

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 50
0 ≤ nums[i] ≤ 50
0 ≤ k ≤ 50
All array elements are non-negative integers

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Sliding Window (Two Pointers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler