Count Positions on Street With Required Brightness - Problem

You are given an integer n. A perfectly straight street is represented by a number line ranging from 0 to n - 1.

You are given a 2D integer array lights representing the street lamps on the street. Each lights[i] = [position_i, range_i] indicates that there is a street lamp at position position_i that lights up the area from [max(0, position_i - range_i), min(n - 1, position_i + range_i)] (inclusive).

The brightness of a position p is defined as the number of street lamps that light up the position p.

You are given a 0-indexed integer array requirement of size n where requirement[i] is the minimum brightness of the i^th position on the street.

Return the number of positions i on the street between 0 and n - 1 that have a brightness of at least requirement[i].

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Position 0: covered by lamp [0,1] → brightness = 1 < 2. Position 1: covered by lamps [0,1], [2,1], and [3,2] → brightness = 3 ≥ 2. Position 2: covered by lamps [2,1] and [3,2] → brightness = 2 ≥ 2. Position 3: covered by lamps [2,1] and [3,2] → brightness = 2 ≥ 2. Position 4: covered by lamp [3,2] → brightness = 1 < 2. Three positions (1, 2, 3) meet requirements.

Example 2 — All Satisfied

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

› Output: 3

💡 Note: Single lamp at position 1 with range 2 covers positions [max(0,1-2), min(3-1,1+2)] = [0,2]. All positions have brightness = 1 ≥ 1.

Example 3 — High Requirements

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

› Output: 3

💡 Note: Lamp [0,1] covers [0,1]. Lamp [1,1] covers [0,2]. Position 0: brightness = 2 ≥ 1. Position 1: brightness = 2 ≥ 2. Position 2: brightness = 1 ≥ 1. Position 3: brightness = 0 < 1. Three positions satisfy requirements.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a difference array for efficient range updates. Instead of checking each position individually, we mark lamp coverage ranges with +1 at start and -1 at end+1. Then calculate prefix sum to get brightness at all positions in O(n+m) time. Best approach is difference array. Time: O(n+m), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n × m) Space: O(1)

For each position on the street, iterate through all lamps to count how many illuminate that position. Then check if the brightness meets the requirement.

Difference Array (Range Updates)

⏱️ Time: O(n + m) Space: O(n)

Create a difference array to mark the start and end of each lamp's coverage range. Then use prefix sum to calculate brightness at each position efficiently.

Brute Force — Algorithm Steps

For each position 0 to n-1
Count lamps that illuminate this position
Compare brightness with requirement
Increment result if requirement is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Count lamps that illuminate position 0

Position 1

Count lamps that illuminate position 1

Compare

Check if brightness >= requirement

Code -

solution.c — C

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

int solution(int n, int lights[][2], int lightsSize, int* requirement) {
    int result = 0;
    for (int pos = 0; pos < n; pos++) {
        int brightness = 0;
        for (int i = 0; i < lightsSize; i++) {
            int lampPos = lights[i][0];
            int lampRange = lights[i][1];
            int left = (0 > lampPos - lampRange) ? 0 : lampPos - lampRange;
            int right = (n - 1 < lampPos + lampRange) ? n - 1 : lampPos + lampRange;
            if (left <= pos && pos <= right) {
                brightness++;
            }
        }
        if (brightness >= requirement[pos]) {
            result++;
        }
    }
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char lightsStr[10000];
    scanf(" %s", lightsStr);
    
    // Simple parsing for lights array
    int lights[1000][2];
    int lightsSize = 0;
    char* ptr = lightsStr + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            lights[lightsSize][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            lights[lightsSize][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            lightsSize++;
        }
        ptr++;
    }
    
    char reqStr[10000];
    scanf(" %s", reqStr);
    
    int requirement[1000];
    int reqSize = 0;
    ptr = reqStr + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            requirement[reqSize] = atoi(ptr);
            reqSize++;
            while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(n, lights, lightsSize, requirement);
    printf("%d\n", result);
    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 variables, no extra data structures

✓ Linear Space

23.4K Views

Medium Frequency

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

Count Positions on Street With Required Brightness - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler