Parking lot

enum SpotSize { SMALL = 1, MEDIUM = 2, LARGE = 3 }
enum VehicleType { MOTORCYCLE = "MOTORCYCLE", CAR = "CAR", TRUCK = "TRUCK" }
const NEEDS: Record<VehicleType, SpotSize> = { MOTORCYCLE: SpotSize.SMALL, CAR: SpotSize.MEDIUM, TRUCK: SpotSize.LARGE };

interface Vehicle { plate: string; type: VehicleType; }

class Spot {
  vehicle: Vehicle | null = null;
  constructor(readonly id: string, readonly floor: number, readonly size: SpotSize) {}
  fits(v: Vehicle): boolean { return this.vehicle === null && this.size >= NEEDS[v.type]; }
}

interface Ticket { id: number; plate: string; spotId: string; entryMin: number; }

interface SpotFinder { find(spots: Spot[], v: Vehicle): Spot | null; }

/** Smallest spot that fits, then the lowest floor: keeps big spots free for big vehicles. */
class SmallestFitFinder implements SpotFinder {
  find(spots: Spot[], v: Vehicle): Spot | null {
    const free = spots.filter((s) => s.fits(v));
    free.sort((a, b) => a.size - b.size || a.floor - b.floor || a.id.localeCompare(b.id));
    return free[0] ?? null;
  }
}

interface FeeCalculator { feeCents(v: Vehicle, minutes: number): number; }

/** Every started hour is charged; the rate depends on the vehicle. */
class HourlyFee implements FeeCalculator {
  private static RATES: Record<VehicleType, number> = { MOTORCYCLE: 100, CAR: 200, TRUCK: 500 };
  feeCents(v: Vehicle, minutes: number): number {
    return Math.max(1, Math.ceil(minutes / 60)) * HourlyFee.RATES[v.type];
  }
}

class ParkingLot {
  private spots: Map<string, Spot>;
  private tickets = new Map<number, { t: Ticket; v: Vehicle }>();
  private nextId = 1;

  constructor(spots: Spot[], private finder: SpotFinder, private fees: FeeCalculator) {
    this.spots = new Map(spots.map((s) => [s.id, s]));
  }

  park(v: Vehicle, nowMin: number): Ticket | null {
    const spot = this.finder.find([...this.spots.values()], v);
    if (!spot) return null;
    spot.vehicle = v;
    const t: Ticket = { id: this.nextId++, plate: v.plate, spotId: spot.id, entryMin: nowMin };
    this.tickets.set(t.id, { t, v });
    return t;
  }

  leave(ticketId: number, nowMin: number): number {
    const entry = this.tickets.get(ticketId);
    if (!entry) throw new Error("unknown ticket");
    this.tickets.delete(ticketId);
    this.spots.get(entry.t.spotId)!.vehicle = null;
    return this.fees.feeCents(entry.v, nowMin - entry.t.entryMin);
  }
}

const money = (c: number) => `$${Math.floor(c / 100)}.${String(c % 100).padStart(2, "0")}`;

const lot = new ParkingLot([new Spot("1-S1", 1, SpotSize.SMALL), new Spot("1-M1", 1, SpotSize.MEDIUM), new Spot("1-M2", 1, SpotSize.MEDIUM),
  new Spot("1-L1", 1, SpotSize.LARGE), new Spot("2-M1", 2, SpotSize.MEDIUM)], new SmallestFitFinder(), new HourlyFee());
const arrivals: Vehicle[] = [["MOTO-1", VehicleType.MOTORCYCLE], ["CAR-A", VehicleType.CAR], ["CAR-B", VehicleType.CAR],
  ["TRUCK-1", VehicleType.TRUCK], ["CAR-C", VehicleType.CAR], ["CAR-D", VehicleType.CAR]].map(([plate, type]) => ({ plate, type: type as VehicleType }));
const tickets = new Map<string, Ticket | null>();
for (const v of arrivals) {
  const t = lot.park(v, 0);
  tickets.set(v.plate, t);
  console.log(`${v.plate} -> ${t ? t.spotId : "lot full for this size"}`);
}
console.log("CAR-A leaves after 130 min, pays", money(lot.leave(tickets.get("CAR-A")!.id, 130)));
const t = lot.park({ plate: "CAR-D", type: VehicleType.CAR }, 131);
console.log("CAR-D ->", t ? t.spotId : "lot full");

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

enum SpotSize { SMALL, MEDIUM, LARGE }

enum VehicleType {
    MOTORCYCLE(SpotSize.SMALL), CAR(SpotSize.MEDIUM), TRUCK(SpotSize.LARGE);

    final SpotSize needs;

    VehicleType(SpotSize needs) {
        this.needs = needs;
    }
}

