Design Underground System solution and explanation

class UndergroundSystem:
    def __init__(self):
        self.checkInData = {}
        self.routeData = {}

    def checkIn(self, id: int, stationName: str, t: int):
        self.checkInData[id] = (stationName, t)

    def checkOut(self, id: int, stationName: str, t: int):
        startStation, startTime = self.checkInData.pop(id)
        route = (startStation, stationName)
        travelTime = t - startTime
        if route not in self.routeData:
            self.routeData[route] = [0, 0]
        self.routeData[route][0] += travelTime
        self.routeData[route][1] += 1

    def getAverageTime(self, startStation: str, endStation: str) -> float:
        totalTime, count = self.routeData[(startStation, endStation)]
        return totalTime / count

#include <unordered_map>
#include <string>
#include <utility>
using namespace std;

class UndergroundSystem {
private:
    unordered_map<int, pair<string, int>> checkInData;
    unordered_map<string, pair<int, int>> routeData;

public:
    UndergroundSystem() {}

    void checkIn(int id, const string &stationName, int t) {
        checkInData[id] = {stationName, t};
    }

    void checkOut(int id, const string &stationName, int t) {
        auto &checkInInfo = checkInData[id];
        string routeKey = checkInInfo.first + "->" + stationName;
        int travelTime = t - checkInInfo.second;
        checkInData.erase(id);

        if (routeData.find(routeKey) == routeData.end()) {
            routeData[routeKey] = {0, 0};
        }
        routeData[routeKey].first += travelTime;
        routeData[routeKey].second += 1;
    }

    double getAverageTime(const string &startStation, const string &endStation) {
        string routeKey = startStation + "->" + endStation;
        auto &routeInfo = routeData[routeKey];
        return (double) routeInfo.first / routeInfo.second;
    }
};

class UndergroundSystem {
    constructor() {
        this.checkInData = new Map();
        this.routeData = new Map();
    }

    checkIn(id, stationName, t) {
        this.checkInData.set(id, { stationName, t });
    }

    checkOut(id, stationName, t) {
        const { stationName: startStation, t: startTime } = this.checkInData.get(id);
        this.checkInData.delete(id);
        const routeKey = startStation + '->' + stationName;
        const travelTime = t - startTime;
        if (!this.routeData.has(routeKey)) {
            this.routeData.set(routeKey, { totalTime: 0, tripCount: 0 });
        }
        const routeInfo = this.routeData.get(routeKey);
        routeInfo.totalTime += travelTime;
        routeInfo.tripCount += 1;
        this.routeData.set(routeKey, routeInfo);
    }

    getAverageTime(startStation, endStation) {
        const routeKey = startStation + '->' + endStation;
        const { totalTime, tripCount } = this.routeData.get(routeKey);
        return totalTime / tripCount;
    }
}

import java.util.HashMap;

class UndergroundSystem {
    private HashMap<Integer, CheckInData> checkInMap;
    private HashMap<String, RouteData> routeMap;
    
    class CheckInData {
        String stationName;
        int time;
        CheckInData(String stationName, int time) {
            this.stationName = stationName;
            this.time = time;
        }
    }
    
    class RouteData {
        int totalTime;
        int tripCount;
        RouteData() {
            this.totalTime = 0;
            this.tripCount = 0;
        }
    }

    public UndergroundSystem() {
        this.checkInMap = new HashMap<>();
        this.routeMap = new HashMap<>();
    }
    
    public void checkIn(int id, String stationName, int t) {
        checkInMap.put(id, new CheckInData(stationName, t));
    }

    public void checkOut(int id, String stationName, int t) {
        CheckInData checkInData = checkInMap.get(id);
        String routeKey = checkInData.stationName + "->" + stationName;
        int travelTime = t - checkInData.time;
        checkInMap.remove(id);
        
        RouteData routeData = routeMap.getOrDefault(routeKey, new RouteData());
        routeData.totalTime += travelTime;
        routeData.tripCount += 1;
        routeMap.put(routeKey, routeData);
    }
    
