K Empty Slots - Practice Coding Problems

K Empty Slots - Problem

Array Binary Indexed Tree Segment Tree Queue Sliding Window Heap (Priority Queue) Ordered Set Monotonic Queue Hard

K Empty Slots is a fascinating problem about timing and patterns in sequential events.

Imagine you have n light bulbs arranged in a row, numbered from 1 to n. Initially, all bulbs are off. Each day, you turn on exactly one bulb according to a predetermined schedule given in array bulbs.

The array bulbs[i] = x means that on day i+1, you'll turn on the bulb at position x. Your goal is to find the earliest day when there exist two turned-on bulbs with exactly k bulbs between them that are all turned off.

For example, if k=2, you're looking for a pattern like: [ON, off, off, ON] where positions 1 and 4 are on, but positions 2 and 3 are off.

Return the minimum day number when this pattern first appears, or -1 if it never happens.

Input & Output

example_1.py — Basic case with k=1

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

› Output: 2

💡 Note: On day 1, bulb 1 is on. On day 2, bulb 3 is on. Now we have pattern [ON, off, ON] where positions 1 and 3 have exactly 1 bulb (position 2) between them that is off. So answer is day 2.

example_2.py — No valid pattern

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

› Output: -1

💡 Note: Bulbs turn on in order 1→2→3. We never get a pattern where two on bulbs have exactly 1 off bulb between them, since adjacent bulbs turn on consecutively.

example_3.py — Larger gap

$ Input: bulbs = [6,5,8,4,7,10,9], k = 2

› Output: 3

💡 Note: We need pattern [ON, off, off, ON]. On day 3, bulb 8 turns on. We then have bulbs 6 and 8 on with exactly 2 bulbs (position 7) between them that are off.

Visualization

Tap to expand

Understanding the Visualization

Daily Installation

Each day, one more street light is turned on according to schedule

Pattern Recognition

Look for two lit areas with exactly k dark areas between them

Timing Check

Ensure the gap stays dark until both boundary lights are on

Safety Achievement

Report the first day this safety pattern is achieved

Key Takeaway

🎯 Key Insight: Instead of checking all pairs daily (O(n³)), we precompute installation days and use sliding windows to check patterns in O(n) time by ensuring gap bulbs turn on after boundary bulbs.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n days, we check O(n²) pairs, and for each pair we check O(n) bulbs between them

⚠ Quadratic Growth

Space Complexity

O(n)

Need array to track which bulbs are lit

⚡ Linearithmic Space

Constraints

1 ≤ bulbs.length ≤ 2 × 10⁴
1 ≤ bulbs[i] ≤ bulbs.length
bulbs is a permutation of numbers from 1 to bulbs.length
1 ≤ k ≤ 2 × 10⁴
All bulb positions are distinct

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 15

The optimal solution uses a sliding window approach that runs in O(n) time. Instead of checking all pairs every day, we preprocess to find when each bulb turns on, then use a sliding window to efficiently check potential k-gap patterns. The key insight is that for a valid pattern, all bulbs between the gap boundaries must turn on after both boundary bulbs are already on.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs Daily)	O(n³)	O(n)	Simulate each day and check all possible bulb pairs for the k-gap pattern
Sliding Window (Optimal)	O(n)	O(n)	Use sliding window to efficiently track potential k-gap patterns as bulbs are turned on

Brute Force (Check All Pairs Daily) — Algorithm Steps

Simulate each day by turning on the scheduled bulb
For each day, check all pairs of currently lit bulbs
For each pair, count bulbs between them and check if exactly k are unlit
Return the first day when such a pattern exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Turn on scheduled bulb

Turn on the bulb scheduled for current day

Check all lit pairs

Examine every pair of currently lit bulbs

Count gaps

For each pair, count unlit bulbs between them

Return if found

Return current day if any pair has exactly k unlit bulbs between

Code -

solution.c — C

int kEmptySlots(int* bulbs, int bulbsSize, int k) {
    bool* lit = (bool*)calloc(bulbsSize + 1, sizeof(bool)); // 1-indexed
    
    for (int day = 0; day < bulbsSize; day++) {
        // Turn on bulb at position bulbs[day]
        int pos = bulbs[day];
        lit[pos] = true;
        
        // Check all pairs of lit bulbs
        for (int i = 1; i <= bulbsSize; i++) {
            if (!lit[i]) continue;
            for (int j = i + k + 1; j <= bulbsSize; j++) {
                if (!lit[j]) continue;
                
                // Check if exactly k bulbs between i and j are unlit
                bool allUnlit = true;
                for (int m = i + 1; m < j; m++) {
                    if (lit[m]) {
                        allUnlit = false;
                        break;
                    }
                }
                
                if (allUnlit && j - i - 1 == k) {
                    free(lit);
                    return day + 1;
                }
            }
        }
    }
    
    free(lit);
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n days, we check O(n²) pairs, and for each pair we check O(n) bulbs between them

⚠ Quadratic Growth

Space Complexity

O(n)

Need array to track which bulbs are lit

⚡ Linearithmic Space

Constraints

1 ≤ bulbs.length ≤ 2 × 10⁴
1 ≤ bulbs[i] ≤ bulbs.length
bulbs is a permutation of numbers from 1 to bulbs.length
1 ≤ k ≤ 2 × 10⁴
All bulb positions are distinct

23.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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 (Check All Pairs Daily) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler