Choosing Patterns in an LLD Interview.

# coupons_v1.py: the first pass at minute ten, one function with an elif for every code
USED = {}  # code -> times it gave a discount
AUDIT = []  # one line per applied code


def discount(code, subtotal):
    if code == "FLAT100":
        d = min(100, subtotal)
    elif code == "SAVE10":
        d = min(subtotal * 10 // 100, 80)
    elif code == "BIG200":
        d = 200 if subtotal >= 1000 else 0
    else:
        raise ValueError("unknown coupon: " + code)
    if d > 0:
        USED[code] = USED.get(code, 0) + 1
    AUDIT.append(code + " " + str(d))
    return d


if __name__ == "__main__":
    for code, subtotal in [("FLAT100", 1140), ("SAVE10", 1140), ("BIG200", 1140), ("BIG200", 340)]:
        print(f"{code} on {subtotal}: {discount(code, subtotal)}")
    try:
        discount("GOLD", 1140)
    except ValueError as e:
        print("rejected:", e)
    print("used:", ", ".join(f"{c} {n}" for c, n in sorted(USED.items())))
    print("audit lines:", len(AUDIT))

// CouponsV1.java: the first pass at minute ten, one method with an else-if for every code
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

class CouponsV1 {
    static final Map<String, Integer> USED = new TreeMap<>(); // code -> times it gave a discount
    static final List<String> AUDIT = new ArrayList<>(); // one line per applied code

    static int discount(String code, int subtotal) {
        int d;
        if (code.equals("FLAT100")) {
            d = Math.min(100, subtotal);
        } else if (code.equals("SAVE10")) {
            d = Math.min(subtotal * 10 / 100, 80);
        } else if (code.equals("BIG200")) {
            d = subtotal >= 1000 ? 200 : 0;
        } else {
            throw new IllegalArgumentException("unknown coupon: " + code);
        }
        if (d > 0) USED.merge(code, 1, Integer::sum);
        AUDIT.add(code + " " + d);
        return d;
    }

    public static void main(String[] args) {
        String[] codes = {"FLAT100", "SAVE10", "BIG200", "BIG200"};
        int[] subtotals = {1140, 1140, 1140, 340};
        for (int i = 0; i < codes.length; i++) {
            System.out.println(codes[i] + " on " + subtotals[i] + ": " + discount(codes[i], subtotals[i]));
        }
        try {
            discount("GOLD", 1140);
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
        List<String> parts = new ArrayList<>();
        for (Map.Entry<String, Integer> e : USED.entrySet()) parts.add(e.getKey() + " " + e.getValue());
        System.out.println("used: " + String.join(", ", parts));
        System.out.println("audit lines: " + AUDIT.size());
    }
}

// coupons_v1.cpp: the first pass at minute ten, one function with an else-if for every code
#include <algorithm>
#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <vector>

std::map<std::string, int> USED;  // code -> times it gave a discount (a sorted map)
std::vector<std::string> AUDIT;   // one line per applied code

int discount(const std::string& code, int subtotal) {
    int d;
    if (code == "FLAT100") {
        d = std::min(100, subtotal);
    } else if (code == "SAVE10") {
        d = std::min(subtotal * 10 / 100, 80);
    } else if (code == "BIG200") {
        d = subtotal >= 1000 ? 200 : 0;
    } else {
        throw std::invalid_argument("unknown coupon: " + code);
    }
    if (d > 0) USED[code] += 1;
    AUDIT.push_back(code + " " + std::to_string(d));
    return d;
}

int main() {
    std::vector<std::pair<std::string, int>> runs = {{"FLAT100", 1140}, {"SAVE10", 1140}, {"BIG200", 1140}, {"BIG200", 340}};
    for (const auto& run : runs) {
        std::cout << run.first << " on " << run.second << ": " << discount(run.first, run.second) << "\n";
    }
    try {
        discount("GOLD", 1140);
    } catch (const std::invalid_argument& e) {
        std::cout << "rejected: " << e.what() << "\n";
    }
    std::string used;
    for (const auto& entry : USED) used += (used.empty() ? "" : ", ") + entry.first + " " + std::to_string(entry.second);
    std::cout << "used: " << used << "\n";
    std::cout << "audit lines: " << AUDIT.size() << "\n";
}

// couponsV1.js: the first pass at minute ten, one function with an else-if for every code
const USED = {}; // code -> times it gave a discount
const AUDIT = []; // one line per applied code

function discount(code, subtotal) {
  let d;
  if (code === "FLAT100") {
    d = Math.min(100, subtotal);
  } else if (code === "SAVE10") {
    d = Math.min(Math.floor((subtotal * 10) / 100), 80);
  } else if (code === "BIG200") {
    d = subtotal >= 1000 ? 200 : 0;
  } else {
    throw new Error("unknown coupon: " + code);
  }
  if (d > 0) USED[code] = (USED[code] || 0) + 1;
  AUDIT.push(code + " " + d);
  return d;
}

for (const [code, subtotal] of [["FLAT100", 1140], ["SAVE10", 1140], ["BIG200", 1140], ["BIG200", 340]]) {
  console.log(`${code} on ${subtotal}: ${discount(code, subtotal)}`);
}
try {
  discount("GOLD", 1140);
} catch (e) {
  console.log("rejected:", e.message);
}
console.log("used:", Object.keys(USED).sort().map((c) => `${c} ${USED[c]}`).join(", "));
console.log("audit lines:", AUDIT.length);

# coupon_engine.py: a rule per class (Strategy), wrappers for cap and minimum (Decorator), listeners (Observer)
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Dict, List


@dataclass(frozen=True)
class Item:
    name: str
    price: int  # rupees
    qty: int


@dataclass(frozen=True)
class Cart:
    items: List[Item]

    def subtotal(self) -> int:
        return sum(i.price * i.qty for i in self.items)


class Coupon(ABC):
    """Strategy: one job (how much off this cart), many ways to do it."""

    @abstractmethod
    def discount(self, cart: Cart) -> int: ...


class FlatOff(Coupon):
    def __init__(self, amount: int) -> None:
        self.amount = amount

    def discount(self, cart: Cart) -> int:
        return min(self.amount, cart.subtotal())


class PercentOff(Coupon):
    def __init__(self, percent: int) -> None:
        self.percent = percent

    def discount(self, cart: Cart) -> int:
        return cart.subtotal() * self.percent // 100


class Capped(Coupon):
    """Decorator: any coupon, but never more than the cap."""

    def __init__(self, inner: Coupon, cap: int) -> None:
        self.inner, self.cap = inner, cap

    def discount(self, cart: Cart) -> int:
        return min(self.inner.discount(cart), self.cap)


class MinimumCart(Coupon):
    """Decorator: any coupon, but only on carts of at least the minimum."""

    def __init__(self, minimum: int, inner: Coupon) -> None:
        self.minimum, self.inner = minimum, inner

    def discount(self, cart: Cart) -> int:
        return self.inner.discount(cart) if cart.subtotal() >= self.minimum else 0


@dataclass(frozen=True)
class CouponEvent:
    code: str
    discount: int
    rejected: bool


class CouponEngine:
    """Looks a code up, asks the coupon, and tells the listeners."""

    def __init__(self, catalog: Dict[str, Coupon]) -> None:
        self.catalog, self.listeners, self.listener_errors = catalog, [], 0

    def subscribe(self, listener) -> None:
        self.listeners.append(listener)

    def discount(self, code: str, cart: Cart) -> int:
        coupon = self.catalog.get(code)
        if coupon is None:
            self._tell(CouponEvent(code, 0, True))
            raise ValueError("unknown coupon: " + code)
        d = coupon.discount(cart)
        self._tell(CouponEvent(code, d, False))
        return d

    def _tell(self, event: CouponEvent) -> None:
        for listener in self.listeners:
            try:
                listener.on_coupon(event)
            except Exception:  # one broken listener must not lose the discount or silence the rest
                self.listener_errors += 1


class UsageCounter:
    def __init__(self) -> None:
        self.used: Dict[str, int] = {}

    def on_coupon(self, event: CouponEvent) -> None:
        if event.discount > 0:
            self.used[event.code] = self.used.get(event.code, 0) + 1


class AuditLog:
    def __init__(self) -> None:
        self.lines: List[str] = []

    def on_coupon(self, event: CouponEvent) -> None:
        self.lines.append(event.code + (" rejected" if event.rejected else " " + str(event.discount)))


class Flaky:
    def on_coupon(self, event: CouponEvent) -> None:
        raise RuntimeError("the dashboard is down")


if __name__ == "__main__":
    catalog = {
        "FLAT100": FlatOff(100),
        "SAVE10": Capped(PercentOff(10), 80),
        "BIG200": MinimumCart(1000, FlatOff(200)),
    }
    engine = CouponEngine(catalog)
    usage, audit = UsageCounter(), AuditLog()
    for listener in (Flaky(), usage, audit):
        engine.subscribe(listener)
    big = Cart([Item("notebook", 120, 2), Item("pen", 25, 4), Item("bag", 800, 1)])
    small = Cart([Item("notebook", 120, 2), Item("pen", 25, 4)])
    for code, cart in [("FLAT100", big), ("SAVE10", big), ("BIG200", big), ("BIG200", small)]:
        print(f"{code} on {cart.subtotal()}: {engine.discount(code, cart)}")
    try:
        engine.discount("GOLD", big)
    except ValueError as e:
        print("rejected:", e)
    print("used:", ", ".join(f"{c} {n}" for c, n in sorted(usage.used.items())))
    print("audit:", " | ".join(audit.lines))
    print(f"listener errors: {engine.listener_errors}, and every discount was still returned")

// CouponEngine.java: a rule per class (Strategy), wrappers for cap and minimum (Decorator), listeners (Observer)
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

class CouponEngine {
    record Item(String name, int price, int qty) {} // rupees

    record Cart(List<Item> items) {
        int subtotal() {
            int sum = 0;
            for (Item i : items) sum += i.price() * i.qty();
            return sum;
        }
    }

    /** Strategy: one job (how much off this cart), many ways to do it. */
    interface Coupon {
        int discount(Cart cart);
    }

    static final class FlatOff implements Coupon {
        private final int amount;

        FlatOff(int amount) { this.amount = amount; }

        public int discount(Cart cart) { return Math.min(amount, cart.subtotal()); }
    }

    static final class PercentOff implements Coupon {
        private final int percent;

        PercentOff(int percent) { this.percent = percent; }

        public int discount(Cart cart) { return cart.subtotal() * percent / 100; }
    }

    /** Decorator: any coupon, but never more than the cap. */
    static final class Capped implements Coupon {
        private final Coupon inner;
        private final int cap;

        Capped(Coupon inner, int cap) { this.inner = inner; this.cap = cap; }

        public int discount(Cart cart) { return Math.min(inner.discount(cart), cap); }
    }

    /** Decorator: any coupon, but only on carts of at least the minimum. */
    static final class MinimumCart implements Coupon {
        private final int minimum;
        private final Coupon inner;

        MinimumCart(int minimum, Coupon inner) { this.minimum = minimum; this.inner = inner; }

        public int discount(Cart cart) { return cart.subtotal() >= minimum ? inner.discount(cart) : 0; }
    }

    record CouponEvent(String code, int discount, boolean rejected) {}

    interface Listener {
        void onCoupon(CouponEvent event);
    }

    /** Looks a code up, asks the coupon, and tells the listeners. */
    static final class Engine {
        private final Map<String, Coupon> catalog;
        private final List<Listener> listeners = new ArrayList<>();
        int listenerErrors = 0;

        Engine(Map<String, Coupon> catalog) { this.catalog = catalog; }

        void subscribe(Listener listener) { listeners.add(listener); }

        int discount(String code, Cart cart) {
            Coupon coupon = catalog.get(code);
            if (coupon == null) {
                tell(new CouponEvent(code, 0, true));
                throw new IllegalArgumentException("unknown coupon: " + code);
            }
            int d = coupon.discount(cart);
            tell(new CouponEvent(code, d, false));
            return d;
        }

        private void tell(CouponEvent event) {
            for (Listener listener : listeners) {
                try {
                    listener.onCoupon(event);
                } catch (RuntimeException e) { // one broken listener must not lose the discount or silence the rest
                    listenerErrors++;
                }
            }
        }
    }

    static final class UsageCounter implements Listener {
        final Map<String, Integer> used = new TreeMap<>();

        public void onCoupon(CouponEvent event) {
            if (event.discount() > 0) used.merge(event.code(), 1, Integer::sum);
        }
    }

    static final class AuditLog implements Listener {
        final List<String> lines = new ArrayList<>();

        public void onCoupon(CouponEvent event) {
            lines.add(event.code() + (event.rejected() ? " rejected" : " " + event.discount()));
        }
    }

    public static void main(String[] args) {
        Map<String, Coupon> catalog = Map.of(
            "FLAT100", new FlatOff(100),
            "SAVE10", new Capped(new PercentOff(10), 80),
            "BIG200", new MinimumCart(1000, new FlatOff(200)));
        Engine engine = new Engine(catalog);
        UsageCounter usage = new UsageCounter();
        AuditLog audit = new AuditLog();
        engine.subscribe(event -> { throw new RuntimeException("the dashboard is down"); });
        engine.subscribe(usage);
        engine.subscribe(audit);
        Cart big = new Cart(List.of(new Item("notebook", 120, 2), new Item("pen", 25, 4), new Item("bag", 800, 1)));
        Cart small = new Cart(List.of(new Item("notebook", 120, 2), new Item("pen", 25, 4)));
        String[] codes = {"FLAT100", "SAVE10", "BIG200", "BIG200"};
        Cart[] carts = {big, big, big, small};
        for (int i = 0; i < codes.length; i++) {
            System.out.println(codes[i] + " on " + carts[i].subtotal() + ": " + engine.discount(codes[i], carts[i]));
        }
        try {
            engine.discount("GOLD", big);
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
        List<String> parts = new ArrayList<>();
        for (Map.Entry<String, Integer> e : usage.used.entrySet()) parts.add(e.getKey() + " " + e.getValue());
        System.out.println("used: " + String.join(", ", parts));
        System.out.println("audit: " + String.join(" | ", audit.lines));
        System.out.println("listener errors: " + engine.listenerErrors + ", and every discount was still returned");
    }
}

// coupon_engine.cpp: a rule per class (Strategy), wrappers for cap and minimum (Decorator), listeners (Observer)
#include <algorithm>
#include <iostream>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

struct Item {
    std::string name;
    int price;  // rupees
    int qty;
};

struct Cart {
    std::vector<Item> items;
    int subtotal() const {
        int sum = 0;
        for (const Item& i : items) sum += i.price * i.qty;
        return sum;
    }
};

// Strategy: one job (how much off this cart), many ways to do it.
class Coupon {
public:
    virtual ~Coupon() = default;
    virtual int discount(const Cart& cart) const = 0;
};

class FlatOff : public Coupon {
    int amount_;
public:
    explicit FlatOff(int amount) : amount_(amount) {}
    int discount(const Cart& cart) const override { return std::min(amount_, cart.subtotal()); }
};

class PercentOff : public Coupon {
    int percent_;
public:
    explicit PercentOff(int percent) : percent_(percent) {}
    int discount(const Cart& cart) const override { return cart.subtotal() * percent_ / 100; }
};

// Decorator: any coupon, but never more than the cap.
class Capped : public Coupon {
    std::shared_ptr<const Coupon> inner_;
    int cap_;
public:
    Capped(std::shared_ptr<const Coupon> inner, int cap) : inner_(std::move(inner)), cap_(cap) {}
    int discount(const Cart& cart) const override { return std::min(inner_->discount(cart), cap_); }
};

// Decorator: any coupon, but only on carts of at least the minimum.
class MinimumCart : public Coupon {
    int minimum_;
    std::shared_ptr<const Coupon> inner_;
public:
    MinimumCart(int minimum, std::shared_ptr<const Coupon> inner) : minimum_(minimum), inner_(std::move(inner)) {}
    int discount(const Cart& cart) const override { return cart.subtotal() >= minimum_ ? inner_->discount(cart) : 0; }
};

struct CouponEvent {
    std::string code;
    int discount;
    bool rejected;
};

class Listener {
public:
    virtual ~Listener() = default;
    virtual void onCoupon(const CouponEvent& event) = 0;
};

// Looks a code up, asks the coupon, and tells the listeners.
class CouponEngine {
    std::map<std::string, std::shared_ptr<const Coupon>> catalog_;
    std::vector<Listener*> listeners_;
    void tell(const CouponEvent& event) {
        for (Listener* listener : listeners_) {
            try {
                listener->onCoupon(event);
            } catch (const std::exception&) {  // one broken listener must not lose the discount or silence the rest
                listenerErrors++;
            }
        }
    }
public:
    int listenerErrors = 0;
    explicit CouponEngine(std::map<std::string, std::shared_ptr<const Coupon>> catalog) : catalog_(std::move(catalog)) {}
    void subscribe(Listener& listener) { listeners_.push_back(&listener); }
    int discount(const std::string& code, const Cart& cart) {
        auto it = catalog_.find(code);
        if (it == catalog_.end()) {
            tell({code, 0, true});
            throw std::invalid_argument("unknown coupon: " + code);
        }
        int d = it->second->discount(cart);
        tell({code, d, false});
        return d;
    }
};

class UsageCounter : public Listener {
public:
    std::map<std::string, int> used;  // a sorted map
    void onCoupon(const CouponEvent& event) override {
        if (event.discount > 0) used[event.code] += 1;
    }
};

class AuditLog : public Listener {
public:
    std::vector<std::string> lines;
    void onCoupon(const CouponEvent& event) override {
        lines.push_back(event.code + (event.rejected ? std::string(" rejected") : " " + std::to_string(event.discount)));
    }
};

class Flaky : public Listener {
public:
    void onCoupon(const CouponEvent&) override { throw std::runtime_error("the dashboard is down"); }
};

int main() {
    CouponEngine engine({
        {"FLAT100", std::make_shared<FlatOff>(100)},
        {"SAVE10", std::make_shared<Capped>(std::make_shared<PercentOff>(10), 80)},
        {"BIG200", std::make_shared<MinimumCart>(1000, std::make_shared<FlatOff>(200))},
    });
    Flaky flaky;
    UsageCounter usage;
    AuditLog audit;
    engine.subscribe(flaky);
    engine.subscribe(usage);
    engine.subscribe(audit);
    Cart big{{{"notebook", 120, 2}, {"pen", 25, 4}, {"bag", 800, 1}}};
    Cart small{{{"notebook", 120, 2}, {"pen", 25, 4}}};
    std::vector<std::pair<std::string, const Cart*>> runs = {{"FLAT100", &big}, {"SAVE10", &big}, {"BIG200", &big}, {"BIG200", &small}};
    for (const auto& run : runs) {
        std::cout << run.first << " on " << run.second->subtotal() << ": " << engine.discount(run.first, *run.second) << "\n";
    }
    try {
        engine.discount("GOLD", big);
    } catch (const std::invalid_argument& e) {
        std::cout << "rejected: " << e.what() << "\n";
    }
    std::string used, log;
    for (const auto& entry : usage.used) used += (used.empty() ? "" : ", ") + entry.first + " " + std::to_string(entry.second);
    for (const auto& line : audit.lines) log += (log.empty() ? "" : " | ") + line;
    std::cout << "used: " << used << "\n";
    std::cout << "audit: " << log << "\n";
    std::cout << "listener errors: " << engine.listenerErrors << ", and every discount was still returned\n";
}

// couponEngine.js: a rule per class (Strategy), wrappers for cap and minimum (Decorator), listeners (Observer)
// An item is { name, price, qty } with whole rupees; a Cart wraps a list of items.
class Cart {
  constructor(items) {
    this.items = items;
  }
  subtotal() {
    return this.items.reduce((sum, i) => sum + i.price * i.qty, 0);
  }
}

// Strategy: any object with discount(cart). JavaScript has no interfaces, so the contract is the method name.
class FlatOff {
  constructor(amount) {
    this.amount = amount;
  }
  discount(cart) {
    return Math.min(this.amount, cart.subtotal());
  }
}

class PercentOff {
  constructor(percent) {
    this.percent = percent;
  }
  discount(cart) {
    return Math.floor((cart.subtotal() * this.percent) / 100);
  }
}

/** Decorator: any coupon, but never more than the cap. */
class Capped {
  constructor(inner, cap) {
    Object.assign(this, { inner, cap });
  }
  discount(cart) {
    return Math.min(this.inner.discount(cart), this.cap);
  }
}

/** Decorator: any coupon, but only on carts of at least the minimum. */
class MinimumCart {
  constructor(minimum, inner) {
    Object.assign(this, { minimum, inner });
  }
  discount(cart) {
    return cart.subtotal() >= this.minimum ? this.inner.discount(cart) : 0;
  }
}

/** Looks a code up, asks the coupon, and tells the listeners. */
class CouponEngine {
  constructor(catalog) {
    this.catalog = catalog;
    this.listeners = [];
    this.listenerErrors = 0;
  }
  subscribe(listener) {
    this.listeners.push(listener);
  }
  discount(code, cart) {
    const coupon = this.catalog.get(code);
    if (!coupon) {
      this.#tell({ code, discount: 0, rejected: true });
      throw new Error("unknown coupon: " + code);
    }
    const d = coupon.discount(cart);
    this.#tell({ code, discount: d, rejected: false });
    return d;
  }
  #tell(event) {
    for (const listener of this.listeners) {
      try {
        listener.onCoupon(event);
      } catch (e) {
        this.listenerErrors++; // one broken listener must not lose the discount or silence the rest
      }
    }
  }
}

class UsageCounter {
  used = new Map();
  onCoupon(event) {
    if (event.discount > 0) this.used.set(event.code, (this.used.get(event.code) || 0) + 1);
  }
}

class AuditLog {
  lines = [];
  onCoupon(event) {
    this.lines.push(event.code + (event.rejected ? " rejected" : " " + event.discount));
  }
}

class Flaky {
  onCoupon(event) {
    throw new Error("the dashboard is down");
  }
}

const catalog = new Map([
  ["FLAT100", new FlatOff(100)],
  ["SAVE10", new Capped(new PercentOff(10), 80)],
  ["BIG200", new MinimumCart(1000, new FlatOff(200))],
]);
const engine = new CouponEngine(catalog);
const usage = new UsageCounter();
const audit = new AuditLog();
for (const listener of [new Flaky(), usage, audit]) engine.subscribe(listener);
const big = new Cart([{ name: "notebook", price: 120, qty: 2 }, { name: "pen", price: 25, qty: 4 }, { name: "bag", price: 800, qty: 1 }]);
const small = new Cart([{ name: "notebook", price: 120, qty: 2 }, { name: "pen", price: 25, qty: 4 }]);
for (const [code, cart] of [["FLAT100", big], ["SAVE10", big], ["BIG200", big], ["BIG200", small]]) {
  console.log(`${code} on ${cart.subtotal()}: ${engine.discount(code, cart)}`);
}
try {
  engine.discount("GOLD", big);
} catch (e) {
  console.log("rejected:", e.message);
}
console.log("used:", [...usage.used.keys()].sort().map((c) => `${c} ${usage.used.get(c)}`).join(", "));
console.log("audit:", audit.lines.join(" | "));
console.log(`listener errors: ${engine.listenerErrors}, and every discount was still returned`);