    public double getAverageTime(String startStation, String endStation) {
        String routeKey = startStation + "->" + endStation;
        RouteData routeData = routeMap.get(routeKey);
        return (double) routeData.totalTime / routeData.tripCount;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#define HASH_SIZE 10000

typedef struct CheckInData {
    char stationName[11];
    int time;
} CheckInData;

typedef struct RouteData {
    int totalTime;
    int tripCount;
    struct RouteData *next;
} RouteData;

typedef struct HashTable {
    CheckInData *checkInEntries[HASH_SIZE];
    RouteData *routeEntries[HASH_SIZE];
} HashTable;

unsigned int hash(char *s) {
    unsigned int hash = 0;
    while (*s) hash = (hash * 101 + *s++) % HASH_SIZE;
    return hash;
}

HashTable* createTable() {
    HashTable* ht = (HashTable*) malloc(sizeof(HashTable));
    for (int i = 0; i < HASH_SIZE; i++) {
        ht->checkInEntries[i] = NULL;
        ht->routeEntries[i] = NULL;
    }
    return ht;
}

void checkIn(HashTable *ht, int id, char *stationName, int t) {
    CheckInData *checkInData = (CheckInData*) malloc(sizeof(CheckInData));
    strcpy(checkInData->stationName, stationName);
    checkInData->time = t;
    ht->checkInEntries[id % HASH_SIZE] = checkInData;
}

void checkOut(HashTable *ht, int id, char *stationName, int t) {
    unsigned int index = id % HASH_SIZE;
    CheckInData *checkInData = ht->checkInEntries[index];
    char routeKey[23];
    snprintf(routeKey, 23, "%s->%s", checkInData->stationName, stationName);

    unsigned int hashIndex = hash(routeKey);
    RouteData *routeData = ht->routeEntries[hashIndex];
    int travelTime = t - checkInData->time;

    while (routeData && strcmp(routeKey, routeData + 1)) {
        routeData = routeData->next;
    }
    if (!routeData) {
        routeData = (RouteData *) malloc(sizeof(RouteData) + 24);
        strcpy((char *)(routeData + 1), routeKey);
        routeData->totalTime = 0;
        routeData->tripCount = 0;
        routeData->next = ht->routeEntries[hashIndex];
        ht->routeEntries[hashIndex] = routeData;
    }

    routeData->totalTime += travelTime;
    routeData->tripCount += 1;

    free(checkInData);
    ht->checkInEntries[index] = NULL;
}

double getAverageTime(HashTable *ht, char *startStation, char *endStation) {
    char routeKey[23];
    snprintf(routeKey, 23, "%s->%s", startStation, endStation);
    unsigned int hashIndex = hash(routeKey);
    RouteData *routeData = ht->routeEntries[hashIndex];
    
    while (routeData && strcmp(routeKey, routeData + 1)) {
        routeData = routeData->next;
    }
    
    if (routeData) {
        return (double) routeData->totalTime / routeData->tripCount;
    }
    return -1.0; // should never reach here by constraint
}

int main() {
    HashTable *system = createTable();
    checkIn(system, 1, "Leyton", 10);
    checkOut(system, 1, "Waterloo", 20);
    checkIn(system, 2, "Leyton", 15);
    checkOut(system, 2, "Waterloo", 25);
    printf("Average Time: %.2f\n", getAverageTime(system, "Leyton", "Waterloo"));
    return 0;
}

type UndergroundSystem struct {
	ts map[int]pair
	d  map[station][2]int
}

func Constructor() UndergroundSystem {
	return UndergroundSystem{
		ts: make(map[int]pair),
		d:  make(map[station][2]int),
	}
}

func (this *UndergroundSystem) CheckIn(id int, stationName string, t int) {
	this.ts[id] = pair{t, stationName}
}

func (this *UndergroundSystem) CheckOut(id int, stationName string, t int) {
	p := this.ts[id]
	s := station{p.a, stationName}
	if _, ok := this.d[s]; !ok {
		this.d[s] = [2]int{t - p.t, 1}
	} else {
		this.d[s] = [2]int{this.d[s][0] + t - p.t, this.d[s][1] + 1}
	}

}

func (this *UndergroundSystem) GetAverageTime(startStation string, endStation string) float64 {
	s := station{startStation, endStation}
	return float64(this.d[s][0]) / float64(this.d[s][1])
}

type station struct {
	a string
	b string
}

type pair struct {
	t int
	a string
}

/**
 * Your UndergroundSystem object will be instantiated and called as such:
 * obj := Constructor();
 * obj.CheckIn(id,stationName,t);
 * obj.CheckOut(id,stationName,t);
 * param_3 := obj.GetAverageTime(startStation,endStation);
 */