Design Underground System

Design Underground System - Problem

Design an UndergroundSystem class that tracks customer travel times between different stations.

Implement these methods:

void checkIn(int id, string stationName, int t) - Customer with card ID checks in at station at time t
void checkOut(int id, string stationName, int t) - Customer checks out from station at time t
double getAverageTime(string startStation, string endStation) - Returns average travel time from start to end station

The system calculates averages from all previous trips between the same start and end stations. All check-ins will have corresponding check-outs, and times are consistent (check-out time > check-in time).

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["UndergroundSystem","checkIn","checkIn","checkIn","checkOut","checkOut","checkOut","getAverageTime","getAverageTime","checkIn","getAverageTime","checkOut","getAverageTime"], parameters = [[],[45,"Leyton",3],[32,"Paradise",8],[27,"Leyton",10],[45,"Waterloo",15],[27,"Waterloo",20],[32,"Cambridge",22],["Paradise","Cambridge"],["Leyton","Waterloo"],[10,"Leyton",24],["Leyton","Waterloo"],[10,"Waterloo",38],["Leyton","Waterloo"]]

› Output: [null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000]

💡 Note: System tracks trips: Paradise→Cambridge (14 min), Leyton→Waterloo (15 min initially, then average with 14 min = 12.0 min)

Example 2 — Multiple Routes

$ Input: operations = ["UndergroundSystem","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime","checkIn","checkOut","getAverageTime"], parameters = [[],[10,"Leyton",3],[10,"Paradise",8],["Leyton","Paradise"],[11,"Paradise",10],[11,"Cambridge",20],["Paradise","Cambridge"],[12,"Cambridge",22],[12,"Leyton",30],["Cambridge","Leyton"]]

› Output: [null,null,null,5.00000,null,null,10.00000,null,null,8.00000]

💡 Note: Three different routes: Leyton→Paradise (5 min), Paradise→Cambridge (10 min), Cambridge→Leyton (8 min)

Example 3 — Same Route Multiple Times

$ Input: operations = ["UndergroundSystem","checkIn","checkOut","checkIn","checkOut","getAverageTime"], parameters = [[],[1,"A",0],[1,"B",10],[2,"A",5],[2,"B",13],["A","B"]]

› Output: [null,null,null,null,null,9.00000]

💡 Note: Two trips on same route A→B: first takes 10 min, second takes 8 min, average = (10+8)/2 = 9.0

Constraints

1 ≤ id, t ≤ 10⁶
1 ≤ stationName.length, startStation.length, endStation.length ≤ 10
All strings contain only lowercase English letters and digits
There will be at most 2 × 10⁴ calls in total
All calls to checkIn and checkOut are consistent
getAverageTime is called with stations that have at least one trip

Visualization

Tap to expand

Asked in

a Amazon 28 f Facebook 15 G Google 12 🍎 Apple 8

The optimal approach uses two hash maps: one to track active trips (id → station, time) and another for route statistics (route → total_time, count). This enables O(1) operations for all methods. Time: O(1), Space: O(P + R) where P is active trips and R is unique routes.

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Brute Force - Store All Trips

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

Keep a list of all completed trips with start station, end station, and duration. When getAverageTime is called, iterate through all trips to find matching routes and calculate the average.

Optimized - Route Statistics

⏱️ Time: O(1) Space: O(P + R)

Use two hash maps: one to track active trips and another to maintain running totals and counts for each route. When calculating averages, simply divide total by count.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* calories, int caloriesSize, int k, int lower, int upper) {
    int points = 0;
    
    // Calculate sum of first window
    int windowSum = 0;
    for (int i = 0; i < k; i++) {
        windowSum += calories[i];
    }
    
    // Check first window
    if (windowSum < lower) {
        points--;
    } else if (windowSum > upper) {
        points++;
    }
    
    // Slide the window
    for (int i = k; i < caloriesSize; i++) {
        // Remove leftmost element, add new rightmost element
        windowSum = windowSum - calories[i - k] + calories[i];
        
        if (windowSum < lower) {
            points--;
        } else if (windowSum > upper) {
            points++;
        }
    }
    
    return points;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int calories[1000];
    int caloriesSize = 0;
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    // Parse array format [1,2,3,4,5]
    char* ptr = line + 1; // Skip opening bracket
    char* token = strtok(ptr, ",]");
    while (token != NULL && caloriesSize < 1000) {
        calories[caloriesSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k, lower, upper;
    scanf("%d", &k);
    scanf("%d", &lower);
    scanf("%d", &upper);
    
    int result = solution(calories, caloriesSize, k, lower, upper);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.5K Views

Medium Frequency

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