Codestin Search App

Design Underground System - Problem

Imagine you're tasked with building the tracking system for a massive underground railway network like the London Underground or NYC Subway. Your system needs to track millions of passenger journeys and provide real-time analytics about travel times between stations.

You'll implement an UndergroundSystem class that handles three core operations:

Check-In: When a passenger taps their card at a station entrance
Check-Out: When a passenger taps their card at their destination
Analytics: Calculate average travel times between any two stations

The system must efficiently track passenger movements and compute travel statistics from historical data. Think of it as building the brain behind those "Average journey time: 23 minutes" displays you see in subway stations!

Key Requirements:

Passengers can only be checked into one location at a time
Travel times are directional (A→B may differ from B→A)
Average calculations use all historical journeys between two stations
The system must handle real-time queries efficiently

Input & Output

example_1.py — Basic Operations

$ Input: undergroundSystem = UndergroundSystem() undergroundSystem.checkIn(45, "Leyton", 3) undergroundSystem.checkIn(32, "Paradise", 8) undergroundSystem.checkIn(27, "Leyton", 10) undergroundSystem.checkOut(45, "Waterloo", 15) undergroundSystem.checkOut(27, "Waterloo", 20) undergroundSystem.checkOut(32, "Cambridge", 22) print(undergroundSystem.getAverageTime("Paradise", "Cambridge")) # 14.00000 print(undergroundSystem.getAverageTime("Leyton", "Waterloo")) # 11.00000 undergroundSystem.checkIn(10, "Leyton", 24) print(undergroundSystem.getAverageTime("Leyton", "Waterloo")) # 11.00000 undergroundSystem.checkOut(10, "Waterloo", 38) print(undergroundSystem.getAverageTime("Leyton", "Waterloo")) # 12.00000

› Output: 14.00000 11.00000 11.00000 12.00000

💡 Note: The system tracks multiple passengers simultaneously. Passenger 45 travels Leyton→Waterloo in 12 minutes, passenger 27 takes the same route in 10 minutes, giving an initial average of 11.0. When passenger 10 completes the journey in 14 minutes, the new average becomes (12+10+14)/3 = 12.0 minutes.

example_2.py — Directional Routes

$ Input: undergroundSystem = UndergroundSystem() undergroundSystem.checkIn(1, "A", 0) undergroundSystem.checkOut(1, "B", 10) # A→B: 10 min undergroundSystem.checkIn(2, "B", 5) undergroundSystem.checkOut(2, "A", 20) # B→A: 15 min print(undergroundSystem.getAverageTime("A", "B")) # 10.0 print(undergroundSystem.getAverageTime("B", "A")) # 15.0

› Output: 10.0 15.0

💡 Note: Routes are directional - A→B and B→A are tracked separately. This reflects real-world scenarios where travel times can vary based on direction due to factors like traffic patterns, elevation changes, or track configurations.

example_3.py — Multiple Same Routes

$ Input: undergroundSystem = UndergroundSystem() undergroundSystem.checkIn(1, "Station1", 10) undergroundSystem.checkIn(2, "Station1", 20) undergroundSystem.checkIn(3, "Station1", 30) undergroundSystem.checkOut(1, "Station2", 35) # 25 min undergroundSystem.checkOut(2, "Station2", 50) # 30 min undergroundSystem.checkOut(3, "Station2", 45) # 15 min print(undergroundSystem.getAverageTime("Station1", "Station2")) # 23.33333

› Output: 23.33333

💡 Note: Multiple passengers taking the same route contribute to the running average: (25+30+15)/3 = 23.33 minutes. The system efficiently maintains this statistic without storing individual trip details.

Constraints

1 ≤ id, t ≤ 10⁶
1 ≤ stationName.length, startStation.length, endStation.length ≤ 10
All strings consist of uppercase and lowercase English letters and digits
At most 2 × 10⁴ calls in total will be made to checkIn, checkOut, and getAverageTime
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Passenger Check-In

Store passenger ID with their starting station and time in the active passengers table

Passenger Check-Out

Calculate journey time, update route statistics, and remove from active passengers

Analytics Query

Instantly return average by dividing total time by trip count from route statistics

Key Takeaway

🎯 Key Insight: Use aggregated statistics instead of individual records to achieve O(1) performance for real-time analytics

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 U Uber 25

The optimal solution uses two hash tables: one tracking active passengers and another maintaining route statistics with running totals. This achieves O(1) time complexity for all operations by avoiding the need to search through individual trip records. The key insight is to store aggregated data (total time + count) rather than individual trips, making it perfect for real-time analytics systems.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Table Design (Optimal)	O(1)	O(P + R)	Use two hash maps: one for active passengers and one for route statistics with running totals
Brute Force (Store All Trips)	O(n)	O(n)	Store every individual trip and recalculate averages from scratch each time

Optimized Hash Table Design (Optimal) — Algorithm Steps

Maintain active_passengers map: passenger_id → (start_station, start_time)
Maintain route_stats map: (start_station, end_station) → (total_time, trip_count)
On check-in: Store passenger's start station and time
On check-out: Calculate trip duration, update route statistics, remove from active passengers
For average queries: Simply divide total_time by trip_count in O(1) time

Visualization

Tap to expand

Step-by-Step Walkthrough

Check-In

Store in active passengers map

Check-Out

Update route statistics and remove from active

Query Average

Instant O(1) lookup in route stats

Code -

solution.c — C

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

#define MAX_PASSENGERS 1000
#define MAX_ROUTES 1000
#define MAX_STATION_LEN 50

typedef struct {
    char station[MAX_STATION_LEN];
    int time;
    int active;
} CheckIn;

typedef struct {
    char routeKey[MAX_STATION_LEN * 2 + 2];
    int totalTime;
    int count;
    int used;
} RouteStats;

typedef struct {
    CheckIn activePassengers[MAX_PASSENGERS];
    RouteStats routeStats[MAX_ROUTES];
    int routeCount;
} UndergroundSystem;

UndergroundSystem* undergroundSystemCreate() {
    UndergroundSystem* obj = (UndergroundSystem*)malloc(sizeof(UndergroundSystem));
    obj->routeCount = 0;
    
    for (int i = 0; i < MAX_PASSENGERS; i++) {
        obj->activePassengers[i].active = 0;
    }
    
    for (int i = 0; i < MAX_ROUTES; i++) {
        obj->routeStats[i].used = 0;
    }
    
    return obj;
}

void undergroundSystemCheckIn(UndergroundSystem* obj, int id, char* stationName, int t) {
    strcpy(obj->activePassengers[id].station, stationName);
    obj->activePassengers[id].time = t;
    obj->activePassengers[id].active = 1;
}

void undergroundSystemCheckOut(UndergroundSystem* obj, int id, char* stationName, int t) {
    CheckIn checkIn = obj->activePassengers[id];
    int duration = t - checkIn.time;
    
    char routeKey[MAX_STATION_LEN * 2 + 2];
    sprintf(routeKey, "%s,%s", checkIn.station, stationName);
    
    // Find existing route or create new one
    int routeIndex = -1;
    for (int i = 0; i < obj->routeCount; i++) {
        if (obj->routeStats[i].used && strcmp(obj->routeStats[i].routeKey, routeKey) == 0) {
            routeIndex = i;
            break;
        }
    }
    
    if (routeIndex >= 0) {
        obj->routeStats[routeIndex].totalTime += duration;
        obj->routeStats[routeIndex].count++;
    } else {
        strcpy(obj->routeStats[obj->routeCount].routeKey, routeKey);
        obj->routeStats[obj->routeCount].totalTime = duration;
        obj->routeStats[obj->routeCount].count = 1;
        obj->routeStats[obj->routeCount].used = 1;
        obj->routeCount++;
    }
    
    obj->activePassengers[id].active = 0;
}

double undergroundSystemGetAverageTime(UndergroundSystem* obj, char* startStation, char* endStation) {
    char routeKey[MAX_STATION_LEN * 2 + 2];
    sprintf(routeKey, "%s,%s", startStation, endStation);
    
    for (int i = 0; i < obj->routeCount; i++) {
        if (obj->routeStats[i].used && strcmp(obj->routeStats[i].routeKey, routeKey) == 0) {
            return (double)obj->routeStats[i].totalTime / obj->routeStats[i].count;
        }
    }
    
    return 0.0; // Should never reach here based on problem constraints
}

void undergroundSystemFree(UndergroundSystem* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations (checkIn, checkOut, getAverageTime) run in constant time using hash table lookups and updates

✓ Linear Growth

Space Complexity

O(P + R)

P is number of active passengers, R is number of unique routes. Much more efficient than storing all individual trips

✓ Linear Space

89.5K Views

High Frequency

~15 min Avg. Time

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

Optimized Hash Table Design (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler