Vending machine

const COINS = new Set([5, 10, 25, 100]); // cents the machine accepts

interface Slot { name: string; price: number; count: number; }

/** Each state answers every action in its own way: no if/else on "what state am I in?". */
interface State {
  readonly name: string;
  insert(m: VendingMachine, cents: number): string;
  select(m: VendingMachine, code: string): string;
  cancel(m: VendingMachine): string;
}

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

class Idle implements State {
  readonly name = "Idle";
  insert(m: VendingMachine, cents: number): string {
    m.balance += cents;
    m.state = new HasMoney();
    return `balance ${money(m.balance)}`;
  }
  select(): string { return "insert money first"; }
  cancel(): string { return "nothing to refund"; }
}

class HasMoney implements State {
  readonly name = "HasMoney";
  insert(m: VendingMachine, cents: number): string {
    m.balance += cents;
    return `balance ${money(m.balance)}`;
  }
  select(m: VendingMachine, code: string): string {
    const slot = m.slots.get(code);
    if (!slot) return `no slot ${code}`;
    if (slot.count === 0) return `${slot.name} is sold out, pick another`;
    if (m.balance < slot.price) return `${slot.name} costs ${money(slot.price)}, insert ${money(slot.price - m.balance)} more`;
    slot.count--;
    const change = m.balance - slot.price;
    m.balance = 0;
    m.state = new Idle();
    return `dispense ${slot.name}, change ${money(change)}`;
  }
  cancel(m: VendingMachine): string {
    const refund = m.balance;
    m.balance = 0;
    m.state = new Idle();
    return `refund ${money(refund)}`;
  }
}

class VendingMachine {
  balance = 0;
  state: State = new Idle();
  constructor(readonly slots: Map<string, Slot>) {}
  insert(cents: number): string {
    if (!COINS.has(cents)) return `rejected coin ${cents}c`; // checked here once, before any state sees it
    return this.state.insert(this, cents);
  }
  select(code: string): string { return this.state.select(this, code); }
  cancel(): string { return this.state.cancel(this); }
}

const vm = new VendingMachine(new Map([["A1", { name: "Water", price: 100, count: 5 }], ["B2", { name: "Chips", price: 150, count: 2 }],
  ["C3", { name: "Gum", price: 75, count: 0 }]]));
const steps: [string, string | number | null][] = [["select", "A1"], ["insert", 100], ["select", "B2"], ["insert", 25], ["insert", 25],
  ["select", "B2"], ["insert", 3], ["insert", 100], ["select", "C3"], ["cancel", null]];
for (const [action, arg] of steps) {
  const out = action === "select" ? vm.select(arg as string) : action === "insert" ? vm.insert(arg as number) : vm.cancel();
  console.log(`${action}${arg !== null ? " " + arg : ""}: ${out}  [${vm.state.name}]`);
}

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

class Slot {
    final String name;
    final int price;
    int count;

    Slot(String name, int price, int count) {
        this.name = name;
        this.price = price;
        this.count = count;
    }
}

/** Each state answers every action in its own way: no if/else on "what state am I in?". */
interface State {
    String insert(VendingMachine m, int cents);
    String select(VendingMachine m, String code);
    String cancel(VendingMachine m);
}

class Idle implements State {
    public String insert(VendingMachine m, int cents) {
        m.balance += cents;
        m.state = new HasMoney();
        return "balance " + VendingMachine.money(m.balance);
    }

    public String select(VendingMachine m, String code) {
        return "insert money first";
    }

    public String cancel(VendingMachine m) {
        return "nothing to refund";
    }
}

class HasMoney implements State {
    public String insert(VendingMachine m, int cents) {
        m.balance += cents;
        return "balance " + VendingMachine.money(m.balance);
    }

    public String select(VendingMachine m, String code) {
        Slot slot = m.slots.get(code);
        if (slot == null) return "no slot " + code;
        if (slot.count == 0) return slot.name + " is sold out, pick another";
        if (m.balance < slot.price)
            return slot.name + " costs " + VendingMachine.money(slot.price) + ", insert " + VendingMachine.money(slot.price - m.balance) + " more";
        slot.count--;
        int change = m.balance - slot.price;
        m.balance = 0;
        m.state = new Idle();
        return "dispense " + slot.name + ", change " + VendingMachine.money(change);
    }

    public String cancel(VendingMachine m) {
        int refund = m.balance;
        m.balance = 0;
        m.state = new Idle();
        return "refund " + VendingMachine.money(refund);
    }
}

class VendingMachine {
    static final Set<Integer> COINS = Set.of(5, 10, 25, 100); // cents the machine accepts
    final Map<String, Slot> slots;
    int balance;
    State state = new Idle();

    VendingMachine(Map<String, Slot> slots) {
        this.slots = slots;
    }

    synchronized String insert(int cents) {
        if (!COINS.contains(cents)) return "rejected coin " + cents + "c"; // checked here once, before any state sees it
        return state.insert(this, cents);
    }

    synchronized String select(String code) {
        return state.select(this, code);
    }

    synchronized String cancel() {
        return state.cancel(this);
    }

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

public class Main {
    public static void main(String[] args) {
        Map<String, Slot> slots = new LinkedHashMap<>();
        slots.put("A1", new Slot("Water", 100, 5));
        slots.put("B2", new Slot("Chips", 150, 2));
        slots.put("C3", new Slot("Gum", 75, 0));
        VendingMachine vm = new VendingMachine(slots);
        Object[][] steps = {{"select", "A1"}, {"insert", 100}, {"select", "B2"}, {"insert", 25}, {"insert", 25},
            {"select", "B2"}, {"insert", 3}, {"insert", 100}, {"select", "C3"}, {"cancel", null}};
        for (Object[] s : steps) {
            String action = (String) s[0];
            String out = action.equals("select") ? vm.select((String) s[1])
                    : action.equals("insert") ? vm.insert((Integer) s[1]) : vm.cancel();
            System.out.println(action + (s[1] != null ? " " + s[1] : "") + ": " + out + "  [" + vm.state.getClass().getSimpleName() + "]");
        }
    }
}