record Vehicle(String plate, VehicleType type) {}

class Spot {
    final String id;
    final int floor;
    final SpotSize size;
    Vehicle vehicle;

    Spot(String id, int floor, SpotSize size) {
        this.id = id;
        this.floor = floor;
        this.size = size;
    }

    boolean fits(Vehicle v) {
        return vehicle == null && size.compareTo(v.type().needs) >= 0;
    }
}

record Ticket(int id, String plate, String spotId, int entryMin) {}

interface SpotFinder {
    Optional<Spot> find(List<Spot> spots, Vehicle v);
}

/** Smallest spot that fits, then the lowest floor: keeps big spots free for big vehicles. */
class SmallestFitFinder implements SpotFinder {
    public Optional<Spot> find(List<Spot> spots, Vehicle v) {
        return spots.stream().filter(s -> s.fits(v))
                .min(Comparator.comparing((Spot s) -> s.size).thenComparingInt(s -> s.floor).thenComparing(s -> s.id));
    }
}

interface FeeCalculator {
    int feeCents(Vehicle v, int minutes);
}

/** Every started hour is charged; the rate depends on the vehicle. */
class HourlyFee implements FeeCalculator {
    private static final Map<VehicleType, Integer> RATES = Map.of(VehicleType.MOTORCYCLE, 100, VehicleType.CAR, 200, VehicleType.TRUCK, 500);

    public int feeCents(Vehicle v, int minutes) {
        int hours = Math.max(1, (minutes + 59) / 60);
        return hours * RATES.get(v.type());
    }
}

class ParkingLot {
    private record Entry(Ticket ticket, Vehicle vehicle) {}

    private final Map<String, Spot> spots = new LinkedHashMap<>();
    private final Map<Integer, Entry> tickets = new HashMap<>();
    private final SpotFinder finder;
    private final FeeCalculator fees;
    private int nextId = 1;

    ParkingLot(List<Spot> spots, SpotFinder finder, FeeCalculator fees) {
        spots.forEach(s -> this.spots.put(s.id, s));
        this.finder = finder;
        this.fees = fees;
    }

    /** synchronized: two cars must never get the same spot. */
    synchronized Optional<Ticket> park(Vehicle v, int nowMin) {
        Optional<Spot> spot = finder.find(new ArrayList<>(spots.values()), v);
        if (spot.isEmpty()) return Optional.empty();
        spot.get().vehicle = v;
        Ticket t = new Ticket(nextId++, v.plate(), spot.get().id, nowMin);
        tickets.put(t.id(), new Entry(t, v));
        return Optional.of(t);
    }

    synchronized int leave(int ticketId, int nowMin) {
        Entry e = tickets.remove(ticketId);
        if (e == null) throw new IllegalArgumentException("unknown ticket");
        spots.get(e.ticket().spotId()).vehicle = null;
        return fees.feeCents(e.vehicle(), nowMin - e.ticket().entryMin());
    }
}

public class Main {
    static String money(int c) {
        return "$" + (c / 100) + "." + (c % 100 < 10 ? "0" : "") + (c % 100);
    }

    public static void main(String[] args) {
        ParkingLot lot = new ParkingLot(List.of(new Spot("1-S1", 1, SpotSize.SMALL), new Spot("1-M1", 1, SpotSize.MEDIUM),
                new Spot("1-M2", 1, SpotSize.MEDIUM), new Spot("1-L1", 1, SpotSize.LARGE), new Spot("2-M1", 2, SpotSize.MEDIUM)),
                new SmallestFitFinder(), new HourlyFee());
        List<Vehicle> arrivals = List.of(new Vehicle("MOTO-1", VehicleType.MOTORCYCLE), new Vehicle("CAR-A", VehicleType.CAR),
                new Vehicle("CAR-B", VehicleType.CAR), new Vehicle("TRUCK-1", VehicleType.TRUCK),
                new Vehicle("CAR-C", VehicleType.CAR), new Vehicle("CAR-D", VehicleType.CAR));
        Map<String, Ticket> tickets = new HashMap<>();
        for (Vehicle v : arrivals) {
            Optional<Ticket> t = lot.park(v, 0);
            t.ifPresent(x -> tickets.put(v.plate(), x));
            System.out.println(v.plate() + " -> " + t.map(Ticket::spotId).orElse("lot full for this size"));
        }
        System.out.println("CAR-A leaves after 130 min, pays " + money(lot.leave(tickets.get("CAR-A").id(), 130)));
        System.out.println("CAR-D -> " + lot.park(new Vehicle("CAR-D", VehicleType.CAR), 131).map(Ticket::spotId).orElse("lot full"));
    }
}