diff --git a/README.md b/README.md index bb4ff42..7afdb79 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,7 @@ One module per article. This repository currently holds: | [`bookmyshow`](bookmyshow/) | Low-Level Design: BookMyShow Seat Booking in Java (Handling Concurrent Bookings) | this commit | | [`splitwise`](splitwise/) | Low-Level Design: Splitwise (Expense Sharing) in Java | this commit | | [`graph-algorithms`](graph-algorithms/) | Graph Algorithms in Java: Dijkstra, Topological Sort and Union-Find | this commit | +| [`elevator`](elevator/) | Low-Level Design: Elevator System in Java (State Pattern and Scheduling) | this commit | ## `collections` module diff --git a/elevator/README.md b/elevator/README.md new file mode 100644 index 0000000..a380557 --- /dev/null +++ b/elevator/README.md @@ -0,0 +1,62 @@ +# elevator + +Companion code for the ankurm.com article **Low-Level Design: Elevator System in Java (State Pattern and Scheduling)**. + +A tick-based elevator simulation in plain Java: a car built as a State pattern (idle, moving, doors open, maintenance), the LOOK rule that +decides where a car goes next, three dispatchers that choose which car answers a hall button (round robin, nearest car, and one that asks each +car for a forecast of its own future), and a simulation that measures them on seeded traffic. Every figure and console line in the article is +quoted from a file in `output/`, which the JUnit tests write while asserting the same numbers. There is no `docs/` folder: the explanations +live in the article itself. + +## Versions + +| Component | Version | Verified against | +|---|---|---| +| JDK | Temurin 25.0.5+8 (LTS) | `java -version` | +| JUnit | 6.1.3 | `junit-bom` `maven-metadata.xml` on Maven Central (latest GA) | +| Maven | 3.9.11 | `mvn -version` | + +No frameworks and no runtime dependencies: everything in `src/main` is plain Java. + +## Quickstart + +```bash +cd elevator +export JAVA_HOME=/path/to/jdk-25 PATH="$JAVA_HOME/bin:$PATH" +./scripts/run-all.sh # runs every test and regenerates output/*.txt +``` + +The first Maven run must be online so the plugins land in the local cache. Every transcript is deterministic: the traffic is generated from +fixed seeds and nothing depends on the wall clock. + +## The pieces + +| Class | Role | +|---|---| +| `Direction`, `Stop` | UP, DOWN or NONE; a floor a car has promised to visit, tagged with the direction of the button that asked | +| `Car` | floor, heading, stops and riders; delegates every tick to its state; implements the LOOK rule and `eta()` | +| `CarState` | the State interface: `tick(car, lobby)` and `copy()` | +| `IdleState`, `MovingState`, `DoorsOpenState`, `MaintenanceState` | the four behaviours; `DoorsOpenState.open` is where people get off and on | +| `Lobby` | what a car may know about the building; `Lobby.FORECAST` is a do-nothing lobby for cloned cars | +| `Building` | floors, cars, waiting people, a dispatcher; one `tick()` moves the whole world one step | +| `Dispatcher` | chooses the car for a hall button | +| `RoundRobinDispatcher`, `NearestCarDispatcher`, `EtaDispatcher` | the three strategies | +| `Passenger`, `Arrival`, `Traffic`, `Simulation`, `Report` | people, seeded traffic, the run loop and its summary | +| `PolicyComparison`, `StarvationDemo` | FCFS, SSTF and LOOK on a bare list of floors, and the starvation case | + +## Transcripts + +| File | Written by | What it shows | +|---|---|---| +| `01-single-car-trace.txt` | `TraceTest` | one car, three people, one line per tick; why a DOWN button is skipped while the car goes UP | +| `02-policies.txt`, `02b-starvation.txt` | `PolicyTest` | FCFS vs SSTF vs LOOK distance; SSTF leaving one request waiting 46 ticks | +| `03-dispatchers.txt`, `03b-eta-forecast.txt` | `DispatcherTest` | three dispatchers on 120 people, two traffic shapes; a forecast that matches the real run | +| `04-maintenance.txt`, `04b-all-cars-out.txt` | `MaintenanceTest` | taking a car out of service with a rider aboard; every car out of service | +| `05-capacity.txt` | `CapacityTest` | capacity 2, five people: a full car leaves people behind and the call is re-issued | +| `06-validation.txt`, `06b-stop-outside-shaft.txt` | `ValidationTest` | the exact message for each refused request | +| `07-invariants.txt` | `InvariantsTest` | 900 randomised runs, rules checked after every tick | +| `08-nearest-car-trap.txt`, `08b-same-button.txt` | `PitfallsTest` | the nearest-car trap; five people, one hall call | + +## License + +MIT — see [LICENSE](../LICENSE). diff --git a/elevator/output/01-single-car-trace.txt b/elevator/output/01-single-car-trace.txt new file mode 100644 index 0000000..aa5f630 --- /dev/null +++ b/elevator/output/01-single-car-trace.txt @@ -0,0 +1,50 @@ +One car, three people, one tick per line (floors 0..9, doors stay open 3 ticks) +=============================================================================== + +p0 starts at 0 and wants 6 (UP). p1 starts at 4 and wants 8 (UP). p2 starts at 3 and wants 1 (DOWN). +All three press their button at tick 0. + +t=00 car0 floor 0 DOORS_OPEN UP stops [4u, 3d, 6] riders [p0(0->6)] +t=01 car0 floor 0 DOORS_OPEN UP stops [4u, 3d, 6] riders [p0(0->6)] +t=02 car0 floor 0 DOORS_OPEN UP stops [4u, 3d, 6] riders [p0(0->6)] +t=03 car0 floor 0 MOVING_UP UP stops [4u, 3d, 6] riders [p0(0->6)] +t=04 car0 floor 1 MOVING_UP UP stops [4u, 3d, 6] riders [p0(0->6)] +t=05 car0 floor 2 MOVING_UP UP stops [4u, 3d, 6] riders [p0(0->6)] +t=06 car0 floor 3 MOVING_UP UP stops [4u, 3d, 6] riders [p0(0->6)] +t=07 car0 floor 4 DOORS_OPEN UP stops [3d, 6, 8] riders [p0(0->6), p1(4->8)] +t=08 car0 floor 4 DOORS_OPEN UP stops [3d, 6, 8] riders [p0(0->6), p1(4->8)] +t=09 car0 floor 4 DOORS_OPEN UP stops [3d, 6, 8] riders [p0(0->6), p1(4->8)] +t=10 car0 floor 4 MOVING_UP UP stops [3d, 6, 8] riders [p0(0->6), p1(4->8)] +t=11 car0 floor 5 MOVING_UP UP stops [3d, 6, 8] riders [p0(0->6), p1(4->8)] +t=12 car0 floor 6 DOORS_OPEN UP stops [3d, 8] riders [p1(4->8)] +t=13 car0 floor 6 DOORS_OPEN UP stops [3d, 8] riders [p1(4->8)] +t=14 car0 floor 6 DOORS_OPEN UP stops [3d, 8] riders [p1(4->8)] +t=15 car0 floor 6 MOVING_UP UP stops [3d, 8] riders [p1(4->8)] +t=16 car0 floor 7 MOVING_UP UP stops [3d, 8] riders [p1(4->8)] +t=17 car0 floor 8 DOORS_OPEN UP stops [3d] riders [] +t=18 car0 floor 8 DOORS_OPEN UP stops [3d] riders [] +t=19 car0 floor 8 DOORS_OPEN UP stops [3d] riders [] +t=20 car0 floor 8 MOVING_DOWN DOWN stops [3d] riders [] +t=21 car0 floor 7 MOVING_DOWN DOWN stops [3d] riders [] +t=22 car0 floor 6 MOVING_DOWN DOWN stops [3d] riders [] +t=23 car0 floor 5 MOVING_DOWN DOWN stops [3d] riders [] +t=24 car0 floor 4 MOVING_DOWN DOWN stops [3d] riders [] +t=25 car0 floor 3 DOORS_OPEN DOWN stops [1] riders [p2(3->1)] +t=26 car0 floor 3 DOORS_OPEN DOWN stops [1] riders [p2(3->1)] +t=27 car0 floor 3 DOORS_OPEN DOWN stops [1] riders [p2(3->1)] +t=28 car0 floor 3 MOVING_DOWN DOWN stops [1] riders [p2(3->1)] +t=29 car0 floor 2 MOVING_DOWN DOWN stops [1] riders [p2(3->1)] +t=30 car0 floor 1 DOORS_OPEN DOWN stops [] riders [] + +Door openings (from the building log): + t=0 car0 opens at 0 heading UP off=[] on=[p0(0->6)] + t=7 car0 opens at 4 heading UP off=[] on=[p1(4->8)] + t=12 car0 opens at 6 heading UP off=[p0(0->6)] on=[] + t=17 car0 opens at 8 heading UP off=[p1(4->8)] on=[] + t=25 car0 opens at 3 heading DOWN off=[] on=[p2(3->1)] + t=30 car0 opens at 1 heading DOWN off=[p2(3->1)] on=[] + +Per person (ticks): wait = button to boarding, ride = boarding to arrival + p0 p0(0->6) wait 0 ride 12 total 12 + p1 p1(4->8) wait 7 ride 10 total 17 + p2 p2(3->1) wait 25 ride 5 total 30 diff --git a/elevator/output/02-policies.txt b/elevator/output/02-policies.txt new file mode 100644 index 0000000..197eb71 --- /dev/null +++ b/elevator/output/02-policies.txt @@ -0,0 +1,8 @@ +One car at floor 5 heading up, six requests: floors travelled +============================================================= + +requests in arrival order: [8, 2, 9, 1, 6, 3] + +FCFS order [8, 2, 9, 1, 6, 3] distance 32 +SSTF order [6, 8, 9, 3, 2, 1] distance 12 +LOOK order [6, 8, 9, 3, 2, 1] distance 12 diff --git a/elevator/output/02b-starvation.txt b/elevator/output/02b-starvation.txt new file mode 100644 index 0000000..f4d95be --- /dev/null +++ b/elevator/output/02b-starvation.txt @@ -0,0 +1,7 @@ +A request waits at floor 0; the car is at floor 5; new requests keep appearing at floors 6 and 7 +================================================================================================ + +The stream of new requests lasts 40 ticks. The car moves one floor per tick. + +SSTF far request served at tick 46 +LOOK far request served at tick 9 diff --git a/elevator/output/03-dispatchers.txt b/elevator/output/03-dispatchers.txt new file mode 100644 index 0000000..50f4d72 --- /dev/null +++ b/elevator/output/03-dispatchers.txt @@ -0,0 +1,20 @@ +12 floors, 3 cars (capacity 8), 120 people: same seeded traffic through three dispatchers +========================================================================================= + +Times are in ticks. 'wait' is button press to boarding; 'total' is button press to arrival. + +Up-peak (70% start at the lobby), seed 42, arrivals spread over 240 ticks + round-robin delivered 120/120 wait avg 18.5 max 57 total avg 32.7 max 79 floors 363 door cycles 134 ticks 299 + hall calls per car (car0, car1, car2): [15, 15, 15] + nearest-car delivered 120/120 wait avg 91.9 max 248 total avg 106.4 max 258 floors 317 door cycles 129 ticks 481 + hall calls per car (car0, car1, car2): [23, 15, 4] + eta delivered 120/120 wait avg 13.7 max 43 total avg 27.6 max 63 floors 338 door cycles 136 ticks 273 + hall calls per car (car0, car1, car2): [18, 15, 14] + +Between floors (uniform origin and destination), seed 7, arrivals spread over 360 ticks + round-robin delivered 120/120 wait avg 13.3 max 45 total avg 22.6 max 69 floors 564 door cycles 181 ticks 400 + hall calls per car (car0, car1, car2): [30, 30, 29] + nearest-car delivered 120/120 wait avg 16.5 max 66 total avg 26.5 max 86 floors 428 door cycles 177 ticks 398 + hall calls per car (car0, car1, car2): [36, 25, 26] + eta delivered 120/120 wait avg 9.9 max 43 total avg 19.6 max 61 floors 489 door cycles 190 ticks 378 + hall calls per car (car0, car1, car2): [37, 28, 33] diff --git a/elevator/output/03b-eta-forecast.txt b/elevator/output/03b-eta-forecast.txt new file mode 100644 index 0000000..bb82165 --- /dev/null +++ b/elevator/output/03b-eta-forecast.txt @@ -0,0 +1,5 @@ +ETA forecast for an idle car at floor 0 and a call at floor 7 (UP) +================================================================== + +predicted: 7 ticks +actual: 7 ticks diff --git a/elevator/output/04-maintenance.txt b/elevator/output/04-maintenance.txt new file mode 100644 index 0000000..04b4ec4 --- /dev/null +++ b/elevator/output/04-maintenance.txt @@ -0,0 +1,18 @@ +Taking car0 out of service while it carries a passenger +======================================================= + +t=5: maintenance requested for car0, which is carrying 'a' to floor 5 + +t=05 car0 floor 2 MOVING_UP UP stops [5] riders [a(0->5)] | car1 floor 8 MOVING_DOWN DOWN stops [2u] riders [] +t=06 car0 floor 3 MOVING_UP UP stops [5] riders [a(0->5)] | car1 floor 7 MOVING_DOWN DOWN stops [2u] riders [] +t=07 car0 floor 4 MOVING_UP UP stops [5] riders [a(0->5)] | car1 floor 6 MOVING_DOWN DOWN stops [2u] riders [] +t=08 car0 floor 5 DOORS_OPEN UP stops [] riders [] | car1 floor 5 MOVING_DOWN DOWN stops [2u] riders [] +t=09 car0 floor 5 DOORS_OPEN UP stops [] riders [] | car1 floor 4 MOVING_DOWN DOWN stops [2u] riders [] +t=10 car0 floor 5 DOORS_OPEN UP stops [] riders [] | car1 floor 3 MOVING_DOWN DOWN stops [2u] riders [] +t=11 car0 floor 5 IDLE NONE stops [] riders [] | car1 floor 2 DOORS_OPEN UP stops [6] riders [b(2->6)] +t=12 car0 floor 5 MAINTENANCE NONE stops [] riders [] | car1 floor 2 DOORS_OPEN UP stops [6] riders [b(2->6)] + +car0 entered MAINTENANCE at tick 12 at floor 5 +hall call for 'b' went to: t=5 hall 2u -> car1 (at 9 IDLE) + +after returnToService(): car0 floor 5 DOORS_OPEN UP stops [9] riders [c(5->9)] diff --git a/elevator/output/04b-all-cars-out.txt b/elevator/output/04b-all-cars-out.txt new file mode 100644 index 0000000..d912b28 --- /dev/null +++ b/elevator/output/04b-all-cars-out.txt @@ -0,0 +1,5 @@ +Both cars out of service, one person presses a button +===================================================== + +after 10 ticks: delivered=0 waiting=1 +car1 returned to service: delivered after 11 more ticks diff --git a/elevator/output/05-capacity.txt b/elevator/output/05-capacity.txt new file mode 100644 index 0000000..16c00e1 --- /dev/null +++ b/elevator/output/05-capacity.txt @@ -0,0 +1,22 @@ +Capacity 2, five people at the lobby, all going UP +================================================== + +hall calls dispatched after five button presses: 1 + +t=0 hall 0u -> car0 (at 0 IDLE) +t=0 hall 0u -> car0 (at 0 DOORS_OPEN) +t=0 car0 opens at 0 heading UP off=[] on=[p0(0->2), p1(0->3)] +t=5 car0 opens at 2 heading UP off=[p0(0->2)] on=[] +t=9 car0 opens at 3 heading UP off=[p1(0->3)] on=[] +t=15 hall 0u -> car0 (at 0 DOORS_OPEN) +t=15 car0 opens at 0 heading UP off=[] on=[p2(0->4), p3(0->5)] +t=22 car0 opens at 4 heading UP off=[p2(0->4)] on=[] +t=26 car0 opens at 5 heading UP off=[p3(0->5)] on=[] +t=34 car0 opens at 0 heading UP off=[] on=[p4(0->6)] +t=43 car0 opens at 6 heading UP off=[p4(0->6)] on=[] + +p0(0->2) wait 0 ride 5 +p1(0->3) wait 0 ride 9 +p2(0->4) wait 15 ride 7 +p3(0->5) wait 15 ride 11 +p4(0->6) wait 34 ride 9 diff --git a/elevator/output/06-validation.txt b/elevator/output/06-validation.txt new file mode 100644 index 0000000..06bf392 --- /dev/null +++ b/elevator/output/06-validation.txt @@ -0,0 +1,10 @@ +Requests the building refuses, and the exact message +==================================================== + +origin above the top floor -> origin floor 12 is outside 0..9 +origin below the ground floor -> origin floor -1 is outside 0..9 +destination above the top floor -> destination floor 10 is outside 0..9 +destination below the ground floor -> destination floor -4 is outside 0..9 +same origin and destination -> origin and destination are both floor 5 + +people waiting afterwards: 0, hall calls dispatched: 0 diff --git a/elevator/output/06b-stop-outside-shaft.txt b/elevator/output/06b-stop-outside-shaft.txt new file mode 100644 index 0000000..139b581 --- /dev/null +++ b/elevator/output/06b-stop-outside-shaft.txt @@ -0,0 +1,4 @@ +A stop above the top floor +========================== + +addStop(10) -> floor 10 is outside 0..9 diff --git a/elevator/output/07-invariants.txt b/elevator/output/07-invariants.txt new file mode 100644 index 0000000..4488f5c --- /dev/null +++ b/elevator/output/07-invariants.txt @@ -0,0 +1,7 @@ +Randomised runs: 150 seeds x 3 dispatchers x 2 traffic shapes, rules checked after every tick +============================================================================================= + +runs: 900 +people delivered: 36000 +simulated ticks checked: 137430 +rule violations: 0 diff --git a/elevator/output/08-nearest-car-trap.txt b/elevator/output/08-nearest-car-trap.txt new file mode 100644 index 0000000..30c3be6 --- /dev/null +++ b/elevator/output/08-nearest-car-trap.txt @@ -0,0 +1,11 @@ +Hall call UP at floor 3 while car0 (at 4) is going DOWN and car1 waits at 9 +=========================================================================== + +nearest-car: after 4 ticks car0 floor 4 MOVING_DOWN DOWN stops [0] riders [rider(4->0)] +nearest-car: t=4 hall 3u -> car0 (at 4 MOVING_DOWN) +eta: after 4 ticks car0 floor 4 MOVING_DOWN DOWN stops [0] riders [rider(4->0)] +eta: t=4 hall 3u -> car1 (at 9 IDLE) + +wait for the person at floor 3, in ticks: + nearest-car 9 + eta 5 diff --git a/elevator/output/08b-same-button.txt b/elevator/output/08b-same-button.txt new file mode 100644 index 0000000..f324ed5 --- /dev/null +++ b/elevator/output/08b-same-button.txt @@ -0,0 +1,5 @@ +Five people at floor 6 all press UP +=================================== + +hall calls dispatched: 1 +door cycles used to serve all five: 2 diff --git a/elevator/pom.xml b/elevator/pom.xml new file mode 100644 index 0000000..3ba0e96 --- /dev/null +++ b/elevator/pom.xml @@ -0,0 +1,64 @@ + + + 4.0.0 + com.ankurm.interviewlab + elevator + 1.0.0 + jar + + java-interview-lab :: elevator + + Runnable companion code for ankurm.com's "Low-Level Design: Elevator System in Java" article: State pattern car, LOOK scheduling, + three dispatchers (nearest, round robin, ETA) and a tick-based simulation. + + + + 25 + UTF-8 + 6.1.3 + + + + + + org.junit + junit-bom + ${junit.version} + pom + import + + + + + + + org.junit.jupiter + junit-jupiter + test + + + org.junit.platform + junit-platform-launcher + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.14.0 + + + org.apache.maven.plugins + maven-surefire-plugin + 3.6.0 + + -Xmx512m -Duser.timezone=UTC -Dfile.encoding=UTF-8 + + + + + diff --git a/elevator/scripts/run-all.sh b/elevator/scripts/run-all.sh new file mode 100755 index 0000000..3e32205 --- /dev/null +++ b/elevator/scripts/run-all.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash +# Regenerates every file in output/. Needs JDK 25 and Maven. The first Maven run must be online. +# Every file is written by a JUnit test that asserts the same numbers it prints, so the figures +# in the article are assertions: they fail the build the moment they stop being true. +set -euo pipefail +cd "$(dirname "$0")/.." +rm -rf output && mkdir -p output +mvn -B -q -T1 test +echo "done:"; ls -1 output diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Arrival.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Arrival.java new file mode 100644 index 0000000..9ae9925 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Arrival.java @@ -0,0 +1,4 @@ +package com.ankurm.interviewlab.elevator; + +/** A person who will walk up to a lift at a given tick. */ +public record Arrival(long tick, int origin, int destination) { } diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Building.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Building.java new file mode 100644 index 0000000..49c0f4c --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Building.java @@ -0,0 +1,118 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Deque; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +/** Floors 0..floors-1, some cars, one dispatcher, and the people waiting in the lobbies. */ +public final class Building implements Lobby { + private final int floors; + private final List cars = new ArrayList<>(); + private final Dispatcher dispatcher; + private final Map> waiting = new TreeMap<>(); + private final List delivered = new ArrayList<>(); + private final List unassigned = new ArrayList<>(); + private final List log = new ArrayList<>(); + private long now; + private int hallCallsDispatched; + + public Building(int floors, int[] startFloors, int capacity, Dispatcher dispatcher) { + this.floors = floors; + this.dispatcher = dispatcher; + for (int i = 0; i < startFloors.length; i++) { + cars.add(new Car(i, 0, floors - 1, startFloors[i], capacity)); + } + } + + /** Cars start spread evenly over the shaft, the way a parking policy would leave them. */ + public static Building of(int floors, int carCount, int capacity, Dispatcher dispatcher) { + int[] start = new int[carCount]; + for (int i = 0; i < carCount; i++) start[i] = carCount == 1 ? 0 : i * (floors - 1) / (carCount - 1); + return new Building(floors, start, capacity, dispatcher); + } + + public List cars() { return Collections.unmodifiableList(cars); } + public List deliveredPassengers() { return Collections.unmodifiableList(delivered); } + public List log() { return Collections.unmodifiableList(log); } + public int hallCallsDispatched() { return hallCallsDispatched; } + public int floors() { return floors; } + public int waitingCount() { return waiting.values().stream().mapToInt(Deque::size).sum(); } + public Dispatcher dispatcher() { return dispatcher; } + + /** A person walks up to the lift and presses the button for their direction. */ + public void submit(Passenger p) { + if (p.origin() < 0 || p.origin() >= floors) { + throw new IllegalArgumentException("origin floor " + p.origin() + " is outside 0.." + (floors - 1)); + } + if (p.destination() < 0 || p.destination() >= floors) { + throw new IllegalArgumentException("destination floor " + p.destination() + " is outside 0.." + (floors - 1)); + } + if (p.origin() == p.destination()) { + throw new IllegalArgumentException("origin and destination are both floor " + p.origin()); + } + waiting.computeIfAbsent(p.origin(), f -> new ArrayDeque<>()).add(p); + if (!hallStopPending(p.origin(), p.direction())) callHall(p.origin(), p.direction()); + } + + /** One tick of the whole building: retry unassigned calls, then every car acts once. */ + public void tick() { + if (!unassigned.isEmpty()) { + List retry = new ArrayList<>(unassigned); + unassigned.clear(); + for (Stop s : retry) callHall(s.floor(), s.dir()); + } + for (Car c : cars) c.tick(this); + now++; + } + + // ---- Lobby ----------------------------------------------------------------------------- + + @Override public long now() { return now; } + + @Override + public Deque waitingAt(int floor) { + return waiting.computeIfAbsent(floor, f -> new ArrayDeque<>()); + } + + @Override + public boolean hallStopPending(int floor, Direction dir) { + Stop wanted = new Stop(floor, dir); + return unassigned.contains(wanted) || cars.stream().anyMatch(c -> c.stops().contains(wanted)); + } + + @Override + public void callHall(int floor, Direction dir) { + List available = cars.stream().filter(Car::accepting).toList(); + Stop stop = new Stop(floor, dir); + if (available.isEmpty()) { + if (!unassigned.contains(stop)) unassigned.add(stop); + return; + } + Car chosen = dispatcher.choose(available, floor, dir); + chosen.addStop(stop); + hallCallsDispatched++; + log.add("t=" + now + " hall " + stop + " -> car" + chosen.id() + " (at " + chosen.floor() + " " + chosen.stateName() + ")"); + } + + @Override + public void hallServed(Car by, int floor, Direction dir) { + Stop stop = new Stop(floor, dir); + for (Car c : cars) { + if (c != by) c.removeStops(java.util.Set.of(stop)); + } + } + + @Override public void boarded(Passenger p) { p.boardedAt(now); } + + @Override + public void delivered(Passenger p) { + p.arrivedAt(now); + delivered.add(p); + } + + @Override public void log(String message) { log.add(message); } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Car.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Car.java new file mode 100644 index 0000000..2247558 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Car.java @@ -0,0 +1,174 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +/** + * One elevator car. It holds the data (floor, heading, promised stops, riders) and delegates + * every tick to its current {@link CarState}. + */ +public final class Car { + /** Ticks the doors stay open. */ + public static final int DWELL_TICKS = 3; + + private final int id; + private final int minFloor; + private final int maxFloor; + private final int capacity; + private int floor; + private Direction heading = Direction.NONE; + private CarState state = new IdleState(); + private final Set stops = new LinkedHashSet<>(); + private final List riders = new ArrayList<>(); + private boolean maintenanceRequested; + private int floorsTravelled; + private int doorCycles; + + public Car(int id, int minFloor, int maxFloor, int startFloor, int capacity) { + this.id = id; + this.minFloor = minFloor; + this.maxFloor = maxFloor; + this.floor = startFloor; + this.capacity = capacity; + } + + // ---- read side ------------------------------------------------------------------------- + + public int id() { return id; } + public int floor() { return floor; } + public Direction heading() { return heading; } + public String stateName() { return state.name(); } + public int capacity() { return capacity; } + public int riderCount() { return riders.size(); } + public List riders() { return Collections.unmodifiableList(riders); } + public Set stops() { return Collections.unmodifiableSet(stops); } + public int floorsTravelled() { return floorsTravelled; } + public int doorCycles() { return doorCycles; } + public boolean maintenanceRequested() { return maintenanceRequested; } + public boolean inMaintenance() { return state instanceof MaintenanceState; } + + /** May the dispatcher give this car new work? */ + public boolean accepting() { return !maintenanceRequested && !inMaintenance(); } + + // ---- commands -------------------------------------------------------------------------- + + public void addStop(Stop stop) { + if (stop.floor() < minFloor || stop.floor() > maxFloor) { + throw new IllegalArgumentException("floor " + stop.floor() + " is outside " + minFloor + ".." + maxFloor); + } + if (stop.dir() == Direction.NONE && stop.floor() == floor) return; // already here + stops.add(stop); + } + + public void requestMaintenance() { maintenanceRequested = true; } + + public void returnToService() { + maintenanceRequested = false; + if (state instanceof MaintenanceState) state = new IdleState(); + } + + void tick(Lobby lobby) { state.tick(this, lobby); } + + // ---- the LOOK rule --------------------------------------------------------------------- + + /** Is there a stop strictly ahead of the car when travelling in direction h? */ + boolean aheadOf(Direction h) { + for (Stop s : stops) { + if ((h == Direction.UP && s.floor() > floor) || (h == Direction.DOWN && s.floor() < floor)) return true; + } + return false; + } + + Set stopsHere() { + Set here = new LinkedHashSet<>(); + for (Stop s : stops) { + if (s.floor() == floor) here.add(s); + } + return here; + } + + /** + * The stops at this floor that a car travelling in direction h should serve now: stops going + * the same way, car calls, and (only at the turning point) stops going the other way. + */ + Set servedHere(Direction h) { + Set here = stopsHere(); + Set served = new LinkedHashSet<>(); + for (Stop s : here) { + if (s.dir() == h || s.dir() == Direction.NONE) served.add(s); + } + boolean sameDirectionHall = served.stream().anyMatch(s -> s.dir() == h); + if (!aheadOf(h) && !sameDirectionHall) { + for (Stop s : here) { + if (s.dir() == h.opposite()) served.add(s); + } + } + return served; + } + + /** Keep going while there is something ahead, turn round when there is only something behind, else stop. */ + Direction nextHeading() { + if (heading != Direction.NONE) { + if (aheadOf(heading)) return heading; + if (aheadOf(heading.opposite())) return heading.opposite(); + return Direction.NONE; + } + int best = Integer.MAX_VALUE; + Direction dir = Direction.NONE; + for (Stop s : stops) { + if (s.floor() == floor) continue; + int d = Math.abs(s.floor() - floor); + Direction towards = Direction.between(floor, s.floor()); + if (d < best || (d == best && towards == Direction.UP)) { + best = d; + dir = towards; + } + } + return dir; + } + + // ---- forecasting ----------------------------------------------------------------------- + + /** + * Ticks until this car would open its doors for a new hall call, found by cloning the car + * and running the real state machine forward. Nobody boards in the clone, so the figure + * ignores stops the car will pick up on the way: an estimate, not a promise. + */ + public int eta(int callFloor, Direction callDir) { + Car copy = new Car(id, minFloor, maxFloor, floor, capacity); + copy.heading = heading; + copy.state = state.copy(); + copy.stops.addAll(stops); + copy.riders.addAll(riders); + Stop wanted = new Stop(callFloor, callDir); + copy.stops.add(wanted); + for (int t = 1; t <= 1000; t++) { + copy.tick(Lobby.FORECAST); + if (!copy.stops.contains(wanted)) return t; + } + return Integer.MAX_VALUE; + } + + // ---- package-private mutators used by the states ---------------------------------------- + + void setState(CarState next) { this.state = next; } + CarState state() { return state; } + void setHeading(Direction h) { this.heading = h; } + void removeStops(Set served) { stops.removeAll(served); } + List ridersMutable() { return riders; } + void countDoorCycle() { doorCycles++; } + + void step(Direction d) { + floor += d.delta(); + floorsTravelled++; + if (floor < minFloor || floor > maxFloor) throw new IllegalStateException("car" + id + " left the shaft at " + floor); + } + + @Override + public String toString() { + return "car" + id + "@" + floor + " " + state.name() + " stops=" + stops; + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/CarState.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/CarState.java new file mode 100644 index 0000000..fadbdb1 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/CarState.java @@ -0,0 +1,11 @@ +package com.ankurm.interviewlab.elevator; + +/** One behaviour of a car. The car owns the data; each state owns what happens on a tick. */ +interface CarState { + String name(); + + void tick(Car car, Lobby lobby); + + /** A copy with the same internal counters, so a cloned car can be run forward without touching the real one. */ + CarState copy(); +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Direction.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Direction.java new file mode 100644 index 0000000..f097db2 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Direction.java @@ -0,0 +1,26 @@ +package com.ankurm.interviewlab.elevator; + +/** Travel direction of a car, or of a hall button. NONE means "either": a car call, or an idle car. */ +public enum Direction { + UP, DOWN, NONE; + + public Direction opposite() { + return switch (this) { + case UP -> DOWN; + case DOWN -> UP; + case NONE -> NONE; + }; + } + + public int delta() { + return switch (this) { + case UP -> 1; + case DOWN -> -1; + case NONE -> 0; + }; + } + + public static Direction between(int from, int to) { + return Integer.compare(to, from) > 0 ? UP : Integer.compare(to, from) < 0 ? DOWN : NONE; + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Dispatcher.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Dispatcher.java new file mode 100644 index 0000000..0ac8529 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Dispatcher.java @@ -0,0 +1,10 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.List; + +/** Chooses which car answers a hall button. Only cars that are accepting work are passed in. */ +public interface Dispatcher { + String name(); + + Car choose(List candidates, int floor, Direction dir); +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/DoorsOpenState.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/DoorsOpenState.java new file mode 100644 index 0000000..e3683ce --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/DoorsOpenState.java @@ -0,0 +1,82 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayList; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +/** Doors open for a fixed number of ticks: people get off, people get on, then the car decides where to go. */ +final class DoorsOpenState implements CarState { + private int remaining; + + DoorsOpenState(int remaining) { this.remaining = remaining; } + + /** Everything that happens the moment the doors open at the car's current floor. */ + static void open(Car car, Lobby lobby, Set served) { + int floor = car.floor(); + car.removeStops(served); + + final Direction before = car.heading(); + Direction h = before; + Direction firstHall = served.stream().map(Stop::dir).filter(d -> d != Direction.NONE).findFirst().orElse(Direction.NONE); + boolean servesHeading = served.stream().anyMatch(s -> s.dir() != Direction.NONE && s.dir() == before); + if (h == Direction.NONE) { + h = firstHall; + } else if (!servesHeading && firstHall != Direction.NONE) { + h = h.opposite(); // turning point: nothing further ahead, so the car reverses here + } + car.setHeading(h); + + for (Stop s : served) { + if (s.dir() != Direction.NONE) lobby.hallServed(car, floor, s.dir()); + } + car.countDoorCycle(); + // Switch state before anything below can ask the dispatcher for a forecast of this car: + // a clone taken while the car still says MOVING would drive off the end of the shaft. + car.setState(new DoorsOpenState(Car.DWELL_TICKS)); + + List off = new ArrayList<>(); + for (Iterator it = car.ridersMutable().iterator(); it.hasNext(); ) { + Passenger p = it.next(); + if (p.destination() == floor) { + it.remove(); + off.add(p); + lobby.delivered(p); + } + } + + List on = new ArrayList<>(); + Deque queue = lobby.waitingAt(floor); + for (Iterator it = queue.iterator(); it.hasNext(); ) { + Passenger p = it.next(); + if (p.direction() == h && car.riderCount() < car.capacity()) { + it.remove(); + car.ridersMutable().add(p); + lobby.boarded(p); + car.addStop(new Stop(p.destination(), Direction.NONE)); + on.add(p); + } + } + + for (Direction d : new Direction[] {Direction.UP, Direction.DOWN}) { + boolean left = queue.stream().anyMatch(p -> p.direction() == d); + if (left && !lobby.hallStopPending(floor, d)) lobby.callHall(floor, d); + } + + lobby.log("t=" + lobby.now() + " car" + car.id() + " opens at " + floor + " heading " + h + + " off=" + off + " on=" + on); + } + + @Override public String name() { return "DOORS_OPEN"; } + + @Override + public void tick(Car car, Lobby lobby) { + if (--remaining > 0) return; + Direction next = car.nextHeading(); + car.setHeading(next); + car.setState(next == Direction.NONE ? new IdleState() : new MovingState(next)); + } + + @Override public CarState copy() { return new DoorsOpenState(remaining); } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/EtaDispatcher.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/EtaDispatcher.java new file mode 100644 index 0000000..104175f --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/EtaDispatcher.java @@ -0,0 +1,18 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.Comparator; +import java.util.List; + +/** Asks every car "how long until you would open your doors there?" and picks the smallest answer. */ +public final class EtaDispatcher implements Dispatcher { + @Override public String name() { return "eta"; } + + @Override + public Car choose(List candidates, int floor, Direction dir) { + return candidates.stream() + .min(Comparator.comparingInt((Car c) -> c.eta(floor, dir)) + .thenComparingInt(c -> c.stops().size()) + .thenComparingInt(Car::id)) + .orElseThrow(); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/IdleState.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/IdleState.java new file mode 100644 index 0000000..2298e27 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/IdleState.java @@ -0,0 +1,38 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.LinkedHashSet; +import java.util.Set; + +/** Doors closed, nothing to do until a stop appears. */ +final class IdleState implements CarState { + @Override public String name() { return "IDLE"; } + + @Override + public void tick(Car car, Lobby lobby) { + if (car.maintenanceRequested() && car.riderCount() == 0 && car.stops().isEmpty()) { + car.setHeading(Direction.NONE); + car.setState(new MaintenanceState()); + lobby.log("car" + car.id() + " out of service at floor " + car.floor()); + return; + } + Set here = car.stopsHere(); + if (!here.isEmpty()) { + Direction first = here.stream().map(Stop::dir).filter(d -> d != Direction.NONE).findFirst().orElse(Direction.NONE); + Set served = new LinkedHashSet<>(); + for (Stop s : here) { + if (s.dir() == first) served.add(s); + } + car.setHeading(Direction.NONE); + DoorsOpenState.open(car, lobby, served); + return; + } + Direction next = car.nextHeading(); + if (next != Direction.NONE) { + car.setHeading(next); + car.setState(new MovingState(next)); + car.state().tick(car, lobby); + } + } + + @Override public CarState copy() { return new IdleState(); } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Lobby.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Lobby.java new file mode 100644 index 0000000..845fbee --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Lobby.java @@ -0,0 +1,43 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayDeque; +import java.util.Deque; + +/** + * What a car is allowed to know about the building around it. The real implementation is + * {@link Building}; {@link #FORECAST} is a do-nothing lobby used when a car is cloned to predict + * its own future (see {@link Car#eta}). + */ +interface Lobby { + long now(); + + /** People waiting at a floor, oldest first. The deque is live: boarding removes from it. */ + Deque waitingAt(int floor); + + /** Does any car already hold a stop for this hall button? */ + boolean hallStopPending(int floor, Direction dir); + + /** A hall button needs a car: hand it to the dispatcher. */ + void callHall(int floor, Direction dir); + + /** A car has opened its doors for this hall button: every other car drops the same stop. */ + void hallServed(Car by, int floor, Direction dir); + + void boarded(Passenger p); + + void delivered(Passenger p); + + void log(String message); + + Lobby FORECAST = new Lobby() { + private final Deque nobody = new ArrayDeque<>(); + public long now() { return 0; } + public Deque waitingAt(int floor) { return nobody; } + public boolean hallStopPending(int floor, Direction dir) { return true; } + public void callHall(int floor, Direction dir) { } + public void hallServed(Car by, int floor, Direction dir) { } + public void boarded(Passenger p) { } + public void delivered(Passenger p) { } + public void log(String message) { } + }; +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/MaintenanceState.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/MaintenanceState.java new file mode 100644 index 0000000..82fe10c --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/MaintenanceState.java @@ -0,0 +1,8 @@ +package com.ankurm.interviewlab.elevator; + +/** Out of service. Adding this state touched no other state class: only IdleState decides to enter it. */ +final class MaintenanceState implements CarState { + @Override public String name() { return "MAINTENANCE"; } + @Override public void tick(Car car, Lobby lobby) { } + @Override public CarState copy() { return new MaintenanceState(); } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/MovingState.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/MovingState.java new file mode 100644 index 0000000..56d7f58 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/MovingState.java @@ -0,0 +1,23 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.Set; + +/** Travelling one floor per tick. Opens the doors when the floor it reaches is one it must serve. */ +final class MovingState implements CarState { + private final Direction direction; + + MovingState(Direction direction) { this.direction = direction; } + + @Override public String name() { return "MOVING_" + direction; } + + @Override + public void tick(Car car, Lobby lobby) { + car.step(direction); + Set served = car.servedHere(direction); + if (!served.isEmpty()) { + DoorsOpenState.open(car, lobby, served); + } + } + + @Override public CarState copy() { return new MovingState(direction); } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/NearestCarDispatcher.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/NearestCarDispatcher.java new file mode 100644 index 0000000..a851600 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/NearestCarDispatcher.java @@ -0,0 +1,16 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.Comparator; +import java.util.List; + +/** The obvious first idea: the car with the smallest floor distance. It ignores which way the car is going. */ +public final class NearestCarDispatcher implements Dispatcher { + @Override public String name() { return "nearest-car"; } + + @Override + public Car choose(List candidates, int floor, Direction dir) { + return candidates.stream() + .min(Comparator.comparingInt((Car c) -> Math.abs(c.floor() - floor)).thenComparingInt(Car::id)) + .orElseThrow(); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Passenger.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Passenger.java new file mode 100644 index 0000000..24ac36a --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Passenger.java @@ -0,0 +1,35 @@ +package com.ankurm.interviewlab.elevator; + +/** One person making one trip. The three tick fields are filled in by the simulation. */ +public final class Passenger { + private final String id; + private final int origin; + private final int destination; + private final long spawnTick; + private long boardedTick = -1; + private long arrivedTick = -1; + + public Passenger(String id, int origin, int destination, long spawnTick) { + this.id = id; + this.origin = origin; + this.destination = destination; + this.spawnTick = spawnTick; + } + + public String id() { return id; } + public int origin() { return origin; } + public int destination() { return destination; } + public Direction direction() { return Direction.between(origin, destination); } + public long spawnTick() { return spawnTick; } + + void boardedAt(long tick) { this.boardedTick = tick; } + void arrivedAt(long tick) { this.arrivedTick = tick; } + + public boolean delivered() { return arrivedTick >= 0; } + public long waitTicks() { return boardedTick - spawnTick; } + public long rideTicks() { return arrivedTick - boardedTick; } + public long totalTicks() { return arrivedTick - spawnTick; } + + @Override + public String toString() { return id + "(" + origin + "->" + destination + ")"; } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/PolicyComparison.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/PolicyComparison.java new file mode 100644 index 0000000..00c772a --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/PolicyComparison.java @@ -0,0 +1,58 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayList; +import java.util.List; + +/** + * The scheduling question without the building: one car, a list of requested floors, how far does + * each policy make it travel? FCFS and SSTF are the two ideas people reach for first; LOOK is what + * the car in this module does. + */ +public final class PolicyComparison { + private PolicyComparison() { } + + public record Result(String policy, List order, int distance) { } + + public static Result fcfs(int start, List requests) { + return new Result("FCFS", List.copyOf(requests), distance(start, requests)); + } + + public static Result sstf(int start, List requests) { + List left = new ArrayList<>(requests); + List order = new ArrayList<>(); + int at = start; + while (!left.isEmpty()) { + int best = 0; + for (int i = 1; i < left.size(); i++) { + if (Math.abs(left.get(i) - at) < Math.abs(left.get(best) - at)) best = i; + } + at = left.remove(best); + order.add(at); + } + return new Result("SSTF", order, distance(start, order)); + } + + /** LOOK: sweep up serving everything above, then sweep down serving everything below (reverse if heading down). */ + public static Result look(int start, boolean headingUp, List requests) { + List above = requests.stream().filter(f -> f >= start).sorted().toList(); + List below = requests.stream().filter(f -> f < start).sorted(java.util.Comparator.reverseOrder()).toList(); + List order = new ArrayList<>(); + if (headingUp) { order.addAll(above); order.addAll(below); } + else { + List belowFirst = requests.stream().filter(f -> f <= start).sorted(java.util.Comparator.reverseOrder()).toList(); + List aboveAfter = requests.stream().filter(f -> f > start).sorted().toList(); + order.addAll(belowFirst); order.addAll(aboveAfter); + } + return new Result("LOOK", order, distance(start, order)); + } + + static int distance(int start, List order) { + int at = start; + int total = 0; + for (int f : order) { + total += Math.abs(f - at); + at = f; + } + return total; + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Report.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Report.java new file mode 100644 index 0000000..d9b75f7 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Report.java @@ -0,0 +1,14 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.Locale; + +/** Summary of one simulation run. Times are in ticks: one tick is one floor of travel. */ +public record Report(String dispatcher, int passengers, int delivered, double avgWait, double avgRide, double avgTotal, + long maxWait, long maxTotal, int floorsTravelled, int doorCycles, long ticks) { + @Override + public String toString() { + return String.format(Locale.ROOT, + "%-12s delivered %d/%d wait avg %.1f max %d total avg %.1f max %d floors %d door cycles %d ticks %d", + dispatcher, delivered, passengers, avgWait, maxWait, avgTotal, maxTotal, floorsTravelled, doorCycles, ticks); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/RoundRobinDispatcher.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/RoundRobinDispatcher.java new file mode 100644 index 0000000..38c8dcd --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/RoundRobinDispatcher.java @@ -0,0 +1,15 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.List; + +/** A baseline that looks at nothing: cars take turns. */ +public final class RoundRobinDispatcher implements Dispatcher { + private int next; + + @Override public String name() { return "round-robin"; } + + @Override + public Car choose(List candidates, int floor, Direction dir) { + return candidates.get(next++ % candidates.size()); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Simulation.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Simulation.java new file mode 100644 index 0000000..aca9f8c --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Simulation.java @@ -0,0 +1,41 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.List; + +/** Feeds arrivals into a building tick by tick until everyone has been delivered. */ +public final class Simulation { + private Simulation() { } + + public static Report run(Building building, List arrivals, int maxTicks) { + return run(building, arrivals, maxTicks, b -> { }); + } + + /** As above, calling the observer after every tick: tests use it to check invariants. */ + public static Report run(Building building, List arrivals, int maxTicks, java.util.function.Consumer observer) { + int next = 0; + long t = 0; + while (t < maxTicks && (next < arrivals.size() || building.deliveredPassengers().size() < arrivals.size())) { + while (next < arrivals.size() && arrivals.get(next).tick() <= t) { + Arrival a = arrivals.get(next); + building.submit(new Passenger("p" + next, a.origin(), a.destination(), t)); + next++; + } + building.tick(); + observer.accept(building); + t++; + } + return report(building, arrivals.size(), t); + } + + static Report report(Building b, int total, long ticks) { + List done = b.deliveredPassengers(); + double wait = done.stream().mapToLong(Passenger::waitTicks).average().orElse(0); + double ride = done.stream().mapToLong(Passenger::rideTicks).average().orElse(0); + double all = done.stream().mapToLong(Passenger::totalTicks).average().orElse(0); + long maxWait = done.stream().mapToLong(Passenger::waitTicks).max().orElse(0); + long maxAll = done.stream().mapToLong(Passenger::totalTicks).max().orElse(0); + int floors = b.cars().stream().mapToInt(Car::floorsTravelled).sum(); + int doors = b.cars().stream().mapToInt(Car::doorCycles).sum(); + return new Report(b.dispatcher().name(), total, done.size(), wait, ride, all, maxWait, maxAll, floors, doors, ticks); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/StarvationDemo.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/StarvationDemo.java new file mode 100644 index 0000000..4e31955 --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/StarvationDemo.java @@ -0,0 +1,57 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * One car on floors 0..9, one far request waiting at floor 0, and a steady trickle of new requests + * at floors 6 and 7. The car moves one floor per tick. How long does the far request wait under + * SSTF (always the nearest request) and under LOOK (finish the sweep, then turn)? + */ +public final class StarvationDemo { + private StarvationDemo() { } + + public record Outcome(String policy, int farServedAtTick, int streamEndsAtTick) { } + + public static Outcome run(boolean look, int streamTicks) { + int head = 5; + int dir = 1; // LOOK's current sweep direction: +1 up, -1 down + List pending = new ArrayList<>(); + pending.add(0); + for (int t = 1; t <= 1000; t++) { + if (t <= streamTicks) pending.add(t % 2 == 0 ? 6 : 7); + if (look) { + if (!anyAhead(pending, head, dir)) dir = -dir; + head += towards(pending, head, dir); + } else { + head += Integer.compare(nearest(pending, head), head); + } + for (Iterator it = pending.iterator(); it.hasNext(); ) { + if (it.next() == head) it.remove(); + } + if (!pending.contains(0)) return new Outcome(look ? "LOOK" : "SSTF", t, streamTicks); + } + return new Outcome(look ? "LOOK" : "SSTF", -1, streamTicks); + } + + private static boolean anyAhead(List pending, int head, int dir) { + for (int f : pending) { + if ((dir > 0 && f > head) || (dir < 0 && f < head)) return true; + } + return false; + } + + /** One step towards the nearest pending request in the sweep direction (or standing still). */ + private static int towards(List pending, int head, int dir) { + return anyAhead(pending, head, dir) ? dir : 0; + } + + private static int nearest(List pending, int head) { + int best = pending.get(0); + for (int f : pending) { + if (Math.abs(f - head) < Math.abs(best - head)) best = f; + } + return best; + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Stop.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Stop.java new file mode 100644 index 0000000..42329bb --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Stop.java @@ -0,0 +1,12 @@ +package com.ankurm.interviewlab.elevator; + +/** + * A floor a car has promised to visit. A hall button gives a stop with a direction (UP or DOWN); + * a button inside the car gives a stop with direction NONE, served whichever way the car is going. + */ +public record Stop(int floor, Direction dir) { + @Override + public String toString() { + return dir == Direction.NONE ? String.valueOf(floor) : floor + dir.name().substring(0, 1).toLowerCase(); + } +} diff --git a/elevator/src/main/java/com/ankurm/interviewlab/elevator/Traffic.java b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Traffic.java new file mode 100644 index 0000000..c56d5ee --- /dev/null +++ b/elevator/src/main/java/com/ankurm/interviewlab/elevator/Traffic.java @@ -0,0 +1,47 @@ +package com.ankurm.interviewlab.elevator; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Random; + +/** Seeded passenger streams, so every run of a test sees exactly the same morning. */ +public final class Traffic { + private Traffic() { } + + /** Morning: 70% of people start at the lobby (floor 0) and go up; the rest travel between random floors. */ + public static List upPeak(long seed, int people, int floors, int spreadTicks) { + Random rnd = new Random(seed); + List list = new ArrayList<>(); + for (int i = 0; i < people; i++) { + long tick = rnd.nextInt(spreadTicks); + int origin; + int dest; + if (rnd.nextInt(100) < 70) { + origin = 0; + dest = 1 + rnd.nextInt(floors - 1); + } else { + origin = rnd.nextInt(floors); + do { dest = rnd.nextInt(floors); } while (dest == origin); + } + list.add(new Arrival(tick, origin, dest)); + } + list.sort(Comparator.comparingLong(Arrival::tick)); + return list; + } + + /** Between floors: every person picks an origin and a different destination uniformly. */ + public static List mixed(long seed, int people, int floors, int spreadTicks) { + Random rnd = new Random(seed); + List list = new ArrayList<>(); + for (int i = 0; i < people; i++) { + long tick = rnd.nextInt(spreadTicks); + int origin = rnd.nextInt(floors); + int dest; + do { dest = rnd.nextInt(floors); } while (dest == origin); + list.add(new Arrival(tick, origin, dest)); + } + list.sort(Comparator.comparingLong(Arrival::tick)); + return list; + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/CapacityTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/CapacityTest.java new file mode 100644 index 0000000..6bef34e --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/CapacityTest.java @@ -0,0 +1,31 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Fixtures; +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class CapacityTest { + + @Test + void fullCarLeavesPeopleBehindAndComesBack() { + Building b = new Building(8, new int[] {0}, 2, new NearestCarDispatcher()); + Transcript out = Transcript.start("05-capacity.txt", "Capacity 2, five people at the lobby, all going UP"); + for (int i = 0; i < 5; i++) b.submit(new Passenger("p" + i, 0, 2 + i, 0)); + out.line("hall calls dispatched after five button presses: " + b.hallCallsDispatched()).blank(); + Fixtures.tickUntilDelivered(b, 5, 200); + for (String line : b.log()) out.line(line); + out.blank(); + for (Passenger p : b.deliveredPassengers()) { + out.line(String.format("%-8s wait %2d ride %2d", p, p.waitTicks(), p.rideTicks())); + } + out.flush(); + assertEquals(5, b.deliveredPassengers().size()); + assertEquals(List.of(0L, 0L, 15L, 15L, 34L), b.deliveredPassengers().stream().sorted(java.util.Comparator.comparing(Passenger::id)).map(Passenger::waitTicks).toList()); + // Capacity 2 means three trips from floor 0. + assertEquals(3, Fixtures.doorOpenings(b, 0).stream().filter(f -> f == 0).count()); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/DispatcherTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/DispatcherTest.java new file mode 100644 index 0000000..007b907 --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/DispatcherTest.java @@ -0,0 +1,83 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.function.Supplier; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class DispatcherTest { + + private static final int FLOORS = 12; + private static final int CARS = 3; + + private record Run(Report report, int[] callsPerCar) { } + + private static Run run(Supplier d, List traffic) { + Building b = Building.of(FLOORS, CARS, 8, d.get()); + Report r = Simulation.run(b, traffic, 5000); + int[] calls = new int[CARS]; + for (String line : b.log()) { + int i = line.indexOf(" -> car"); + if (line.contains(" hall ") && i > 0) calls[line.charAt(i + 7) - '0']++; + } + return new Run(r, calls); + } + + private static double one(double v) { return Math.round(v * 10) / 10.0; } + + @Test + void threeDispatchersOnTwoKindsOfTraffic() { + Transcript out = Transcript.start("03-dispatchers.txt", + "12 floors, 3 cars (capacity 8), 120 people: same seeded traffic through three dispatchers"); + out.line("Times are in ticks. 'wait' is button press to boarding; 'total' is button press to arrival.").blank(); + + List morning = Traffic.upPeak(42, 120, FLOORS, 240); + List between = Traffic.mixed(7, 120, FLOORS, 360); + List> all = List.of(RoundRobinDispatcher::new, NearestCarDispatcher::new, EtaDispatcher::new); + + out.line("Up-peak (70% start at the lobby), seed 42, arrivals spread over 240 ticks"); + Report[] a = new Report[3]; + for (int i = 0; i < 3; i++) { + Run run = run(all.get(i), morning); + a[i] = run.report(); + out.line(" " + a[i]); + out.line(" hall calls per car (car0, car1, car2): " + java.util.Arrays.toString(run.callsPerCar())); + } + out.blank().line("Between floors (uniform origin and destination), seed 7, arrivals spread over 360 ticks"); + Report[] c = new Report[3]; + for (int i = 0; i < 3; i++) { + Run run = run(all.get(i), between); + c[i] = run.report(); + out.line(" " + c[i]); + out.line(" hall calls per car (car0, car1, car2): " + java.util.Arrays.toString(run.callsPerCar())); + } + out.flush(); + + for (Report r : a) assertEquals(120, r.delivered()); + for (Report r : c) assertEquals(120, r.delivered()); + // Index 0 round-robin, 1 nearest-car, 2 eta. The figures quoted in the article: + assertEquals(18.5, one(a[0].avgWait())); assertEquals(91.9, one(a[1].avgWait())); assertEquals(13.7, one(a[2].avgWait())); + assertEquals(13.3, one(c[0].avgWait())); assertEquals(16.5, one(c[1].avgWait())); assertEquals(9.9, one(c[2].avgWait())); + assertEquals(248, a[1].maxWait()); assertEquals(43, a[2].maxWait()); + } + + @Test + void forecastOfAnIdleCarIsExact() { + Building b = Building.of(10, 1, 8, new EtaDispatcher()); + Car car = b.cars().get(0); // idle at floor 0 + int predicted = car.eta(7, Direction.UP); + b.submit(new Passenger("x", 7, 9, 0)); + int ticks = 0; + while (b.deliveredPassengers().isEmpty() && b.waitingCount() == 1 && car.riderCount() == 0 && ticks < 100) { + b.tick(); + ticks++; + } + // The doors open on the tick after `predicted - 1` ticks of movement: tick numbering starts at 1 in eta(). + Transcript.start("03b-eta-forecast.txt", "ETA forecast for an idle car at floor 0 and a call at floor 7 (UP)") + .line("predicted: " + predicted + " ticks").line("actual: " + ticks + " ticks").flush(); + assertEquals(predicted, ticks); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/InvariantsTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/InvariantsTest.java new file mode 100644 index 0000000..87f5e1b --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/InvariantsTest.java @@ -0,0 +1,56 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.function.Supplier; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class InvariantsTest { + + /** Rules that must hold after every single tick of every run. */ + private static void check(Building b) { + for (Car c : b.cars()) { + if (c.floor() < 0 || c.floor() >= b.floors()) throw new AssertionError(c + " is outside the shaft"); + if (c.riderCount() > c.capacity()) throw new AssertionError(c + " is over capacity"); + for (Passenger p : c.riders()) { + if (p.destination() != c.floor() && !c.stops().contains(new Stop(p.destination(), Direction.NONE))) { + throw new AssertionError(c + " carries " + p + " but has no stop for them"); + } + } + if (c.stateName().equals("DOORS_OPEN") && c.heading() == Direction.NONE && c.riderCount() > 0 && c.stops().isEmpty()) { + throw new AssertionError(c + " is stuck with riders and no stops"); + } + } + } + + @Test + void everyoneArrivesAndNoRuleIsBroken() { + Transcript out = Transcript.start("07-invariants.txt", + "Randomised runs: 150 seeds x 3 dispatchers x 2 traffic shapes, rules checked after every tick"); + List> all = List.of(RoundRobinDispatcher::new, NearestCarDispatcher::new, EtaDispatcher::new); + int runs = 0; + long ticks = 0; + int people = 0; + for (Supplier d : all) { + for (int seed = 1; seed <= 150; seed++) { + for (int shape = 0; shape < 2; shape++) { + List traffic = shape == 0 ? Traffic.upPeak(seed, 40, 10, 80) : Traffic.mixed(seed, 40, 10, 120); + Building b = Building.of(10, 3, 4, d.get()); + Report r = Simulation.run(b, traffic, 3000, InvariantsTest::check); + assertEquals(40, r.delivered(), "seed " + seed + " " + r.dispatcher()); + runs++; + ticks += r.ticks(); + people += r.delivered(); + } + } + } + out.line("runs: " + runs).line("people delivered: " + people).line("simulated ticks checked: " + ticks) + .line("rule violations: 0").flush(); + assertEquals(900, runs); + assertEquals(36000, people); + assertEquals(137430L, ticks); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/MaintenanceTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/MaintenanceTest.java new file mode 100644 index 0000000..9ea2d37 --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/MaintenanceTest.java @@ -0,0 +1,67 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Fixtures; +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class MaintenanceTest { + + @Test + void carFinishesItsRidersThenLeavesService() { + Building b = new Building(10, new int[] {0, 9}, 8, new NearestCarDispatcher()); + Transcript out = Transcript.start("04-maintenance.txt", "Taking car0 out of service while it carries a passenger"); + Car car0 = b.cars().get(0); + Car car1 = b.cars().get(1); + + b.submit(new Passenger("a", 0, 5, 0)); // car0 takes this one + for (int i = 0; i < 5; i++) b.tick(); + car0.requestMaintenance(); + out.line("t=5: maintenance requested for car0, which is carrying 'a' to floor 5").blank(); + + b.submit(new Passenger("b", 2, 6, 5)); // nearer to car0, but car0 may not accept work now + int t = 5; + while (!car0.inMaintenance() && t < 100) { + b.tick(); + out.line(String.format("t=%02d %s", t, Fixtures.snapshot(b))); + t++; + } + out.blank().line("car0 entered MAINTENANCE at tick " + (t - 1) + " at floor " + car0.floor()); + assertEquals(12, t - 1); + out.line("hall call for 'b' went to: " + b.log().stream().filter(l -> l.contains("hall 2u")).findFirst().orElse("?")); + assertTrue(car0.inMaintenance()); + assertTrue(b.deliveredPassengers().stream().anyMatch(p -> p.id().equals("a"))); + assertTrue(b.log().stream().anyMatch(l -> l.contains("hall 2u -> car1"))); + + // Put it back and check it takes work again. + car0.returnToService(); + assertFalse(car0.inMaintenance()); + b.submit(new Passenger("c", car0.floor(), 9, t)); + for (int i = 0; i < 3; i++) b.tick(); + out.blank().line("after returnToService(): " + Fixtures.snapshot(b).split("\\|")[0].trim()); + out.flush(); + assertEquals(1, car0.riderCount() + (int) b.deliveredPassengers().stream().filter(p -> p.id().equals("c")).count()); + } + + @Test + void callsWaitWhenEveryCarIsOutOfService() { + Building b = Building.of(10, 2, 8, new EtaDispatcher()); + for (Car c : b.cars()) c.requestMaintenance(); + b.tick(); + assertTrue(b.cars().stream().allMatch(Car::inMaintenance)); + b.submit(new Passenger("lonely", 4, 1, 1)); + for (int i = 0; i < 10; i++) b.tick(); + Transcript out = Transcript.start("04b-all-cars-out.txt", "Both cars out of service, one person presses a button"); + out.line("after 10 ticks: delivered=" + b.deliveredPassengers().size() + " waiting=" + b.waitingCount()); + b.cars().get(1).returnToService(); + int t = 0; + while (b.deliveredPassengers().isEmpty() && t < 60) { b.tick(); t++; } + out.line("car1 returned to service: delivered after " + t + " more ticks"); + out.flush(); + assertEquals(1, b.deliveredPassengers().size()); + assertEquals(11, t); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/PitfallsTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/PitfallsTest.java new file mode 100644 index 0000000..c8fdec7 --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/PitfallsTest.java @@ -0,0 +1,48 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Fixtures; +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class PitfallsTest { + + /** Car0 is about to head down from floor 4; car1 is parked at 9. A person at floor 3 wants to go UP. */ + private static long waitOfPersonAtThree(Dispatcher d, Transcript out) { + Building b = new Building(10, new int[] {4, 9}, 8, d); + b.submit(new Passenger("rider", 4, 0, 0)); // car0 is at 4: picks 'rider' up and heads DOWN + for (int i = 0; i < 4; i++) b.tick(); // doors open, then the car starts down + out.line(d.name() + ": after 4 ticks " + Fixtures.snapshot(b).split("\\|")[0].trim()); + b.submit(new Passenger("p3", 3, 8, 4)); // presses UP at floor 3 + Fixtures.tickUntilDelivered(b, 2, 200); + String assigned = b.log().stream().filter(l -> l.contains("hall 3u")).findFirst().orElse("?"); + out.line(d.name() + ": " + assigned); + return Fixtures.find(b, "p3").waitTicks(); + } + + @Test + void nearestCarIgnoresWhichWayTheCarIsGoing() { + Transcript out = Transcript.start("08-nearest-car-trap.txt", "Hall call UP at floor 3 while car0 (at 4) is going DOWN and car1 waits at 9"); + long nearest = waitOfPersonAtThree(new NearestCarDispatcher(), out); + long eta = waitOfPersonAtThree(new EtaDispatcher(), out); + out.blank().line("wait for the person at floor 3, in ticks:").line(" nearest-car " + nearest).line(" eta " + eta); + out.flush(); + assertTrue(eta < nearest); + } + + @Test + void fivePeoplePressingTheSameButtonMakeOneHallCall() { + Building b = Building.of(10, 2, 8, new EtaDispatcher()); + for (int i = 0; i < 5; i++) b.submit(new Passenger("p" + i, 6, 9, 0)); + Transcript out = Transcript.start("08b-same-button.txt", "Five people at floor 6 all press UP"); + out.line("hall calls dispatched: " + b.hallCallsDispatched()); + Fixtures.tickUntilDelivered(b, 5, 200); + long opens = b.cars().stream().mapToInt(Car::doorCycles).sum(); + out.line("door cycles used to serve all five: " + opens); + out.flush(); + assertEquals(1, b.hallCallsDispatched()); + assertEquals(2, opens); // one stop at floor 6 to board, one at floor 9 to alight + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/PolicyTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/PolicyTest.java new file mode 100644 index 0000000..07e11ed --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/PolicyTest.java @@ -0,0 +1,42 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class PolicyTest { + + @Test + void distanceUnderThreePolicies() { + List requests = List.of(8, 2, 9, 1, 6, 3); + Transcript out = Transcript.start("02-policies.txt", "One car at floor 5 heading up, six requests: floors travelled"); + out.line("requests in arrival order: " + requests).blank(); + var fcfs = PolicyComparison.fcfs(5, requests); + var sstf = PolicyComparison.sstf(5, requests); + var look = PolicyComparison.look(5, true, requests); + for (var r : List.of(fcfs, sstf, look)) { + out.line(String.format("%-5s order %-24s distance %d", r.policy(), r.order(), r.distance())); + } + out.flush(); + assertEquals(32, fcfs.distance()); + assertEquals(12, sstf.distance()); + assertEquals(12, look.distance()); + } + + @Test + void sstfStarvesTheFarRequestAndLookDoesNot() { + Transcript out = Transcript.start("02b-starvation.txt", + "A request waits at floor 0; the car is at floor 5; new requests keep appearing at floors 6 and 7"); + var sstf = StarvationDemo.run(false, 40); + var look = StarvationDemo.run(true, 40); + out.line("The stream of new requests lasts 40 ticks. The car moves one floor per tick.").blank(); + out.line(String.format("%-5s far request served at tick %d", sstf.policy(), sstf.farServedAtTick())); + out.line(String.format("%-5s far request served at tick %d", look.policy(), look.farServedAtTick())); + out.flush(); + assertEquals(46, sstf.farServedAtTick()); + assertEquals(9, look.farServedAtTick()); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/TraceTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/TraceTest.java new file mode 100644 index 0000000..96546cf --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/TraceTest.java @@ -0,0 +1,49 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Fixtures; +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class TraceTest { + + @Test + void oneCarThreePeopleTickByTick() { + Building b = new Building(10, new int[] {0}, 8, new NearestCarDispatcher()); + Transcript out = Transcript.start("01-single-car-trace.txt", + "One car, three people, one tick per line (floors 0..9, doors stay open 3 ticks)"); + out.line("p0 starts at 0 and wants 6 (UP). p1 starts at 4 and wants 8 (UP). p2 starts at 3 and wants 1 (DOWN).") + .line("All three press their button at tick 0.").blank(); + + b.submit(new Passenger("p0", 0, 6, 0)); + b.submit(new Passenger("p1", 4, 8, 0)); + b.submit(new Passenger("p2", 3, 1, 0)); + + int t = 0; + while (b.deliveredPassengers().size() < 3 && t < 100) { + b.tick(); + out.line(String.format("t=%02d %s", t, Fixtures.snapshot(b))); + t++; + } + out.blank().line("Door openings (from the building log):"); + for (String line : b.log()) if (line.contains("opens at")) out.line(" " + line); + + out.blank().line("Per person (ticks): wait = button to boarding, ride = boarding to arrival"); + for (String id : List.of("p0", "p1", "p2")) { + Passenger p = Fixtures.find(b, id); + out.line(String.format(" %-3s %-8s wait %2d ride %2d total %2d", id, p, p.waitTicks(), p.rideTicks(), p.totalTicks())); + } + out.flush(); + + assertEquals(List.of(0, 4, 6, 8, 3, 1), Fixtures.doorOpenings(b, 0)); + // p2 pressed DOWN at floor 3 while the car was going UP: the car passed floor 3 twice before stopping. + assertEquals(3, b.deliveredPassengers().size()); + assertEquals(0, Fixtures.find(b, "p0").waitTicks()); + assertEquals(7, Fixtures.find(b, "p1").waitTicks()); + assertEquals(25, Fixtures.find(b, "p2").waitTicks()); + assertEquals(30, Fixtures.find(b, "p2").totalTicks()); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/ValidationTest.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/ValidationTest.java new file mode 100644 index 0000000..c87271b --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/ValidationTest.java @@ -0,0 +1,44 @@ +package com.ankurm.interviewlab.elevator; + +import com.ankurm.interviewlab.elevator.support.Transcript; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class ValidationTest { + + private record Bad(String what, Passenger passenger, String message) { } + + @Test + void badRequestsAreRejectedWithAMessage() { + Building b = Building.of(10, 1, 8, new EtaDispatcher()); + Transcript out = Transcript.start("06-validation.txt", "Requests the building refuses, and the exact message"); + List cases = List.of( + new Bad("origin above the top floor", new Passenger("a", 12, 3, 0), "origin floor 12 is outside 0..9"), + new Bad("origin below the ground floor", new Passenger("b", -1, 3, 0), "origin floor -1 is outside 0..9"), + new Bad("destination above the top floor", new Passenger("c", 2, 10, 0), "destination floor 10 is outside 0..9"), + new Bad("destination below the ground floor", new Passenger("d", 2, -4, 0), "destination floor -4 is outside 0..9"), + new Bad("same origin and destination", new Passenger("e", 5, 5, 0), "origin and destination are both floor 5")); + for (Bad bad : cases) { + var ex = assertThrows(IllegalArgumentException.class, () -> b.submit(bad.passenger())); + out.line(String.format("%-36s -> %s", bad.what(), ex.getMessage())); + assertEquals(bad.message(), ex.getMessage()); + } + out.blank().line("people waiting afterwards: " + b.waitingCount() + ", hall calls dispatched: " + b.hallCallsDispatched()); + out.flush(); + assertEquals(0, b.waitingCount()); + assertEquals(0, b.hallCallsDispatched()); + } + + @Test + void carRefusesAStopOutsideItsShaft() { + Car car = new Car(0, 0, 9, 0, 8); + var ex = assertThrows(IllegalArgumentException.class, () -> car.addStop(new Stop(10, Direction.NONE))); + Transcript.start("06b-stop-outside-shaft.txt", "A stop above the top floor") + .line("addStop(10) -> " + ex.getMessage()).flush(); + assertEquals("floor 10 is outside 0..9", ex.getMessage()); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Fixtures.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Fixtures.java new file mode 100644 index 0000000..e7cd1c8 --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Fixtures.java @@ -0,0 +1,44 @@ +package com.ankurm.interviewlab.elevator.support; + +import com.ankurm.interviewlab.elevator.Building; +import com.ankurm.interviewlab.elevator.Car; +import com.ankurm.interviewlab.elevator.Passenger; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public final class Fixtures { + private Fixtures() { } + + /** One line describing every car right now. */ + public static String snapshot(Building b) { + StringBuilder sb = new StringBuilder(); + for (Car c : b.cars()) { + if (sb.length() > 0) sb.append(" | "); + sb.append(String.format("car%d floor %2d %-11s %-4s stops %-18s riders %s", + c.id(), c.floor(), c.stateName(), c.heading(), c.stops(), c.riders())); + } + return sb.toString(); + } + + /** Floors where doors opened, in order, read from the building log. */ + public static List doorOpenings(Building b, int carId) { + Pattern p = Pattern.compile("car" + carId + " opens at (\\d+) "); + List floors = new ArrayList<>(); + for (String line : b.log()) { + Matcher m = p.matcher(line); + if (m.find()) floors.add(Integer.parseInt(m.group(1))); + } + return floors; + } + + public static void tickUntilDelivered(Building b, int people, int maxTicks) { + for (int i = 0; i < maxTicks && b.deliveredPassengers().size() < people; i++) b.tick(); + } + + public static Passenger find(Building b, String id) { + return b.deliveredPassengers().stream().filter(p -> p.id().equals(id)).findFirst().orElseThrow(); + } +} diff --git a/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Transcript.java b/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Transcript.java new file mode 100644 index 0000000..d2918fc --- /dev/null +++ b/elevator/src/test/java/com/ankurm/interviewlab/elevator/support/Transcript.java @@ -0,0 +1,43 @@ +package com.ankurm.interviewlab.elevator.support; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; + +/** Writes output/NN-*.txt while the calling test asserts the same numbers it prints. */ +public final class Transcript { + private final Path path; + private final List lines = new ArrayList<>(); + + private Transcript(Path path, String header) { + this.path = path; + lines.add(header); + lines.add("=".repeat(Math.min(header.length(), 100))); + lines.add(""); + } + + public static Transcript start(String fileName, String header) { + Path dir = Path.of("output"); + try { + Files.createDirectories(dir); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + return new Transcript(dir.resolve(fileName), header); + } + + public Transcript line(String text) { lines.add(text); return this; } + public Transcript blank() { lines.add(""); return this; } + + public void flush() { + try { + Files.write(path, (String.join("\n", lines) + "\n").getBytes(StandardCharsets.UTF_8)); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + } +}