Count Positions on Street With Required Brightness

Count Positions on Street With Required Brightness - Problem

Imagine you're a city planner working on optimizing street lighting for a perfectly straight road. The street is represented by positions from 0 to n-1, and you have several street lamps installed at various positions.

Here's the challenge: Each street lamp at position i with range r illuminates all positions from max(0, i-r) to min(n-1, i+r). The brightness of any position is simply the number of street lamps that light it up.

You're given a requirement array where requirement[i] specifies the minimum brightness needed at position i. Your task is to count how many positions meet their brightness requirements.

For example, if position 3 needs at least 2 lamps to light it up, and currently 3 lamps illuminate that position, then position 3 satisfies its requirement.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, lights = [[0,1],[2,1],[3,2]], requirement = [0,2,1,4,1]

› Output: 4

💡 Note: Position 0: brightness=1 (lamp at 0), requirement=0 ✓. Position 1: brightness=2 (lamps at 0,2), requirement=2 ✓. Position 2: brightness=2 (lamps at 2,3), requirement=1 ✓. Position 3: brightness=2 (lamps at 2,3), requirement=4 ✗. Position 4: brightness=1 (lamp at 3), requirement=1 ✓. Total: 4 positions meet requirements.

example_2.py — All Requirements Met

$ Input: n = 3, lights = [[1,1]], requirement = [1,1,1]

› Output: 3

💡 Note: Single lamp at position 1 with range 1 lights up all positions 0,1,2. All positions have brightness=1 and requirement=1, so all 3 positions satisfy their requirements.

example_3.py — No Requirements Met

$ Input: n = 4, lights = [[1,0],[3,0]], requirement = [2,2,2,2]

› Output: 0

💡 Note: Two lamps with range 0 only light their own positions. Each position has brightness ≤ 1, but all require brightness ≥ 2. No position meets its requirement.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ lights.length ≤ 10⁵
lights[i].length == 2
0 ≤ position_i < n
0 ≤ range_i ≤ 10⁹
requirement.length == n
0 ≤ requirement[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Place Lamps

Each lamp at position p with range r lights [p-r, p+r]

Calculate Brightness

Count overlapping lamp coverage at each position

Check Requirements

Compare brightness vs minimum requirement at each position

Key Takeaway

🎯 Key Insight: Use difference arrays to avoid recalculating lamp coverage for each position - mark range boundaries once, then accumulate with prefix sum!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a difference array technique to efficiently calculate brightness at all positions in O(n + m) time. Instead of checking each lamp for each position, we mark where lighting starts/ends and use prefix sum to accumulate the actual brightness values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Lamp for Every Position)	O(n × m)	O(1)	For each position, count how many lamps illuminate it
Difference Array (Optimal)	O(n + m)	O(n)	Use difference array to efficiently calculate brightness at all positions

Brute Force (Check Every Lamp for Every Position) — Algorithm Steps

For each position i from 0 to n-1
Count how many lamps illuminate position i
Check if count >= requirement[i]
If yes, increment the result counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position 0

Count all lamps that illuminate position 0

Check Position 1

Count all lamps that illuminate position 1

Continue...

Repeat for all positions

Code -

solution.c — C

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

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int meetRequirement(int n, int lights[][2], int lightsSize, int* requirement) {
    int count = 0;
    
    for (int pos = 0; pos < n; pos++) {
        int brightness = 0;
        
        // Count how many lamps light up this position
        for (int i = 0; i < lightsSize; i++) {
            int lampPos = lights[i][0];
            int lampRange = lights[i][1];
            int leftBound = max(0, lampPos - lampRange);
            int rightBound = min(n - 1, lampPos + lampRange);
            
            if (leftBound <= pos && pos <= rightBound) {
                brightness++;
            }
        }
        
        // Check if this position meets requirement
        if (brightness >= requirement[pos]) {
            count++;
        }
    }
    
    return count;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n positions, we check all m lamps

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

28.4K Views

Medium Frequency

~18 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

Brute Force (Check Every Lamp for Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler