Parking lot
The warm-up that's really about concurrency.

ParkingLot
  List<Floor> floors
  park(Vehicle): Ticket
  unpark(ticketId): Receipt

Floor
  int number
  Map<SpotType, List<ParkingSpot>> spots

ParkingSpot
  String id
  SpotType type
  AtomicReference<Vehicle> occupant
  tryOccupy(Vehicle): bool
  release()

Vehicle
  String plate
  VehicleType type

Ticket
  String id
  Vehicle vehicle
  ParkingSpot spot
  Instant entryTime

SpotAllocationStrategy (interface)
  allocate(List<Floor>, Vehicle): Optional<ParkingSpot>

PricingStrategy (interface)
  calculate(Ticket, Instant exit): Money

How they connect:
  ParkingLot owns Floor (1 to many)
  Floor owns ParkingSpot (1 to many)
  ParkingLot uses SpotAllocationStrategy
  ParkingLot uses PricingStrategy
  Ticket uses ParkingSpot
  Ticket uses Vehicle

enum VehicleType { BIKE, CAR, TRUCK }
enum SpotType {
    SMALL, MEDIUM, LARGE;
    boolean fits(VehicleType v) {
        return switch (v) {
            case BIKE -> true;                              // fits anywhere
            case CAR -> this != SMALL;
            case TRUCK -> this == LARGE;
        };
    }
}

record Vehicle(String plate, VehicleType type) {}

class ParkingSpot {
    private final String id; private final SpotType type; private final int floor;
    private final AtomicReference<Vehicle> occupant = new AtomicReference<>();

    ParkingSpot(String id, SpotType type, int floor) { this.id = id; this.type = type; this.floor = floor; }

    /** Lock-free claim: only one thread can win the CAS from null → vehicle. */
    boolean tryOccupy(Vehicle v) { return type.fits(v.type()) && occupant.compareAndSet(null, v); }
    void release() { occupant.set(null); }
    boolean isFree() { return occupant.get() == null; }
    SpotType type() { return type; } String id() { return id; } int floor() { return floor; }
}

class Floor {
    private final int number;
    private final List<ParkingSpot> spots;                  // ordered by distance from the gate
    Floor(int number, List<ParkingSpot> spots) { this.number = number; this.spots = spots; }
    List<ParkingSpot> spots() { return spots; }
    long available(SpotType t) { return spots.stream().filter(s -> s.type() == t && s.isFree()).count(); }
}

record Ticket(String id, Vehicle vehicle, ParkingSpot spot, Instant entryTime) {}
record Receipt(String ticketId, Duration duration, BigDecimal amount) {}

interface SpotAllocationStrategy {
    Optional<ParkingSpot> allocate(List<Floor> floors, Vehicle v);
}

/** Nearest first: lowest floor, then the order within the floor; smallest fitting spot type first. */
class NearestSpotStrategy implements SpotAllocationStrategy {
    public Optional<ParkingSpot> allocate(List<Floor> floors, Vehicle v) {
        for (SpotType type : SpotType.values()) {             // SMALL → LARGE: don't waste big spots
            if (!type.fits(v.type())) continue;
            for (Floor f : floors)
                for (ParkingSpot s : f.spots())
                    if (s.type() == type && s.tryOccupy(v)) return Optional.of(s);
        }
        return Optional.empty();
    }
}

interface PricingStrategy { BigDecimal calculate(Ticket t, Instant exit); }

class HourlyPricing implements PricingStrategy {
    private final Map<VehicleType, BigDecimal> ratePerHour;
    HourlyPricing(Map<VehicleType, BigDecimal> ratePerHour) { this.ratePerHour = ratePerHour; }
    public BigDecimal calculate(Ticket t, Instant exit) {
        long minutes = Duration.between(t.entryTime(), exit).toMinutes();
        long hours = Math.max(1, (minutes + 59) / 60);        // round up, minimum 1 hour
        return ratePerHour.get(t.vehicle().type()).multiply(BigDecimal.valueOf(hours));
    }
}

class ParkingLot {
    private final List<Floor> floors;
    private final SpotAllocationStrategy allocator;
    private final PricingStrategy pricing;
    private final Clock clock;
    private final Map<String, Ticket> activeTickets = new ConcurrentHashMap<>();

    ParkingLot(List<Floor> floors, SpotAllocationStrategy allocator, PricingStrategy pricing, Clock clock) {
        this.floors = floors; this.allocator = allocator; this.pricing = pricing; this.clock = clock;
    }

    public Ticket park(Vehicle v) {
        ParkingSpot spot = allocator.allocate(floors, v)
                .orElseThrow(() -> new IllegalStateException("Parking full for " + v.type()));
        Ticket t = new Ticket(UUID.randomUUID().toString(), v, spot, clock.instant());
        activeTickets.put(t.id(), t);
        return t;
    }

    public Receipt unpark(String ticketId) {
        Ticket t = activeTickets.remove(ticketId);            // atomic: a double exit returns null
        if (t == null) throw new IllegalArgumentException("Invalid or already used ticket");
        Instant exit = clock.instant();
        BigDecimal amount = pricing.calculate(t, exit);
        t.spot().release();
        return new Receipt(t.id(), Duration.between(t.entryTime(), exit), amount);
    }
}