Design a Parking Lot

export type VehicleType = "motorcycle" | "car" | "truck";export type SpotSize = "small" | "medium" | "large";export interface Vehicle {  plate: string;  type: VehicleType;}// Which spot sizes can hold which vehicle. One table, easy to change.export const FITS: Record<VehicleType, readonly SpotSize[]> = {  motorcycle: ["small", "medium", "large"],  car: ["medium", "large"],  truck: ["large"],};export class Spot {  occupiedBy: string | null = null; // plate, or null when free  readonly id: string;  readonly level: number;  readonly size: SpotSize;  readonly distance: number; // metres from the entrance  constructor(id: string, level: number, size: SpotSize, distance: number) {    this.id = id;    this.level = level;    this.size = size;    this.distance = distance;  }  get isFree(): boolean {    return this.occupiedBy === null;  }  fits(v: Vehicle): boolean {    return FITS[v.type].includes(this.size);  }  // Compare-and-set: succeeds only if the spot is still free right now.  claim(plate: string): boolean {    if (this.occupiedBy !== null) return false;    this.occupiedBy = plate;    return true;  }  release(): void {    this.occupiedBy = null;  }}// ---- Strategy 1: how to pick a spot ----export interface AllocationStrategy {  choose(candidates: Spot[], v: Vehicle): Spot | undefined;}// Candidates are already free and already fit the vehicle.export class NearestToEntrance implements AllocationStrategy {  choose(candidates: Spot[]): Spot | undefined {    return [...candidates].sort((a, b) => a.distance - b.distance)[0];  }}const SIZE_RANK: Record<SpotSize, number> = { small: 0, medium: 1, large: 2 };// Use the smallest spot that fits, so big spots stay free for big vehicles.export class BestFit implements AllocationStrategy {  choose(candidates: Spot[]): Spot | undefined {    return [...candidates].sort(      (a, b) => SIZE_RANK[a.size] - SIZE_RANK[b.size] || a.distance - b.distance,    )[0];  }}// ---- Strategy 2: how to price a stay ----export interface PricingStrategy {  feeCents(v: Vehicle, minutes: number): number;}export class HourlyPricing implements PricingStrategy {  private readonly centsPerHour: Record<VehicleType, number>;  private readonly graceMinutes: number;  constructor(centsPerHour: Record<VehicleType, number>, graceMinutes = 15) {    this.centsPerHour = centsPerHour;    this.graceMinutes = graceMinutes;  }  feeCents(v: Vehicle, minutes: number): number {    if (minutes <= this.graceMinutes) return 0;    return Math.ceil(minutes / 60) * this.centsPerHour[v.type]; // part hours round up  }}// Decorator: wraps any pricing and limits the total for one day.export class DailyCap implements PricingStrategy {  private readonly inner: PricingStrategy;  private readonly capCents: number;  constructor(inner: PricingStrategy, capCents: number) {    this.inner = inner;    this.capCents = capCents;  }  feeCents(v: Vehicle, minutes: number): number {    const days = Math.floor(minutes / 1440);    const rest = minutes % 1440;    return days * this.capCents + Math.min(this.inner.feeCents(v, rest), this.capCents);  }}export interface Ticket {  id: string;  plate: string;  spotId: string;  enteredAt: number; // ms since epoch, from the injected clock}export class ParkingLot {  private readonly active = new Map<string, Ticket>();  private readonly byPlate = new Map<string, string>(); // plate -> ticket id  private nextId = 1;  private readonly spots: Spot[];  private readonly allocation: AllocationStrategy;  private readonly pricing: PricingStrategy;  private readonly now: () => number;  constructor(spots: Spot[], allocation: AllocationStrategy, pricing: PricingStrategy, now: () => number = Date.now) {    this.spots = spots;    this.allocation = allocation;    this.pricing = pricing;    this.now = now;  }  freeCount(): number {    return this.spots.filter((s) => s.isFree).length;  }  park(v: Vehicle): Ticket | null {    if (this.byPlate.has(v.plate)) throw new Error(`already parked: ${v.plate}`);    const candidates = this.spots.filter((s) => s.isFree && s.fits(v));    const spot = this.allocation.choose(candidates, v);    if (!spot || !spot.claim(v.plate)) return null; // lot full for this vehicle    const ticket: Ticket = { id: `T${this.nextId++}`, plate: v.plate, spotId: spot.id, enteredAt: this.now() };    this.active.set(ticket.id, ticket);    this.byPlate.set(v.plate, ticket.id);    return ticket;  }  unpark(ticketId: string, v: Vehicle): { feeCents: number; minutes: number } {    const t = this.active.get(ticketId);    if (!t || t.plate !== v.plate) throw new Error(`unknown ticket: ${ticketId}`);    const minutes = Math.ceil((this.now() - t.enteredAt) / 60000);    const feeCents = this.pricing.feeCents(v, minutes);    this.spots.find((s) => s.id === t.spotId)!.release();    this.active.delete(ticketId);    this.byPlate.delete(t.plate);    return { feeCents, minutes };  }}

import { BestFit, DailyCap, HourlyPricing, ParkingLot, Spot } from "./lot.ts";let clock = Date.UTC(2026, 0, 1, 9, 0);const lot = new ParkingLot(  [    new Spot("L0-S1", 0, "small", 5),    new Spot("L0-M1", 0, "medium", 10),    new Spot("L0-M2", 0, "medium", 12),    new Spot("L1-L1", 1, "large", 40),  ],  new BestFit(),  new DailyCap(new HourlyPricing({ motorcycle: 100, car: 300, truck: 800 }), 2000),  () => clock,);const bike = { plate: "BIKE-1", type: "motorcycle" as const };const car = { plate: "CAR-1", type: "car" as const };const truck = { plate: "TRK-1", type: "truck" as const };const t1 = lot.park(bike)!;const t2 = lot.park(car)!;const t3 = lot.park(truck)!;console.log("bike  ->", t1.spotId); // smallest fit: the small spotconsole.log("car   ->", t2.spotId); // nearest mediumconsole.log("truck ->", t3.spotId); // only largeconsole.log("second truck ->", lot.park({ plate: "TRK-2", type: "truck" })); // null: no large leftconsole.log("free spots:", lot.freeCount());clock += 130 * 60000; // 2 h 10 min laterconsole.log("car leaves:", lot.unpark(t2.id, car));clock += 600 * 60000; // truck stays 12 h 10 min in totalconsole.log("truck leaves:", lot.unpark(t3.id, truck));console.log("free spots:", lot.freeCount());

$ node demo.tsbike  -> L0-S1car   -> L0-M1truck -> L1-L1second truck -> nullfree spots: 1car leaves: { feeCents: 900, minutes: 130 }truck leaves: { feeCents: 2000, minutes: 730 }free spots: 3

import { Spot } from "./lot.ts";const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));const spot = new Spot("S1", 0, "medium", 1);// WRONG: check, then await, then act. Another request can run in the gap.async function parkUnsafe(plate: string): Promise<boolean> {  if (!spot.isFree) return false;  await sleep(10); // stands in for a database call or a payment call  spot.occupiedBy = plate; // blind write  return true;}// RIGHT: the check and the write are one step (compare-and-set).async function parkSafe(plate: string): Promise<boolean> {  await sleep(10); // slow work happens BEFORE the claim  return spot.claim(plate);}console.log("unsafe:", await Promise.all([parkUnsafe("AAA"), parkUnsafe("BBB")]));spot.release();console.log("safe:  ", await Promise.all([parkSafe("AAA"), parkSafe("BBB")]), "owner =", spot.occupiedBy);

$ node race.tsunsafe: [ true, true ]safe:   [ true, false ] owner = AAA

import { test } from "node:test";import assert from "node:assert/strict";import { BestFit, HourlyPricing, DailyCap, NearestToEntrance, ParkingLot, Spot } from "./lot.ts";const rates = { motorcycle: 100, car: 300, truck: 800 };function make(clock = { t: 0 }) {  const spots = [    new Spot("S", 0, "small", 5),    new Spot("M", 0, "medium", 10),    new Spot("L", 0, "large", 1),  ];  const lot = new ParkingLot(spots, new BestFit(), new HourlyPricing(rates), () => clock.t);  return { lot, spots, clock };}const car = { plate: "C1", type: "car" as const };test("best fit gives a motorcycle the small spot, not the nearest one", () => {  const { lot } = make();  assert.equal(lot.park({ plate: "B1", type: "motorcycle" })!.spotId, "S");});test("nearest-to-entrance strategy picks by distance instead", () => {  const spots = [new Spot("far", 0, "medium", 50), new Spot("near", 0, "medium", 2)];  const lot = new ParkingLot(spots, new NearestToEntrance(), new HourlyPricing(rates));  assert.equal(lot.park(car)!.spotId, "near");});test("returns null when no free spot fits", () => {  const { lot } = make();  lot.park(car);  lot.park({ plate: "C2", type: "car" }); // takes the large spot  assert.equal(lot.park({ plate: "C3", type: "car" }), null);  assert.equal(lot.park({ plate: "T1", type: "truck" }), null);});test("the same plate cannot park twice", () => {  const { lot } = make();  lot.park(car);  assert.throws(() => lot.park(car), /already parked/);});

$ node --test --test-reporter=spec lot.test.ts | LC_ALL=C sed 's/\xE2\x9C\x94/pass/; s/\xE2\x84\xB9/#/'pass best fit gives a motorcycle the small spot, not the nearest one (1.44455ms)pass nearest-to-entrance strategy picks by distance instead (0.303418ms)pass returns null when no free spot fits (0.279795ms)pass the same plate cannot park twice (0.522371ms)pass unpark frees the spot and charges part hours as full hours (1.639155ms)pass grace period is free (0.240133ms)pass unknown or wrong ticket is rejected (0.267712ms)pass daily cap wraps any pricing (0.221574ms)# tests 8# suites 0# pass 8# fail 0# cancelled 0# skipped 0# todo 0# duration_ms 205.56542