Traffic Light Controlled Intersection - Practice Coding Problems

Traffic Light Controlled Intersection - Problem

Concurrency Easy

Traffic Light Controlled Intersection

Picture a busy intersection where two roads cross: Road A runs North-South and Road B runs West-East. Cars travel in both directions on each road:

🚗 Road A: Direction 1 (North→South), Direction 2 (South→North)
🚗 Road B: Direction 3 (West→East), Direction 4 (East→West)

Each road has a traffic light that can be either GREEN ✅ (cars can cross) or RED ❌ (cars must wait). Critical rule: Only one road can have a green light at a time!

Initially, Road A has a green light and Road B has a red light. When cars arrive, you must coordinate the traffic lights to prevent deadlock while ensuring no two cars from different roads cross simultaneously.

Your Mission: Implement carArrived(carId, roadId, direction, turnGreen, crossCar) where:
• carId: unique identifier for the car
• roadId: 1 for Road A, 2 for Road B
• direction: travel direction (1-4)
• turnGreen(): function to turn current road's light green
• crossCar(): function to let current car cross

Warning: Turning a light green when it's already green is considered incorrect!

Input & Output

example_1.py — Basic Traffic Flow

$ Input: Cars arriving: [(1, 1, 1), (2, 1, 2), (3, 2, 3)] Initial state: Road A=GREEN, Road B=RED

› Output: Car 1 crosses (no light change needed) Car 2 crosses (no light change needed) Road B light turns GREEN Car 3 crosses

💡 Note: Cars 1 and 2 can cross without light changes since Road A is initially green. Car 3 requires switching to Road B.

example_2.py — Alternating Roads

$ Input: Cars arriving: [(1, 2, 3), (2, 1, 1), (3, 2, 4), (4, 1, 2)]

› Output: Road B light turns GREEN Car 1 crosses Road A light turns GREEN Car 2 crosses Road B light turns GREEN Car 3 crosses Road A light turns GREEN Car 4 crosses

💡 Note: Each car is from a different road than the previous, requiring light switches for optimal traffic flow.

example_3.py — Same Road Sequence

$ Input: Cars arriving: [(1, 1, 1), (2, 1, 2), (3, 1, 1), (4, 1, 2)]

› Output: Car 1 crosses (no light change) Car 2 crosses (no light change) Car 3 crosses (no light change) Car 4 crosses (no light change)

💡 Note: All cars are from Road A, so no light switches are needed since Road A starts with green light.

Visualization

Tap to expand

Understanding the Visualization

Car Arrives

A car approaches the intersection and requests access to cross

State Check

System checks if the car's road currently has the green light

Smart Switch

If needed, traffic light switches to car's road (avoiding unnecessary switches)

Safe Crossing

Car crosses the intersection safely while holding the lock

Key Takeaway

🎯 Key Insight: By tracking the current green road state and using proper synchronization, we eliminate unnecessary light switches while ensuring thread-safe operation and preventing deadlock in concurrent scenarios.

Time & Space Complexity

Time Complexity

⏱️

O(1) per car arrival

Each car operation is constant time with minimal overhead

✓ Linear Growth

Space Complexity

O(1)

Only stores current green road state and synchronization primitives

✓ Linear Space

Constraints

1 ≤ carId ≤ 20
roadId ∈ {1, 2} where 1 = Road A, 2 = Road B
direction ∈ {1, 2, 3, 4} where 1,2 are Road A directions and 3,4 are Road B directions
Initially, Road A has GREEN light and Road B has RED light
At most 20 cars will call carArrived function
Cars may arrive concurrently from different threads

Asked in

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

The optimal solution uses state-aware synchronization with a mutex/lock to track which road currently has the green light. Key insights: 1) Only call turnGreen() when switching roads to avoid errors, 2) Use proper synchronization to handle concurrent car arrivals, 3) Initialize Road A as green per problem requirements. This achieves O(1) time per car with minimal overhead and prevents deadlock through careful state management.

Common Approaches

Approach	Time	Space	Notes
✓ State-Aware Synchronization (Optimal)	O(1) per car arrival	O(1)	Track current green road and synchronize efficiently with minimal light switches
Naive Synchronization	O(1) per car arrival	O(1)	Use basic locking without tracking current light state

State-Aware Synchronization (Optimal) — Algorithm Steps

Initialize with Road A having green light (as per problem statement)
When car arrives, acquire lock for thread safety
Check if car's road already has green light
If not, switch the light to car's road
Let car cross the intersection
Release lock for next car

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Current State

System maintains which road currently has green light

Smart Light Control

Only switches light when car's road differs from current green road

Safe Crossing

Car crosses after ensuring proper light state

Code -

solution.c — C

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

typedef struct {
    pthread_mutex_t mutex;
    int green_road;
} TrafficLight;

typedef struct {
    TrafficLight* tl;
    int car_id;
    int road_id;
    int direction;
} CarData;

void init_traffic_light(TrafficLight* tl) {
    pthread_mutex_init(&tl->mutex, NULL);
    tl->green_road = 1; // Initially road A is green
}

void car_arrived(
    TrafficLight* tl,
    int car_id,
    int road_id,
    int direction,
    void (*turn_green)(int),
    void (*cross_car)(int, int, int)
) {
    pthread_mutex_lock(&tl->mutex);
    
    // Only turn green if current road doesn't have green light
    if (tl->green_road != road_id) {
        tl->green_road = road_id;
        turn_green(road_id);
    }
    
    // Car can now cross safely
    cross_car(car_id, road_id, direction);
    
    pthread_mutex_unlock(&tl->mutex);
}

void turn_green_impl(int road_id) {
    printf("🟢 Road %d light turned GREEN\n", road_id);
    usleep(100000); // 100ms delay
}

void cross_car_impl(int car_id, int road_id, int direction) {
    printf("🚗 Car %d (Road %d, Dir %d) crossing\n", car_id, road_id, direction);
    usleep(200000); // 200ms delay
}

void* car_thread(void* arg) {
    CarData* data = (CarData*)arg;
    
    // Add random delay to simulate real arrival times
    usleep((rand() % 500) * 1000);
    
    car_arrived(data->tl, data->car_id, data->road_id, data->direction,
                turn_green_impl, cross_car_impl);
    
    return NULL;
}

int main() {
    TrafficLight tl;
    init_traffic_light(&tl);
    
    pthread_t threads[5];
    CarData car_data[5] = {
        {&tl, 1, 1, 1},
        {&tl, 2, 2, 3},
        {&tl, 3, 1, 2},
        {&tl, 4, 2, 4},
        {&tl, 5, 1, 1}
    };
    
    // Create threads for car simulations
    for (int i = 0; i < 5; i++) {
        pthread_create(&threads[i], NULL, car_thread, &car_data[i]);
    }
    
    // Wait for all threads to complete
    for (int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("Traffic simulation complete\n");
    pthread_mutex_destroy(&tl.mutex);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) per car arrival

Each car operation is constant time with minimal overhead

✓ Linear Growth

Space Complexity

O(1)

Only stores current green road state and synchronization primitives

✓ Linear Space

Constraints

1 ≤ carId ≤ 20
roadId ∈ {1, 2} where 1 = Road A, 2 = Road B
direction ∈ {1, 2, 3, 4} where 1,2 are Road A directions and 3,4 are Road B directions
Initially, Road A has GREEN light and Road B has RED light
At most 20 cars will call carArrived function
Cars may arrive concurrently from different threads

29.0K 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

State-Aware Synchronization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler