Brightest Position on Street - Practice Coding Problems

Brightest Position on Street - Problem

Imagine you're a city planner tasked with finding the brightest spot on a perfectly straight street! 🌟

The street is represented by a number line, and you have several street lamps positioned along it. Each lamp is described by a 2D array lights[i] = [position, range], where:

position - where the lamp is located on the street
range - how far the light extends in both directions

A lamp at position p with range r illuminates the area from [p-r, p+r] (inclusive).

The brightness of any position is simply the number of lamps that light up that position. Your goal is to find the position with maximum brightness. If multiple positions tie for brightest, return the smallest position.

Example: If we have lamps at [[1,2], [3,1]], the first lamp lights [-1,3] and the second lights [2,4]. Position 2 and 3 both have brightness 2 (lit by both lamps), so we return 2.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Lamp 1 at position 1 with range 2 covers [-1, 3]. Lamp 2 at position 3 with range 1 covers [2, 4]. Positions 2 and 3 both have brightness 2, so we return the smallest: 2.

example_2.py — Single Lamp

$ Input: lights = [[1,0]]

› Output: 1

💡 Note: Only one lamp at position 1 with range 0, so it only lights up position 1. The brightest (and only lit) position is 1.

example_3.py — No Overlap

$ Input: lights = [[1,1], [5,1]]

› Output: 0

💡 Note: Lamp 1 covers [0, 2] and Lamp 2 covers [4, 6]. Both regions have brightness 1. The smallest position with maximum brightness is 0.

Constraints

1 ≤ lights.length ≤ 10⁵
lights[i].length == 2
-10⁸ ≤ position_i ≤ 10⁸
0 ≤ range_i ≤ 10⁸

Visualization

Tap to expand

Understanding the Visualization

Place Lamps

Each lamp creates a circle of light with specified range

Find Overlaps

Areas where multiple circles overlap are brighter

Track Changes

Brightness only changes at lamp boundaries

Find Maximum

The brightest spot has the most overlapping lights

Key Takeaway

🎯 Key Insight: Brightness only changes at lamp boundaries, so we only need to check these critical positions instead of every possible location.

Asked in

G Google 28 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a sweep line algorithm with events. Instead of checking every position, we only process positions where brightness changes (at lamp boundaries). Create events for each lamp's start (+1 brightness) and end (-1 brightness), sort them, then sweep through to track the maximum brightness position in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n × R)	O(1)	Check every position within the range and count overlapping lamps
Sweep Line with Events (Optimal)	O(n log n)	O(n)	Use sweep line algorithm to track brightness changes at lamp boundaries

Brute Force (Check Every Position) — Algorithm Steps

Find the minimum and maximum positions that could be illuminated
For each position in this range, count how many lamps cover it
Track the position with maximum brightness (choosing smallest on ties)
Return the brightest position

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Determine min and max positions that could be illuminated

Check Each Position

For each position, count how many lamps cover it

Track Maximum

Keep track of the position with highest brightness

Code -

solution.c — C

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

int brightestPosition(int** lights, int lightsSize, int* lightsColSize) {
    if (lightsSize == 0) return 0;
    
    // Find the range of all possible positions
    int minPos = INT_MAX;
    int maxPos = INT_MIN;
    
    for (int i = 0; i < lightsSize; i++) {
        int start = lights[i][0] - lights[i][1];
        int end = lights[i][0] + lights[i][1];
        if (start < minPos) minPos = start;
        if (end > maxPos) maxPos = end;
    }
    
    int maxBrightness = 0;
    int brightestPos = minPos;
    
    // Check each position in the range
    for (int position = minPos; position <= maxPos; position++) {
        int brightness = 0;
        // Count how many lamps illuminate this position
        for (int i = 0; i < lightsSize; i++) {
            if (lights[i][0] - lights[i][1] <= position && 
                position <= lights[i][0] + lights[i][1]) {
                brightness++;
            }
        }
        
        // Update if this position is brighter
        if (brightness > maxBrightness) {
            maxBrightness = brightness;
            brightestPos = position;
        }
    }
    
    return brightestPos;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × R)

Where n is number of lamps and R is the total range of positions to check

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current and maximum brightness

✓ Linear Space

38.4K Views

Medium Frequency

~25 min Avg. Time

1.2K 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 Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler