Single responsibility in depth

interface Expense { id: number; paidBy: string; amount: number; shares: Map<string, number>; } // cents

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

// Asked for by the product team: how a bill is divided.
class SplitCalculator {
  equal(amount: number, people: string[]): Map<string, number> {
    const base = Math.floor(amount / people.length), extra = amount % people.length;
    return new Map(people.map((p, i): [string, number] => [p, base + (i < extra ? 1 : 0)]));
  }
  byPercent(amount: number, percents: Map<string, number>): Map<string, number> {
    const shares = new Map<string, number>();
    for (const [p, pct] of percents) shares.set(p, Math.floor((amount * pct) / 100));
    const first = [...shares.keys()][0];
    const total = [...shares.values()].reduce((s, v) => s + v, 0);
    shares.set(first, (shares.get(first) ?? 0) + amount - total); // the first person absorbs rounding
    return shares;
  }
}

// Asked for by the platform team: where expenses are kept.
interface ExpenseRepository { save(expense: Expense): void; count(): number; }

class InMemoryExpenses implements ExpenseRepository {
  private rows: Expense[] = [];
  save(expense: Expense): void { this.rows.push(expense); }
  count(): number { return this.rows.length; }
}

// Asked for by the messaging team: what people are told, and how.
class ExpenseNotifier {
  notify(e: Expense): void {
    for (const [person, owed] of e.shares) if (person !== e.paidBy) console.log(`#${e.id} ${person} owes ${e.paidBy} ${money(owed)}`);
  }
}

// The workflow itself: changes only if the steps of adding an expense change.
class ExpenseService {
  constructor(private repo: ExpenseRepository, private notifier: ExpenseNotifier) {}
  add(paidBy: string, amount: number, shares: Map<string, number>): Expense {
    if ([...shares.values()].reduce((s, v) => s + v, 0) !== amount) throw new Error("shares must add up to the amount");
    const expense: Expense = { id: this.repo.count() + 1, paidBy, amount, shares };
    this.repo.save(expense);
    this.notifier.notify(expense);
    return expense;
  }
}

const split = new SplitCalculator(), repo = new InMemoryExpenses();
const service = new ExpenseService(repo, new ExpenseNotifier());
service.add("Ben", 10000, split.equal(10000, ["Ana", "Ben", "Chen"]));
// The product team adds percentage splits: only SplitCalculator changed.
service.add("Ana", 6000, split.byPercent(6000, new Map([["Ana", 50], ["Ben", 30], ["Chen", 20]])));
console.log(`stored: ${repo.count()} expenses`);

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

record Expense(int id, String paidBy, int amount, Map<String, Integer> shares) {} // cents

// Asked for by the product team: how a bill is divided.
class SplitCalculator {
    Map<String, Integer> equal(int amount, List<String> people) {
        int base = amount / people.size(), extra = amount % people.size();
        Map<String, Integer> shares = new LinkedHashMap<>();
        for (int i = 0; i < people.size(); i++) shares.put(people.get(i), base + (i < extra ? 1 : 0));
        return shares;
    }

    Map<String, Integer> byPercent(int amount, Map<String, Integer> percents) {
        Map<String, Integer> shares = new LinkedHashMap<>();
        percents.forEach((p, pct) -> shares.put(p, amount * pct / 100));
        String first = shares.keySet().iterator().next();
        int total = shares.values().stream().mapToInt(Integer::intValue).sum();
        shares.put(first, shares.get(first) + amount - total); // the first person absorbs rounding
        return shares;
    }
}

// Asked for by the platform team: where expenses are kept.
interface ExpenseRepository {
    void save(Expense expense);
    int count();
}

class InMemoryExpenses implements ExpenseRepository {
    private final List<Expense> rows = new ArrayList<>();
    public void save(Expense expense) { rows.add(expense); }
    public int count() { return rows.size(); }
}

// Asked for by the messaging team: what people are told, and how.
class ExpenseNotifier {
    static String money(int c) { return (c / 100) + "." + String.format("%02d", c % 100); }

    void notify(Expense e) {
        e.shares().forEach((person, owed) -> {
            if (!person.equals(e.paidBy())) System.out.println("#" + e.id() + " " + person + " owes " + e.paidBy() + " " + money(owed));
        });
    }
}

// The workflow itself: changes only if the steps of adding an expense change.
class ExpenseService {
    private final ExpenseRepository repo;
    private final ExpenseNotifier notifier;

    ExpenseService(ExpenseRepository repo, ExpenseNotifier notifier) { this.repo = repo; this.notifier = notifier; }

    Expense add(String paidBy, int amount, Map<String, Integer> shares) {
        if (shares.values().stream().mapToInt(Integer::intValue).sum() != amount) throw new IllegalArgumentException("shares must add up to the amount");
        Expense expense = new Expense(repo.count() + 1, paidBy, amount, shares);
        repo.save(expense);
        notifier.notify(expense);
        return expense;
    }
}

public class Main {
    public static void main(String[] args) {
        SplitCalculator split = new SplitCalculator();
        InMemoryExpenses repo = new InMemoryExpenses();
        ExpenseService service = new ExpenseService(repo, new ExpenseNotifier());
        service.add("Ben", 10000, split.equal(10000, List.of("Ana", "Ben", "Chen")));
        // The product team adds percentage splits: only SplitCalculator changed.
        Map<String, Integer> pct = new LinkedHashMap<>();
        pct.put("Ana", 50); pct.put("Ben", 30); pct.put("Chen", 20);
        service.add("Ana", 6000, split.byPercent(6000, pct));
        System.out.println("stored: " + repo.count() + " expenses");
    }
}