diff --git a/README.md b/README.md
index e792a1b..3a2a292 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,7 @@ One module per article. This repository currently holds:
| [`matrix`](matrix/) | Matrix Programs in Java: Addition, Multiplication, Transpose, Spiral and Rotation | this commit |
| [`rate-limiter`](rate-limiter/) | Low-Level Design: Rate Limiter in Java (Token Bucket, Sliding Window) + Spring Boot | this commit |
| [`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 |
## `collections` module
diff --git a/splitwise/README.md b/splitwise/README.md
new file mode 100644
index 0000000..7b89e07
--- /dev/null
+++ b/splitwise/README.md
@@ -0,0 +1,57 @@
+# splitwise
+
+Companion code for the ankurm.com article **Low-Level Design: Splitwise (Expense Sharing) in Java**.
+
+An expense-sharing core: four ways to split a bill (equal, exact, percent, shares) with exact paise arithmetic, a ledger derived from
+the expense log, and two debt simplifiers (greedy, and an exact search that finds the true minimum number of payments). 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 splitwise
+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. Two transcripts contain figures that depend on timing
+(`04c-simplify-cost.txt`, `06b-concurrency-control.txt`); they say so in their first line and differ from run to run by design.
+
+## The pieces
+
+| Class | Role |
+|---|---|
+| `Money` | text to and from whole paise; the rest of the code never sees a `double` |
+| `Apportion` | largest remainder division: shares always add up to the total exactly |
+| `SplitStrategy` | the one interface a split implements: `participants()` and `split(total)` |
+| `EqualSplit`, `ExactSplit`, `PercentSplit`, `ShareSplit` | the four strategies; each validates its own input |
+| `Expense`, `Transfer`, `User` | immutable records: an expense and what each person owes, a payment, a person |
+| `Ledger` | net balance per person plus a per-pair view, built by applying expenses and transfers in order |
+| `Group` | members, the expense log, and synchronized `addExpense` / `settle` |
+| `DebtSimplifier` | net balances in, short list of payments out |
+| `GreedyDebtSimplifier` | biggest debtor pays biggest creditor; at most n - 1 payments |
+| `OptimalDebtSimplifier` | subset DP over zero-sum groups; the true minimum, up to 20 people |
+| `SplitwiseService` | registers users, creates groups |
+
+## Transcripts
+
+| File | Written by | What it shows |
+|---|---|---|
+| `01-happy-path.txt` | `HappyPathTest` | a four-friend trip: shares, net balances, pairwise vs simplified debts |
+| `02-rounding.txt`, `02b-rounding-property.txt` | `RoundingTest` | why `double` and plain division fail; 200,000 seeded divisions |
+| `03-validation.txt` | `ValidationTest` | eleven bad requests, the exact message for each, ledger untouched |
+| `04-simplify.txt`, `04b-simplify-random.txt`, `04c-simplify-cost.txt` | `SimplifyTest` | where greedy is not minimal; 1,500 seeded cases cross-checked by backtracking; cost of the exact search |
+| `05-settle-up.txt`, `05b-replay.txt` | `SettleUpTest` | recording payments; the ledger rebuilt from the log |
+| `06-concurrency.txt`, `06b-concurrency-control.txt` | `ConcurrencyTest` | eight threads on one group; the same idea with an unsynchronized map |
+| `07-pitfalls.txt` | `PitfallsTest` | six traps, each reproduced |
diff --git a/splitwise/output/01-happy-path.txt b/splitwise/output/01-happy-path.txt
new file mode 100644
index 0000000..0008a4f
--- /dev/null
+++ b/splitwise/output/01-happy-path.txt
@@ -0,0 +1,28 @@
+Four friends, five expenses, four split strategies
+==================================================
+
+Expenses (shares in paise-exact rupees)
+#1 Hotel (equal) paid by asha Rs 12000.00 asha=Rs 3000.00 bala=Rs 3000.00 chitra=Rs 3000.00 dev=Rs 3000.00
+#2 Dinner (equal, 3 people) paid by bala Rs 100.00 asha=Rs 33.34 bala=Rs 33.33 chitra=Rs 33.33
+#3 Cab (exact) paid by chitra Rs 900.00 asha=Rs 300.00 bala=Rs 200.00 chitra=Rs 100.00 dev=Rs 300.00
+#4 Scuba (percent) paid by dev Rs 4000.00 asha=Rs 1600.00 bala=Rs 400.00 chitra=Rs 400.00 dev=Rs 1600.00
+#5 Groceries (shares 2:1:1) paid by asha Rs 1000.00 asha=Rs 500.00 bala=Rs 250.00 chitra=Rs 250.00
+
+Net balance per person (positive = the group owes them)
+asha Rs 7566.66
+bala -Rs 3783.33
+chitra -Rs 2883.33
+dev -Rs 900.00
+
+Detailed debts, netted pair by pair: 6 payments
+ bala pays asha Rs 3216.66
+ chitra pays asha Rs 2950.00
+ dev pays asha Rs 1400.00
+ bala pays chitra Rs 166.67
+ bala pays dev Rs 400.00
+ chitra pays dev Rs 100.00
+
+Simplified debts (greedy): 3 payments
+ bala pays asha Rs 3783.33
+ chitra pays asha Rs 2883.33
+ dev pays asha Rs 900.00
diff --git a/splitwise/output/02-rounding.txt b/splitwise/output/02-rounding.txt
new file mode 100644
index 0000000..11bbe4f
--- /dev/null
+++ b/splitwise/output/02-rounding.txt
@@ -0,0 +1,14 @@
+Why paise in a long, and why largest remainder
+==============================================
+
+double: 0.1 + 0.2 = 0.30000000000000004
+double: ten times 0.10 = 0.9999999999999999
+
+long, plain division: 10000 paise / 3 = 3333 each; three of them make 9999 paise
+one paisa has vanished: 1
+
+largest remainder, Rs 100.00 in 3 equal parts: [3334, 3333, 3333] sum 10000
+largest remainder, 10 paise in 3 equal parts: [4, 3, 3] sum 10
+largest remainder, 33.33% / 33.33% / 33.34%: [3333, 3333, 3334] sum 10000
+largest remainder, shares 2:1:1 of Rs 1000.00: [50000, 25000, 25000] sum 100000
+largest remainder, Rs 100.00 in 7 equal parts: [1429, 1429, 1429, 1429, 1428, 1428, 1428] sum 10000
diff --git a/splitwise/output/02b-rounding-property.txt b/splitwise/output/02b-rounding-property.txt
new file mode 100644
index 0000000..8da809e
--- /dev/null
+++ b/splitwise/output/02b-rounding-property.txt
@@ -0,0 +1,7 @@
+Seeded property check: 200000 random divisions
+==============================================
+
+trials: 200000
+every trial: shares add up to the total exactly
+every share: equal to the exact amount rounded down, or one paisa more
+largest gap above the rounded-down amount: 1 paisa
diff --git a/splitwise/output/03-validation.txt b/splitwise/output/03-validation.txt
new file mode 100644
index 0000000..c575c23
--- /dev/null
+++ b/splitwise/output/03-validation.txt
@@ -0,0 +1,16 @@
+Bad input is rejected before it touches the ledger
+==================================================
+
+exact amounts too small -> InvalidSplitException: exact amounts add up to Rs 90.00 but the expense is Rs 100.00
+percentages add up to 99.99 -> InvalidSplitException: percentages add up to 99.99 but must add up to 100
+percentage with 3 decimal places -> InvalidSplitException: percent for asha has more than 2 decimal places: 33.333
+zero shares -> InvalidSplitException: shares for bala must be positive
+same person listed twice -> InvalidSplitException: duplicate participant in [asha, asha]
+nobody to split with -> InvalidSplitException: an equal split needs at least one participant
+participant outside the group -> IllegalArgumentException: esha is not a member of group Goa trip
+payer outside the group -> IllegalArgumentException: esha is not a member of group Goa trip
+zero-rupee expense -> IllegalArgumentException: an expense must be positive, got Rs 0.00
+paying yourself -> IllegalArgumentException: asha cannot pay themselves
+amount with three decimals -> IllegalArgumentException: not a whole number of paise: 10.005
+
+After eleven rejected requests: 5 expenses, balances unchanged = true
diff --git a/splitwise/output/04-simplify.txt b/splitwise/output/04-simplify.txt
new file mode 100644
index 0000000..4f73645
--- /dev/null
+++ b/splitwise/output/04-simplify.txt
@@ -0,0 +1,16 @@
+Simplifying debts: pairwise vs greedy vs exact
+==============================================
+
+Goa trip: 6 pairwise payments, 3 greedy, 3 exact
+
+Balances (Rs): a +4, b +3, c +3, d -4, e -6
+greedy: 4 payments
+ e pays a Rs 4.00
+ d pays b Rs 3.00
+ e pays c Rs 2.00
+ d pays c Rs 1.00
+exact: 3 payments
+ e pays b Rs 3.00
+ e pays c Rs 3.00
+ d pays a Rs 4.00
+why: {a, d} cancel exactly (+4 -4) and {b, c, e} cancel exactly (+3 +3 -6), so two separate groups need 1 + 2 = 3 payments
diff --git a/splitwise/output/04b-simplify-random.txt b/splitwise/output/04b-simplify-random.txt
new file mode 100644
index 0000000..e8253af
--- /dev/null
+++ b/splitwise/output/04b-simplify-random.txt
@@ -0,0 +1,9 @@
+1500 seeded random zero-sum balance sets, up to 9 people
+========================================================
+
+cases: 1500
+every case: both simplifiers leave every balance at exactly zero
+every case: greedy uses at most (people with a balance) - 1 payments
+every case: the exact simplifier's count equals an independent backtracking search
+cases where greedy used more payments than exact: 448 of 1500
+largest difference: 2 payment(s)
diff --git a/splitwise/output/04c-simplify-cost.txt b/splitwise/output/04c-simplify-cost.txt
new file mode 100644
index 0000000..0c17e7e
--- /dev/null
+++ b/splitwise/output/04c-simplify-cost.txt
@@ -0,0 +1,7 @@
+Exact search cost (timing dependent: figures differ from run to run)
+====================================================================
+
+people 10: exact 9 payments in about 4 ms, greedy 9 payments in about 32 microseconds
+people 14: exact 12 payments in about 18 ms, greedy 13 payments in about 29 microseconds
+people 18: exact 15 payments in about 46 ms, greedy 17 payments in about 141 microseconds
+people 20: exact 17 payments in about 97 ms, greedy 18 payments in about 44 microseconds
diff --git a/splitwise/output/05-settle-up.txt b/splitwise/output/05-settle-up.txt
new file mode 100644
index 0000000..7560b67
--- /dev/null
+++ b/splitwise/output/05-settle-up.txt
@@ -0,0 +1,45 @@
+Recording real payments against the ledger
+==========================================
+
+Before settling
+asha Rs 7566.66
+bala -Rs 3783.33
+chitra -Rs 2883.33
+dev -Rs 900.00
+
+After bala pays asha Rs 3783.33
+asha Rs 3783.33
+bala Rs 0.00
+chitra -Rs 2883.33
+dev -Rs 900.00
+pair view after paying the net amount (asha-bala flips direction, because bala paid more than he owed asha directly):
+ asha pays bala Rs 566.67
+ chitra pays asha Rs 2950.00
+ dev pays asha Rs 1400.00
+ bala pays chitra Rs 166.67
+ bala pays dev Rs 400.00
+ chitra pays dev Rs 100.00
+
+After dev pays asha Rs 1000.00 (Rs 100.00 more than dev owes)
+asha Rs 2783.33
+bala Rs 0.00
+chitra -Rs 2883.33
+dev Rs 100.00
+
+Now chitra and dev follow the simplified plan
+ chitra pays asha Rs 2783.33
+ chitra pays dev Rs 100.00
+
+After the plan
+asha Rs 0.00
+bala Rs 0.00
+chitra Rs 0.00
+dev Rs 0.00
+net balances all zero: true
+pair view still lists 5 debts, because the plan paid net amounts, not the original pairs:
+ asha pays bala Rs 566.67
+ chitra pays asha Rs 166.67
+ dev pays asha Rs 400.00
+ bala pays chitra Rs 166.67
+ bala pays dev Rs 400.00
+each person's pair debts add up to their net balance: true
diff --git a/splitwise/output/05b-replay.txt b/splitwise/output/05b-replay.txt
new file mode 100644
index 0000000..daedee9
--- /dev/null
+++ b/splitwise/output/05b-replay.txt
@@ -0,0 +1,7 @@
+The ledger is derived: replaying the log rebuilds it exactly
+============================================================
+
+expenses replayed: 5
+settlements replayed: 1
+net balances equal: true
+pairwise debts equal: true
diff --git a/splitwise/output/06-concurrency.txt b/splitwise/output/06-concurrency.txt
new file mode 100644
index 0000000..7745961
--- /dev/null
+++ b/splitwise/output/06-concurrency.txt
@@ -0,0 +1,7 @@
+Eight threads adding expenses to one group
+==========================================
+
+expenses added: 40000 (expected 40000)
+distinct expense ids: 40000, highest id: 40000
+net balances add up to zero: true
+replaying the log gives the same balances: true
diff --git a/splitwise/output/06b-concurrency-control.txt b/splitwise/output/06b-concurrency-control.txt
new file mode 100644
index 0000000..d9dde2b
--- /dev/null
+++ b/splitwise/output/06b-concurrency-control.txt
@@ -0,0 +1,6 @@
+Control: the same idea without a lock (timing dependent: the figure differs every run)
+======================================================================================
+
+expected total: 1600000
+actual total: 740725
+updates lost: 859275 (always zero or more, and usually well above zero)
diff --git a/splitwise/output/07-pitfalls.txt b/splitwise/output/07-pitfalls.txt
new file mode 100644
index 0000000..097578d
--- /dev/null
+++ b/splitwise/output/07-pitfalls.txt
@@ -0,0 +1,25 @@
+Pitfalls that look fine until they are not
+==========================================
+
+1. new BigDecimal(33.33) = 33.3299999999999982946974341757595539093017578125
+ new BigDecimal("33.33") = 33.33
+ the split rejects the double-built value: percent for asha has more than 2 decimal places: 33.3299999999999982946974341757595539093017578125
+
+2. 3000 dinners of Rs 100.00 between asha, bala and chitra
+ always the same order: asha Rs 100020.00, bala Rs 99990.00, chitra Rs 99990.00
+ rotating tie offset: asha Rs 100000.00, bala Rs 100000.00, chitra Rs 100000.00
+
+3. asha pays Rs 600.00 for a gift but is not in the split
+ asha Rs 600.00
+ bala -Rs 300.00
+ chitra -Rs 300.00
+
+4. default fraction digits: INR 2, JPY 0, KWD 3
+
+5. an expense of Rs 0.01 split three ways
+ asha Rs 0.00
+ bala Rs 0.00
+ chitra Rs 0.00
+ debts: []
+
+6. simplifying balances that do not add up to zero: balances do not add up to zero: the sum is Rs 0.01
diff --git a/splitwise/pom.xml b/splitwise/pom.xml
new file mode 100644
index 0000000..95b3707
--- /dev/null
+++ b/splitwise/pom.xml
@@ -0,0 +1,64 @@
+
+
+ 4.0.0
+ com.ankurm.interviewlab
+ splitwise
+ 1.0.0
+ jar
+
+ java-interview-lab :: splitwise
+
+ Runnable companion code for ankurm.com's "Low-Level Design: Splitwise (Expense Sharing) in Java" article: split strategies,
+ exact paise arithmetic, a derived ledger and debt simplification (greedy and exact).
+
+
+
+ 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/splitwise/scripts/run-all.sh b/splitwise/scripts/run-all.sh
new file mode 100755
index 0000000..38df9a6
--- /dev/null
+++ b/splitwise/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")/.."
+mkdir -p output
+mvn -B -q -T1 test
+echo "done:"; ls -1 output
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Apportion.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Apportion.java
new file mode 100644
index 0000000..a44cbf2
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Apportion.java
@@ -0,0 +1,61 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * Divides a whole number of paise in proportion to integer weights so that the parts add up to exactly the total.
+ * This is the largest remainder (Hamilton) method: give everyone the rounded-down share, then hand the leftover
+ * paise, one each, to the people whose exact share had the biggest fractional part.
+ */
+public final class Apportion {
+ private Apportion() {
+ }
+
+ /**
+ * @param total paise to divide, zero or more
+ * @param weights one non-negative weight per person; at least one must be positive
+ * @param tieOffset which index wins a tie for a leftover paisa first (indexes after it follow, wrapping around)
+ */
+ public static long[] split(long total, long[] weights, int tieOffset) {
+ if (total < 0) {
+ throw new IllegalArgumentException("total must not be negative: " + total);
+ }
+ long weightSum = 0;
+ for (long w : weights) {
+ if (w < 0) {
+ throw new IllegalArgumentException("weights must not be negative");
+ }
+ weightSum = Math.addExact(weightSum, w);
+ }
+ if (weightSum == 0) {
+ throw new IllegalArgumentException("at least one weight must be positive");
+ }
+ int n = weights.length;
+ long[] parts = new long[n];
+ long[] remainder = new long[n];
+ long given = 0;
+ for (int i = 0; i < n; i++) {
+ long scaled = Math.multiplyExact(total, weights[i]);
+ parts[i] = scaled / weightSum;
+ remainder[i] = scaled % weightSum;
+ given += parts[i];
+ }
+ int leftover = (int) (total - given);
+ Integer[] order = new Integer[n];
+ for (int i = 0; i < n; i++) {
+ order[i] = i;
+ }
+ Arrays.sort(order, Comparator
+ .comparingLong((Integer i) -> remainder[i]).reversed()
+ .thenComparingInt(i -> Math.floorMod(i - tieOffset, n)));
+ for (int k = 0; k < leftover; k++) {
+ parts[order[k]]++;
+ }
+ return parts;
+ }
+
+ public static long[] split(long total, long[] weights) {
+ return split(total, weights, 0);
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/DebtSimplifier.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/DebtSimplifier.java
new file mode 100644
index 0000000..1cc8017
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/DebtSimplifier.java
@@ -0,0 +1,11 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.List;
+import java.util.Map;
+
+/** Turns net balances into a short list of payments that leaves everybody at zero. */
+public interface DebtSimplifier {
+
+ /** @param net user id to net paise (positive: is owed money); must add up to zero */
+ List simplify(Map net);
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/EqualSplit.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/EqualSplit.java
new file mode 100644
index 0000000..ca7b573
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/EqualSplit.java
@@ -0,0 +1,46 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/** Everyone listed pays the same, give or take one paisa. */
+public final class EqualSplit implements SplitStrategy {
+ private final List participants;
+ private final int tieOffset;
+
+ public EqualSplit(List participants) {
+ this(participants, 0);
+ }
+
+ /** {@code tieOffset} picks who is charged the extra paisa first; rotate it to keep a long series fair. */
+ public EqualSplit(List participants, int tieOffset) {
+ if (participants.isEmpty()) {
+ throw new InvalidSplitException("an equal split needs at least one participant");
+ }
+ if (new LinkedHashSet<>(participants).size() != participants.size()) {
+ throw new InvalidSplitException("duplicate participant in " + participants);
+ }
+ this.participants = List.copyOf(participants);
+ this.tieOffset = tieOffset;
+ }
+
+ @Override
+ public Set participants() {
+ return new LinkedHashSet<>(participants);
+ }
+
+ @Override
+ public Map split(long totalPaise) {
+ long[] weights = new long[participants.size()];
+ java.util.Arrays.fill(weights, 1);
+ long[] parts = Apportion.split(totalPaise, weights, tieOffset);
+ Map shares = new LinkedHashMap<>();
+ for (int i = 0; i < parts.length; i++) {
+ shares.put(participants.get(i), parts[i]);
+ }
+ return shares;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ExactSplit.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ExactSplit.java
new file mode 100644
index 0000000..34409f4
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ExactSplit.java
@@ -0,0 +1,38 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/** The payer states each person's amount; the amounts must add up to the expense exactly. */
+public final class ExactSplit implements SplitStrategy {
+ private final Map amounts;
+
+ public ExactSplit(Map amounts) {
+ if (amounts.isEmpty()) {
+ throw new InvalidSplitException("an exact split needs at least one participant");
+ }
+ amounts.forEach((user, paise) -> {
+ if (paise < 0) {
+ throw new InvalidSplitException("amount for " + user + " must not be negative");
+ }
+ });
+ this.amounts = new LinkedHashMap<>(amounts);
+ }
+
+ @Override
+ public Set participants() {
+ return new LinkedHashSet<>(amounts.keySet());
+ }
+
+ @Override
+ public Map split(long totalPaise) {
+ long sum = amounts.values().stream().mapToLong(Long::longValue).sum();
+ if (sum != totalPaise) {
+ throw new InvalidSplitException("exact amounts add up to " + Money.format(sum)
+ + " but the expense is " + Money.format(totalPaise));
+ }
+ return new LinkedHashMap<>(amounts);
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Expense.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Expense.java
new file mode 100644
index 0000000..05868ec
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Expense.java
@@ -0,0 +1,23 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * One thing somebody paid for. {@code shares} says what each person owes for it, in paise, and always adds up to the total.
+ * The payer need not appear in {@code shares} (somebody can pay for other people entirely).
+ */
+public record Expense(long id, String description, String paidBy, long totalPaise, Map shares) {
+
+ public Expense {
+ if (totalPaise <= 0) {
+ throw new IllegalArgumentException("an expense must be positive, got " + Money.format(totalPaise));
+ }
+ shares = Collections.unmodifiableMap(new LinkedHashMap<>(shares));
+ long sum = shares.values().stream().mapToLong(Long::longValue).sum();
+ if (sum != totalPaise) {
+ throw new IllegalArgumentException("shares add up to " + Money.format(sum) + " but the expense is " + Money.format(totalPaise));
+ }
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/GreedyDebtSimplifier.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/GreedyDebtSimplifier.java
new file mode 100644
index 0000000..deb3b8d
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/GreedyDebtSimplifier.java
@@ -0,0 +1,51 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+/**
+ * Repeatedly makes the biggest debtor pay the biggest creditor as much as they can. Every payment settles at least one
+ * person completely, so n people with non-zero balances need at most n - 1 payments. Fast (O(n log n)) but not always the minimum.
+ */
+public final class GreedyDebtSimplifier implements DebtSimplifier {
+
+ private record Balance(String user, long paise) {
+ }
+
+ private static final Comparator BIGGEST_FIRST =
+ Comparator.comparingLong(Balance::paise).reversed().thenComparing(Balance::user);
+
+ @Override
+ public List simplify(Map net) {
+ long sum = net.values().stream().mapToLong(Long::longValue).sum();
+ if (sum != 0) {
+ throw new IllegalArgumentException("balances do not add up to zero: the sum is " + Money.format(sum));
+ }
+ PriorityQueue creditors = new PriorityQueue<>(BIGGEST_FIRST);
+ PriorityQueue debtors = new PriorityQueue<>(BIGGEST_FIRST); // paise stored as the positive amount owed
+ net.forEach((user, paise) -> {
+ if (paise > 0) {
+ creditors.add(new Balance(user, paise));
+ } else if (paise < 0) {
+ debtors.add(new Balance(user, -paise));
+ }
+ });
+ List transfers = new ArrayList<>();
+ while (!creditors.isEmpty() && !debtors.isEmpty()) {
+ Balance creditor = creditors.poll();
+ Balance debtor = debtors.poll();
+ long pay = Math.min(creditor.paise(), debtor.paise());
+ transfers.add(new Transfer(debtor.user(), creditor.user(), pay));
+ if (creditor.paise() > pay) {
+ creditors.add(new Balance(creditor.user(), creditor.paise() - pay));
+ }
+ if (debtor.paise() > pay) {
+ debtors.add(new Balance(debtor.user(), debtor.paise() - pay));
+ }
+ }
+ return transfers;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Group.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Group.java
new file mode 100644
index 0000000..dddbb97
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Group.java
@@ -0,0 +1,91 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A set of people who share expenses. Every change goes through a synchronized method, so the ledger can never be seen
+ * half-updated: an expense is checked, divided and applied as one step.
+ */
+public final class Group {
+ private final String id;
+ private final String name;
+ private final Set members;
+ private final Ledger ledger = new Ledger();
+ private final List expenses = new ArrayList<>();
+ private final List settlements = new ArrayList<>();
+ private long nextExpenseId = 1;
+
+ public Group(String id, String name, Set members) {
+ this.id = id;
+ this.name = name;
+ this.members = new LinkedHashSet<>(members);
+ }
+
+ public String id() {
+ return id;
+ }
+
+ public String name() {
+ return name;
+ }
+
+ public synchronized Expense addExpense(String description, String paidBy, long totalPaise, SplitStrategy strategy) {
+ requireMember(paidBy);
+ strategy.participants().forEach(this::requireMember);
+ Map shares = strategy.split(totalPaise);
+ Expense expense = new Expense(nextExpenseId, description, paidBy, totalPaise, shares);
+ nextExpenseId++;
+ ledger.apply(expense);
+ expenses.add(expense);
+ return expense;
+ }
+
+ /** Records that {@code from} really paid {@code to} outside the app. */
+ public synchronized Transfer settle(String from, String to, long paise) {
+ requireMember(from);
+ requireMember(to);
+ Transfer transfer = new Transfer(from, to, paise);
+ ledger.apply(transfer);
+ settlements.add(transfer);
+ return transfer;
+ }
+
+ /** Net balance for every member, including members with nothing yet. */
+ public synchronized Map balances() {
+ Map net = ledger.net();
+ Map result = new LinkedHashMap<>();
+ members.forEach(m -> result.put(m, net.getOrDefault(m, 0L)));
+ return result;
+ }
+
+ public synchronized List pairwiseDebts() {
+ return ledger.pairwiseDebts();
+ }
+
+ public synchronized List simplifiedDebts(DebtSimplifier simplifier) {
+ return simplifier.simplify(ledger.net());
+ }
+
+ public synchronized List expenses() {
+ return List.copyOf(expenses);
+ }
+
+ public synchronized List settlements() {
+ return List.copyOf(settlements);
+ }
+
+ public synchronized boolean isBalanced() {
+ return ledger.isBalanced();
+ }
+
+ private void requireMember(String user) {
+ if (!members.contains(user)) {
+ throw new IllegalArgumentException(user + " is not a member of group " + name);
+ }
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/InvalidSplitException.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/InvalidSplitException.java
new file mode 100644
index 0000000..2b96852
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/InvalidSplitException.java
@@ -0,0 +1,8 @@
+package com.ankurm.interviewlab.splitwise;
+
+/** Thrown when the numbers describing a split cannot produce a valid division of the expense. */
+public class InvalidSplitException extends IllegalArgumentException {
+ public InvalidSplitException(String message) {
+ super(message);
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Ledger.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Ledger.java
new file mode 100644
index 0000000..6c545e7
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Ledger.java
@@ -0,0 +1,64 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Who owes what, derived by applying expenses and settlements one at a time. It keeps two views of the same facts:
+ * a net balance per person (positive: the group owes them) and a signed balance per pair of people.
+ * Not thread-safe by itself; {@link Group} serialises access.
+ */
+public final class Ledger {
+ private final Map net = new TreeMap<>();
+ private final Map pair = new TreeMap<>(); // key "a|b" with a < b; positive means a owes b
+
+ public void apply(Expense e) {
+ net.merge(e.paidBy(), e.totalPaise(), Long::sum);
+ e.shares().forEach((user, share) -> {
+ net.merge(user, -share, Long::sum);
+ if (!user.equals(e.paidBy()) && share > 0) {
+ owes(user, e.paidBy(), share);
+ }
+ });
+ }
+
+ public void apply(Transfer t) {
+ net.merge(t.from(), t.paise(), Long::sum);
+ net.merge(t.to(), -t.paise(), Long::sum);
+ owes(t.from(), t.to(), -t.paise());
+ }
+
+ private void owes(String debtor, String creditor, long paise) {
+ if (debtor.compareTo(creditor) < 0) {
+ pair.merge(debtor + "|" + creditor, paise, Long::sum);
+ } else {
+ pair.merge(creditor + "|" + debtor, -paise, Long::sum);
+ }
+ }
+
+ /** Net balance per person: what they are owed (positive) or owe (negative). */
+ public Map net() {
+ return new LinkedHashMap<>(net);
+ }
+
+ /** Every pair that still owes something, netted so each pair appears once: this is the "detailed debts" view. */
+ public List pairwiseDebts() {
+ List debts = new ArrayList<>();
+ pair.forEach((key, value) -> {
+ if (value == 0) {
+ return;
+ }
+ String[] ab = key.split("\\|");
+ debts.add(value > 0 ? new Transfer(ab[0], ab[1], value) : new Transfer(ab[1], ab[0], -value));
+ });
+ return debts;
+ }
+
+ /** The invariant everything rests on: money is only moved, never created, so the net balances add up to zero. */
+ public boolean isBalanced() {
+ return net.values().stream().mapToLong(Long::longValue).sum() == 0;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Money.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Money.java
new file mode 100644
index 0000000..b63f2de
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Money.java
@@ -0,0 +1,29 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Locale;
+
+/**
+ * Every amount in this module is a whole number of paise held in a {@code long}. This class only converts to and from text,
+ * so the arithmetic everywhere else is exact integer arithmetic.
+ */
+public final class Money {
+ private Money() {
+ }
+
+ /** "100.00" becomes 10000. Text with more than two decimal places is rejected rather than rounded. */
+ public static long ofRupees(String text) {
+ try {
+ return new BigDecimal(text).setScale(2, RoundingMode.UNNECESSARY).movePointRight(2).longValueExact();
+ } catch (ArithmeticException e) {
+ throw new IllegalArgumentException("not a whole number of paise: " + text, e);
+ }
+ }
+
+ /** 3334 becomes "Rs 33.34"; negative amounts keep the sign in front. */
+ public static String format(long paise) {
+ long abs = Math.abs(paise);
+ return String.format(Locale.ROOT, "%sRs %d.%02d", paise < 0 ? "-" : "", abs / 100, abs % 100);
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/OptimalDebtSimplifier.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/OptimalDebtSimplifier.java
new file mode 100644
index 0000000..02d7866
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/OptimalDebtSimplifier.java
@@ -0,0 +1,68 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Finds the true minimum number of payments. A group of people whose balances add up to zero can settle among themselves
+ * with (size - 1) payments, so the minimum is (people) minus (the most zero-sum groups the people can be split into).
+ * Finding that split is a subset-sum style problem, solved here by dynamic programming over all subsets: O(2^n * n),
+ * so it is limited to {@value #MAX_PEOPLE} people with a non-zero balance.
+ */
+public final class OptimalDebtSimplifier implements DebtSimplifier {
+ public static final int MAX_PEOPLE = 20;
+
+ private final DebtSimplifier insideAGroup = new GreedyDebtSimplifier();
+
+ @Override
+ public List simplify(Map net) {
+ long total = net.values().stream().mapToLong(Long::longValue).sum();
+ if (total != 0) {
+ throw new IllegalArgumentException("balances do not add up to zero: the sum is " + Money.format(total));
+ }
+ List users = new ArrayList<>(net.keySet().stream().filter(u -> net.get(u) != 0).sorted().toList());
+ int n = users.size();
+ if (n == 0) {
+ return List.of();
+ }
+ if (n > MAX_PEOPLE) {
+ throw new IllegalArgumentException("exact search is limited to " + MAX_PEOPLE + " people, got " + n);
+ }
+ int full = (1 << n) - 1;
+ long[] sum = new long[full + 1];
+ int[] zeroGroups = new int[full + 1];
+ byte[] last = new byte[full + 1];
+ for (int mask = 1; mask <= full; mask++) {
+ int low = Integer.numberOfTrailingZeros(mask);
+ sum[mask] = sum[mask & (mask - 1)] + net.get(users.get(low));
+ int best = -1;
+ for (int i = 0; i < n; i++) {
+ if ((mask & (1 << i)) != 0 && zeroGroups[mask ^ (1 << i)] > best) {
+ best = zeroGroups[mask ^ (1 << i)];
+ last[mask] = (byte) i;
+ }
+ }
+ zeroGroups[mask] = best + (sum[mask] == 0 ? 1 : 0);
+ }
+ // Rebuild the best ordering, then cut it wherever the running total returns to zero.
+ List order = new ArrayList<>();
+ for (int mask = full; mask != 0; mask ^= 1 << last[mask]) {
+ order.add(0, (int) last[mask]);
+ }
+ List transfers = new ArrayList<>();
+ Map group = new LinkedHashMap<>();
+ long running = 0;
+ for (int i : order) {
+ String user = users.get(i);
+ group.put(user, net.get(user));
+ running += net.get(user);
+ if (running == 0) {
+ transfers.addAll(insideAGroup.simplify(group));
+ group = new LinkedHashMap<>();
+ }
+ }
+ return transfers;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/PercentSplit.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/PercentSplit.java
new file mode 100644
index 0000000..c403542
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/PercentSplit.java
@@ -0,0 +1,55 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/** Each person pays a percentage, with at most two decimal places; the percentages must add up to exactly 100. */
+public final class PercentSplit implements SplitStrategy {
+ private final Map percents;
+
+ public PercentSplit(Map percents) {
+ if (percents.isEmpty()) {
+ throw new InvalidSplitException("a percent split needs at least one participant");
+ }
+ BigDecimal sum = BigDecimal.ZERO;
+ for (Map.Entry e : percents.entrySet()) {
+ BigDecimal p = e.getValue();
+ if (p.signum() < 0) {
+ throw new InvalidSplitException("percent for " + e.getKey() + " must not be negative");
+ }
+ if (p.stripTrailingZeros().scale() > 2) {
+ throw new InvalidSplitException("percent for " + e.getKey()
+ + " has more than 2 decimal places: " + p.toPlainString());
+ }
+ sum = sum.add(p);
+ }
+ if (sum.compareTo(BigDecimal.valueOf(100)) != 0) {
+ throw new InvalidSplitException("percentages add up to " + sum.toPlainString() + " but must add up to 100");
+ }
+ this.percents = new LinkedHashMap<>(percents);
+ }
+
+ @Override
+ public Set participants() {
+ return new LinkedHashSet<>(percents.keySet());
+ }
+
+ @Override
+ public Map split(long totalPaise) {
+ String[] users = percents.keySet().toArray(new String[0]);
+ long[] basisPoints = new long[users.length];
+ for (int i = 0; i < users.length; i++) {
+ basisPoints[i] = percents.get(users[i]).setScale(2, RoundingMode.UNNECESSARY).movePointRight(2).longValueExact();
+ }
+ long[] parts = Apportion.split(totalPaise, basisPoints);
+ Map shares = new LinkedHashMap<>();
+ for (int i = 0; i < users.length; i++) {
+ shares.put(users[i], parts[i]);
+ }
+ return shares;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ShareSplit.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ShareSplit.java
new file mode 100644
index 0000000..778d92e
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/ShareSplit.java
@@ -0,0 +1,43 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/** Each person owns a number of shares ("2 nights, 1 night"); the cost is divided in proportion. */
+public final class ShareSplit implements SplitStrategy {
+ private final Map shares;
+
+ public ShareSplit(Map shares) {
+ if (shares.isEmpty()) {
+ throw new InvalidSplitException("a share split needs at least one participant");
+ }
+ shares.forEach((user, n) -> {
+ if (n <= 0) {
+ throw new InvalidSplitException("shares for " + user + " must be positive");
+ }
+ });
+ this.shares = new LinkedHashMap<>(shares);
+ }
+
+ @Override
+ public Set participants() {
+ return new LinkedHashSet<>(shares.keySet());
+ }
+
+ @Override
+ public Map split(long totalPaise) {
+ String[] users = shares.keySet().toArray(new String[0]);
+ long[] weights = new long[users.length];
+ for (int i = 0; i < users.length; i++) {
+ weights[i] = shares.get(users[i]);
+ }
+ long[] parts = Apportion.split(totalPaise, weights);
+ Map result = new LinkedHashMap<>();
+ for (int i = 0; i < users.length; i++) {
+ result.put(users[i], parts[i]);
+ }
+ return result;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitStrategy.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitStrategy.java
new file mode 100644
index 0000000..bcd0fc2
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitStrategy.java
@@ -0,0 +1,14 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.Map;
+import java.util.Set;
+
+/** One way of dividing an expense. Implementations are small immutable values, so a group can accept any of them. */
+public interface SplitStrategy {
+
+ /** Everyone who owes a share, in the order the shares are reported. */
+ Set participants();
+
+ /** Returns user id to share in paise. The shares add up to exactly {@code totalPaise}. */
+ Map split(long totalPaise);
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitwiseService.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitwiseService.java
new file mode 100644
index 0000000..6469c03
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/SplitwiseService.java
@@ -0,0 +1,43 @@
+package com.ankurm.interviewlab.splitwise;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+
+/** The front door: register people, create groups, find them again. Everything else happens on {@link Group}. */
+public final class SplitwiseService {
+ private final Map users = new LinkedHashMap<>();
+ private final Map groups = new LinkedHashMap<>();
+
+ public synchronized User registerUser(String id, String name) {
+ if (users.containsKey(id)) {
+ throw new IllegalArgumentException("user id already taken: " + id);
+ }
+ User user = new User(id, name);
+ users.put(id, user);
+ return user;
+ }
+
+ public synchronized Group createGroup(String id, String name, List memberIds) {
+ memberIds.forEach(m -> {
+ if (!users.containsKey(m)) {
+ throw new IllegalArgumentException("unknown user: " + m);
+ }
+ });
+ if (groups.containsKey(id)) {
+ throw new IllegalArgumentException("group id already taken: " + id);
+ }
+ Group group = new Group(id, name, new LinkedHashSet<>(memberIds));
+ groups.put(id, group);
+ return group;
+ }
+
+ public synchronized Group group(String id) {
+ Group group = groups.get(id);
+ if (group == null) {
+ throw new IllegalArgumentException("unknown group: " + id);
+ }
+ return group;
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Transfer.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Transfer.java
new file mode 100644
index 0000000..fd9d0ab
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/Transfer.java
@@ -0,0 +1,19 @@
+package com.ankurm.interviewlab.splitwise;
+
+/** {@code from} pays {@code to} this many paise. Used both for recorded settlements and for suggested simplified payments. */
+public record Transfer(String from, String to, long paise) {
+
+ public Transfer {
+ if (paise <= 0) {
+ throw new IllegalArgumentException("a transfer must be positive, got " + Money.format(paise));
+ }
+ if (from.equals(to)) {
+ throw new IllegalArgumentException(from + " cannot pay themselves");
+ }
+ }
+
+ @Override
+ public String toString() {
+ return from + " pays " + to + " " + Money.format(paise);
+ }
+}
diff --git a/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/User.java b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/User.java
new file mode 100644
index 0000000..5242341
--- /dev/null
+++ b/splitwise/src/main/java/com/ankurm/interviewlab/splitwise/User.java
@@ -0,0 +1,5 @@
+package com.ankurm.interviewlab.splitwise;
+
+/** A person. The id is what every other class refers to; the name is only for display. */
+public record User(String id, String name) {
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ConcurrencyTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ConcurrencyTest.java
new file mode 100644
index 0000000..3409031
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ConcurrencyTest.java
@@ -0,0 +1,109 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SplittableRandom;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConcurrencyTest {
+
+ @Test
+ void manyThreadsAddingExpensesKeepTheLedgerBalanced() throws Exception {
+ Transcript out = Transcript.start("06-concurrency.txt", "Eight threads adding expenses to one group");
+ List people = List.of("p0", "p1", "p2", "p3", "p4", "p5");
+ Group group = new Group("g", "stress", new java.util.LinkedHashSet<>(people));
+ int threads = 8;
+ int perThread = 5000;
+ CountDownLatch start = new CountDownLatch(1);
+ List workers = new ArrayList<>();
+ AtomicReference failure = new AtomicReference<>();
+ for (int t = 0; t < threads; t++) {
+ long seed = 100 + t;
+ Thread worker = new Thread(() -> {
+ try {
+ start.await();
+ SplittableRandom random = new SplittableRandom(seed);
+ for (int i = 0; i < perThread; i++) {
+ String payer = people.get(random.nextInt(people.size()));
+ List sharers = new ArrayList<>(people);
+ java.util.Collections.shuffle(sharers, new java.util.Random(random.nextLong()));
+ sharers = sharers.subList(0, 1 + random.nextInt(people.size()));
+ group.addExpense("e", payer, 1 + random.nextInt(500_000), new EqualSplit(sharers));
+ }
+ } catch (Throwable e) {
+ failure.set(e);
+ }
+ });
+ workers.add(worker);
+ worker.start();
+ }
+ start.countDown();
+ for (Thread w : workers) {
+ w.join();
+ }
+ assertEquals(null, failure.get());
+
+ List expenses = group.expenses();
+ Set ids = new HashSet<>();
+ expenses.forEach(e -> ids.add(e.id()));
+ Ledger replay = new Ledger();
+ expenses.forEach(replay::apply);
+
+ out.line("expenses added: " + expenses.size() + " (expected " + threads * perThread + ")");
+ out.line("distinct expense ids: " + ids.size() + ", highest id: " + expenses.stream().mapToLong(Expense::id).max().orElse(0));
+ out.line("net balances add up to zero: " + group.isBalanced());
+ out.line("replaying the log gives the same balances: " + replay.net().equals(Map.copyOf(group.balances())));
+ assertEquals(threads * perThread, expenses.size());
+ assertEquals(threads * perThread, ids.size());
+ assertEquals(threads * perThread, expenses.stream().mapToLong(Expense::id).max().orElse(0));
+ assertTrue(group.isBalanced());
+ assertEquals(Map.copyOf(group.balances()), Map.copyOf(replay.net()));
+ out.flush();
+ }
+
+ @Test
+ void controlAnUnsynchronisedMapLosesUpdates() throws Exception {
+ Transcript out = Transcript.start("06b-concurrency-control.txt", "Control: the same idea without a lock (timing dependent: the figure differs every run)");
+ Map unsafe = new HashMap<>();
+ int threads = 8;
+ int perThread = 200_000;
+ CountDownLatch start = new CountDownLatch(1);
+ List workers = new ArrayList<>();
+ for (int t = 0; t < threads; t++) {
+ Thread worker = new Thread(() -> {
+ try {
+ start.await();
+ for (int i = 0; i < perThread; i++) {
+ unsafe.merge("asha", 1L, Long::sum);
+ }
+ } catch (Throwable ignored) {
+ // a corrupted HashMap may throw; the point is that the total is wrong
+ }
+ });
+ workers.add(worker);
+ worker.start();
+ }
+ start.countDown();
+ for (Thread w : workers) {
+ w.join();
+ }
+ long expected = (long) threads * perThread;
+ long actual = unsafe.getOrDefault("asha", 0L);
+ out.line("expected total: " + expected);
+ out.line("actual total: " + actual);
+ out.line("updates lost: " + (expected - actual) + " (always zero or more, and usually well above zero)");
+ assertTrue(actual <= expected);
+ out.flush();
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/HappyPathTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/HappyPathTest.java
new file mode 100644
index 0000000..d3e98f6
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/HappyPathTest.java
@@ -0,0 +1,54 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Fixtures;
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class HappyPathTest {
+
+ @Test
+ void goaTripBalancesAndDebts() {
+ Group trip = Fixtures.goaTrip();
+ Transcript out = Transcript.start("01-happy-path.txt", "Four friends, five expenses, four split strategies");
+
+ out.line("Expenses (shares in paise-exact rupees)");
+ for (Expense e : trip.expenses()) {
+ out.line(Fixtures.describe(e));
+ }
+
+ // Shares that need a rounding decision: Rs 100.00 between three people.
+ assertEquals(Map.of("asha", 3334L, "bala", 3333L, "chitra", 3333L), trip.expenses().get(1).shares());
+ assertEquals(Map.of("asha", 160000L, "bala", 40000L, "chitra", 40000L, "dev", 160000L), trip.expenses().get(3).shares());
+ assertEquals(Map.of("asha", 50000L, "bala", 25000L, "chitra", 25000L), trip.expenses().get(4).shares());
+
+ Map net = trip.balances();
+ out.blank().line("Net balance per person (positive = the group owes them)").line(Fixtures.describe(net));
+ assertEquals(756666L, net.get("asha"));
+ assertEquals(-378333L, net.get("bala"));
+ assertEquals(-288333L, net.get("chitra"));
+ assertEquals(-90000L, net.get("dev"));
+ assertEquals(0L, net.values().stream().mapToLong(Long::longValue).sum());
+ assertTrue(trip.isBalanced());
+
+ List pairwise = trip.pairwiseDebts();
+ out.blank().line("Detailed debts, netted pair by pair: " + pairwise.size() + " payments");
+ pairwise.forEach(t -> out.line(" " + t));
+ assertEquals(6, pairwise.size());
+
+ List simple = trip.simplifiedDebts(new GreedyDebtSimplifier());
+ out.blank().line("Simplified debts (greedy): " + simple.size() + " payments");
+ simple.forEach(t -> out.line(" " + t));
+ assertEquals(3, simple.size());
+ assertEquals(List.of(
+ new Transfer("bala", "asha", 378333L),
+ new Transfer("chitra", "asha", 288333L),
+ new Transfer("dev", "asha", 90000L)), simple);
+ out.flush();
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/PitfallsTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/PitfallsTest.java
new file mode 100644
index 0000000..7800eb1
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/PitfallsTest.java
@@ -0,0 +1,91 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Fixtures;
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Currency;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class PitfallsTest {
+
+ @Test
+ void sixPitfalls() {
+ Transcript out = Transcript.start("07-pitfalls.txt", "Pitfalls that look fine until they are not");
+
+ // 1. A double-based percent
+ BigDecimal fromDouble = new BigDecimal(33.33);
+ out.line("1. new BigDecimal(33.33) = " + fromDouble.toPlainString());
+ out.line(" new BigDecimal(\"33.33\") = " + new BigDecimal("33.33").toPlainString());
+ InvalidSplitException e = assertThrows(InvalidSplitException.class,
+ () -> new PercentSplit(Map.of("asha", fromDouble, "bala", new BigDecimal("66.67"))));
+ out.line(" the split rejects the double-built value: " + e.getMessage());
+ assertEquals("percent for asha has more than 2 decimal places: " + fromDouble.toPlainString(), e.getMessage());
+
+ // 2. The extra paisa always lands on the same person
+ List abc = List.of("asha", "bala", "chitra");
+ long[] fixedOrder = new long[3];
+ long[] rotating = new long[3];
+ for (int i = 0; i < 3000; i++) {
+ long[] a = shares(new EqualSplit(abc).split(10000L), abc);
+ long[] b = shares(new EqualSplit(abc, i).split(10000L), abc);
+ for (int k = 0; k < 3; k++) {
+ fixedOrder[k] += a[k];
+ rotating[k] += b[k];
+ }
+ }
+ out.blank().line("2. 3000 dinners of Rs 100.00 between asha, bala and chitra");
+ out.line(" always the same order: asha " + Money.format(fixedOrder[0]) + ", bala " + Money.format(fixedOrder[1]) + ", chitra " + Money.format(fixedOrder[2]));
+ out.line(" rotating tie offset: asha " + Money.format(rotating[0]) + ", bala " + Money.format(rotating[1]) + ", chitra " + Money.format(rotating[2]));
+ assertEquals(10_002_000L, fixedOrder[0]);
+ assertEquals(9_999_000L, fixedOrder[1]);
+ assertEquals(10_000_000L, rotating[0]);
+ assertEquals(10_000_000L, rotating[1]);
+ assertEquals(10_000_000L, rotating[2]);
+
+ // 3. The payer does not have to take part in the split
+ Group g = new Group("g", "Gift", new java.util.LinkedHashSet<>(List.of("asha", "bala", "chitra")));
+ g.addExpense("Gift for chitra", "asha", Money.ofRupees("600.00"), new EqualSplit(List.of("bala", "chitra")));
+ out.blank().line("3. asha pays Rs 600.00 for a gift but is not in the split");
+ out.line(indent(Fixtures.describe(g.balances())));
+ assertEquals(60000L, g.balances().get("asha"));
+ assertEquals(-30000L, g.balances().get("chitra"));
+
+ // 4. Currencies do not all have two decimals
+ out.blank().line("4. default fraction digits: INR " + Currency.getInstance("INR").getDefaultFractionDigits()
+ + ", JPY " + Currency.getInstance("JPY").getDefaultFractionDigits()
+ + ", KWD " + Currency.getInstance("KWD").getDefaultFractionDigits());
+ assertEquals(2, Currency.getInstance("INR").getDefaultFractionDigits());
+ assertEquals(0, Currency.getInstance("JPY").getDefaultFractionDigits());
+ assertEquals(3, Currency.getInstance("KWD").getDefaultFractionDigits());
+
+ // 5. Rounding creates a tiny amount that still needs a payment
+ Group h = new Group("h", "Tiny", new java.util.LinkedHashSet<>(List.of("asha", "bala", "chitra")));
+ h.addExpense("One paisa item", "asha", 1, new EqualSplit(List.of("asha", "bala", "chitra")));
+ out.blank().line("5. an expense of Rs 0.01 split three ways");
+ out.line(indent(Fixtures.describe(h.balances())));
+ out.line(" debts: " + h.pairwiseDebts());
+ assertEquals(0L, h.balances().get("asha"));
+ assertEquals(0, h.pairwiseDebts().size());
+
+ // 6. Balances that do not add up are refused, not silently simplified
+ IllegalArgumentException bad = assertThrows(IllegalArgumentException.class,
+ () -> new GreedyDebtSimplifier().simplify(Map.of("asha", 100L, "bala", -99L)));
+ out.blank().line("6. simplifying balances that do not add up to zero: " + bad.getMessage());
+ assertEquals("balances do not add up to zero: the sum is Rs 0.01", bad.getMessage());
+ out.flush();
+ }
+
+ private static long[] shares(Map split, List order) {
+ return order.stream().mapToLong(split::get).toArray();
+ }
+
+ private static String indent(String text) {
+ return " " + text.replace("\n", "\n ");
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/RoundingTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/RoundingTest.java
new file mode 100644
index 0000000..55dfb19
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/RoundingTest.java
@@ -0,0 +1,92 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.SplittableRandom;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class RoundingTest {
+
+ @Test
+ void whyNotDoubleOrTruncation() {
+ Transcript out = Transcript.start("02-rounding.txt", "Why paise in a long, and why largest remainder");
+
+ double a = 0.1 + 0.2;
+ double tenTimes = 0;
+ for (int i = 0; i < 10; i++) {
+ tenTimes += 0.10;
+ }
+ out.line("double: 0.1 + 0.2 = " + a);
+ out.line("double: ten times 0.10 = " + tenTimes);
+ assertNotEquals(0.3, a);
+ assertNotEquals(1.0, tenTimes);
+
+ long total = Money.ofRupees("100.00");
+ long truncated = total / 3;
+ out.blank().line("long, plain division: " + total + " paise / 3 = " + truncated + " each; three of them make " + (truncated * 3) + " paise");
+ out.line("one paisa has vanished: " + (total - truncated * 3));
+ assertEquals(1, total - truncated * 3);
+
+ long[] equal = Apportion.split(total, new long[]{1, 1, 1});
+ out.blank().line("largest remainder, Rs 100.00 in 3 equal parts: " + Arrays.toString(equal) + " sum " + sum(equal));
+ assertArrayEquals(new long[]{3334, 3333, 3333}, equal);
+
+ long[] tiny = Apportion.split(10, new long[]{1, 1, 1});
+ out.line("largest remainder, 10 paise in 3 equal parts: " + Arrays.toString(tiny) + " sum " + sum(tiny));
+ assertArrayEquals(new long[]{4, 3, 3}, tiny);
+
+ long[] weighted = Apportion.split(Money.ofRupees("100.00"), new long[]{3333, 3333, 3334});
+ out.line("largest remainder, 33.33% / 33.33% / 33.34%: " + Arrays.toString(weighted) + " sum " + sum(weighted));
+ assertArrayEquals(new long[]{3333, 3333, 3334}, weighted);
+
+ long[] shares = Apportion.split(Money.ofRupees("1000.00"), new long[]{2, 1, 1});
+ out.line("largest remainder, shares 2:1:1 of Rs 1000.00: " + Arrays.toString(shares) + " sum " + sum(shares));
+ assertArrayEquals(new long[]{50000, 25000, 25000}, shares);
+
+ long[] seven = Apportion.split(Money.ofRupees("100.00"), new long[]{1, 1, 1, 1, 1, 1, 1});
+ out.line("largest remainder, Rs 100.00 in 7 equal parts: " + Arrays.toString(seven) + " sum " + sum(seven));
+ assertEquals(10000, sum(seven));
+ out.flush();
+ }
+
+ @Test
+ void sharesAlwaysAddUpAndStayWithinOnePaisaOfExact() {
+ Transcript out = Transcript.start("02b-rounding-property.txt", "Seeded property check: 200000 random divisions");
+ SplittableRandom random = new SplittableRandom(2026);
+ int trials = 200_000;
+ long worstGap = 0;
+ for (int t = 0; t < trials; t++) {
+ int n = 1 + random.nextInt(12);
+ long[] weights = new long[n];
+ long weightSum = 0;
+ for (int i = 0; i < n; i++) {
+ weights[i] = 1 + random.nextInt(10_000);
+ weightSum += weights[i];
+ }
+ long total = 1 + random.nextLong(100_000_000L);
+ long[] parts = Apportion.split(total, weights, random.nextInt(n));
+ assertEquals(total, sum(parts), "shares must add up exactly");
+ for (int i = 0; i < n; i++) {
+ long floor = Math.multiplyExact(total, weights[i]) / weightSum;
+ assertTrue(parts[i] == floor || parts[i] == floor + 1, "share outside floor/ceil of the exact quota");
+ worstGap = Math.max(worstGap, parts[i] - floor);
+ }
+ }
+ out.line("trials: " + trials);
+ out.line("every trial: shares add up to the total exactly");
+ out.line("every share: equal to the exact amount rounded down, or one paisa more");
+ out.line("largest gap above the rounded-down amount: " + worstGap + " paisa");
+ assertEquals(1, worstGap);
+ out.flush();
+ }
+
+ private static long sum(long[] values) {
+ return Arrays.stream(values).sum();
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SettleUpTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SettleUpTest.java
new file mode 100644
index 0000000..b10336d
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SettleUpTest.java
@@ -0,0 +1,77 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Fixtures;
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SettleUpTest {
+
+ @Test
+ void settlingMovesBalancesAndNeverBreaksTheInvariant() {
+ Group trip = Fixtures.goaTrip();
+ Transcript out = Transcript.start("05-settle-up.txt", "Recording real payments against the ledger");
+
+ out.line("Before settling");
+ out.line(Fixtures.describe(trip.balances()));
+
+ trip.settle("bala", "asha", 378333);
+ out.blank().line("After bala pays asha Rs 3783.33");
+ out.line(Fixtures.describe(trip.balances()));
+ assertEquals(0L, trip.balances().get("bala"));
+ assertEquals(378333L, trip.balances().get("asha"));
+ out.line("pair view after paying the net amount (asha-bala flips direction, because bala paid more than he owed asha directly):");
+ trip.pairwiseDebts().forEach(t -> out.line(" " + t));
+ assertEquals(6, trip.pairwiseDebts().size());
+ assertTrue(trip.pairwiseDebts().contains(new Transfer("asha", "bala", 56667)));
+
+ trip.settle("dev", "asha", 100000);
+ out.blank().line("After dev pays asha Rs 1000.00 (Rs 100.00 more than dev owes)");
+ out.line(Fixtures.describe(trip.balances()));
+ assertEquals(10000L, trip.balances().get("dev"));
+ assertTrue(trip.isBalanced());
+
+ out.blank().line("Now chitra and dev follow the simplified plan");
+ List plan = trip.simplifiedDebts(new OptimalDebtSimplifier());
+ plan.forEach(t -> out.line(" " + t));
+ for (Transfer t : plan) {
+ trip.settle(t.from(), t.to(), t.paise());
+ }
+ out.blank().line("After the plan");
+ out.line(Fixtures.describe(trip.balances()));
+ out.line("net balances all zero: " + trip.balances().values().stream().allMatch(v -> v == 0));
+ out.line("pair view still lists " + trip.pairwiseDebts().size() + " debts, because the plan paid net amounts, not the original pairs:");
+ trip.pairwiseDebts().forEach(t -> out.line(" " + t));
+ assertTrue(trip.balances().values().stream().allMatch(v -> v == 0));
+ assertEquals(5, trip.pairwiseDebts().size());
+ // the two views never disagree about a person's total: each pair debt nets out to the same balance
+ Map fromPairs = Fixtures.netFromPairs(trip.pairwiseDebts());
+ out.line("each person's pair debts add up to their net balance: "
+ + trip.balances().keySet().stream().allMatch(u -> fromPairs.getOrDefault(u, 0L).equals(trip.balances().get(u))));
+ trip.balances().keySet().forEach(u -> assertEquals(trip.balances().get(u), fromPairs.getOrDefault(u, 0L)));
+ out.flush();
+ }
+
+ @Test
+ void ledgerIsJustAFoldOverTheEvents() {
+ Group trip = Fixtures.goaTrip();
+ trip.settle("chitra", "asha", 100000);
+ Ledger replay = new Ledger();
+ trip.expenses().forEach(replay::apply);
+ trip.settlements().forEach(replay::apply);
+
+ Transcript out = Transcript.start("05b-replay.txt", "The ledger is derived: replaying the log rebuilds it exactly");
+ out.line("expenses replayed: " + trip.expenses().size());
+ out.line("settlements replayed: " + trip.settlements().size());
+ out.line("net balances equal: " + replay.net().equals(Map.copyOf(trip.balances())));
+ out.line("pairwise debts equal: " + replay.pairwiseDebts().equals(trip.pairwiseDebts()));
+ assertEquals(Map.copyOf(trip.balances()), Map.copyOf(replay.net()));
+ assertEquals(trip.pairwiseDebts(), replay.pairwiseDebts());
+ out.flush();
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SimplifyTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SimplifyTest.java
new file mode 100644
index 0000000..3d556cc
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/SimplifyTest.java
@@ -0,0 +1,155 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Fixtures;
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.SplittableRandom;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SimplifyTest {
+ private final DebtSimplifier greedy = new GreedyDebtSimplifier();
+ private final DebtSimplifier optimal = new OptimalDebtSimplifier();
+
+ /** Applies the payments to the balances and returns what is left over. */
+ private static Map afterPaying(Map net, List transfers) {
+ Map left = new LinkedHashMap<>(net);
+ for (Transfer t : transfers) {
+ left.merge(t.from(), t.paise(), Long::sum);
+ left.merge(t.to(), -t.paise(), Long::sum);
+ }
+ return left;
+ }
+
+ private static Map balances(Object... pairs) {
+ Map map = new LinkedHashMap<>();
+ for (int i = 0; i < pairs.length; i += 2) {
+ map.put((String) pairs[i], ((Number) pairs[i + 1]).longValue() * 100);
+ }
+ return map;
+ }
+
+ /** Independent check: the classic backtracking search, no bitmasks, for the minimum number of payments. */
+ private static int backtrack(long[] debts, int start) {
+ while (start < debts.length && debts[start] == 0) {
+ start++;
+ }
+ if (start == debts.length) {
+ return 0;
+ }
+ int best = Integer.MAX_VALUE;
+ for (int i = start + 1; i < debts.length; i++) {
+ if (debts[i] * debts[start] < 0) {
+ debts[i] += debts[start];
+ best = Math.min(best, 1 + backtrack(debts, start + 1));
+ debts[i] -= debts[start];
+ }
+ }
+ return best;
+ }
+
+ @Test
+ void tripAndTheCaseWhereGreedyIsNotMinimal() {
+ Transcript out = Transcript.start("04-simplify.txt", "Simplifying debts: pairwise vs greedy vs exact");
+
+ Group trip = Fixtures.goaTrip();
+ out.line("Goa trip: " + trip.pairwiseDebts().size() + " pairwise payments, "
+ + trip.simplifiedDebts(greedy).size() + " greedy, " + trip.simplifiedDebts(optimal).size() + " exact");
+ assertEquals(6, trip.pairwiseDebts().size());
+ assertEquals(3, trip.simplifiedDebts(greedy).size());
+ assertEquals(3, trip.simplifiedDebts(optimal).size());
+
+ Map net = balances("a", 4, "b", 3, "c", 3, "d", -4, "e", -6);
+ List g = greedy.simplify(net);
+ List o = optimal.simplify(net);
+ out.blank().line("Balances (Rs): a +4, b +3, c +3, d -4, e -6");
+ out.line("greedy: " + g.size() + " payments");
+ g.forEach(t -> out.line(" " + t));
+ out.line("exact: " + o.size() + " payments");
+ o.forEach(t -> out.line(" " + t));
+ out.line("why: {a, d} cancel exactly (+4 -4) and {b, c, e} cancel exactly (+3 +3 -6), so two separate groups need 1 + 2 = 3 payments");
+ assertEquals(4, g.size());
+ assertEquals(3, o.size());
+ assertTrue(afterPaying(net, g).values().stream().allMatch(v -> v == 0));
+ assertTrue(afterPaying(net, o).values().stream().allMatch(v -> v == 0));
+ out.flush();
+ }
+
+ @Test
+ void randomBalancesCrossCheckedAgainstBacktracking() {
+ Transcript out = Transcript.start("04b-simplify-random.txt", "1500 seeded random zero-sum balance sets, up to 9 people");
+ SplittableRandom random = new SplittableRandom(465);
+ int cases = 1500;
+ int greedyWorse = 0;
+ int largestGap = 0;
+ for (int c = 0; c < cases; c++) {
+ Map net = new LinkedHashMap<>();
+ int groups = 1 + random.nextInt(3);
+ int person = 0;
+ for (int g = 0; g < groups; g++) {
+ int size = 2 + random.nextInt(3);
+ long running = 0;
+ for (int i = 0; i < size - 1; i++) {
+ long amount = (random.nextInt(2001) - 1000) * 100L;
+ net.put("u" + person++, amount);
+ running += amount;
+ }
+ net.put("u" + person++, -running);
+ }
+ long[] debts = net.values().stream().mapToLong(Long::longValue).toArray();
+ int nonZero = (int) java.util.Arrays.stream(debts).filter(v -> v != 0).count();
+
+ List g = greedy.simplify(net);
+ List o = optimal.simplify(net);
+ assertTrue(afterPaying(net, g).values().stream().allMatch(v -> v == 0), "greedy must settle everyone");
+ assertTrue(afterPaying(net, o).values().stream().allMatch(v -> v == 0), "exact must settle everyone");
+ assertTrue(g.size() <= Math.max(nonZero - 1, 0), "greedy never needs more than n - 1");
+ assertEquals(backtrack(debts.clone(), 0), o.size(), "exact search agrees with backtracking");
+ assertTrue(o.size() <= g.size());
+ if (g.size() > o.size()) {
+ greedyWorse++;
+ largestGap = Math.max(largestGap, g.size() - o.size());
+ }
+ }
+ out.line("cases: " + cases);
+ out.line("every case: both simplifiers leave every balance at exactly zero");
+ out.line("every case: greedy uses at most (people with a balance) - 1 payments");
+ out.line("every case: the exact simplifier's count equals an independent backtracking search");
+ out.line("cases where greedy used more payments than exact: " + greedyWorse + " of " + cases);
+ out.line("largest difference: " + largestGap + " payment(s)");
+ assertTrue(greedyWorse > 0);
+ out.flush();
+ }
+
+ @Test
+ void exactSearchCostGrowsWithPeople() {
+ Transcript out = Transcript.start("04c-simplify-cost.txt", "Exact search cost (timing dependent: figures differ from run to run)");
+ SplittableRandom random = new SplittableRandom(7);
+ for (int n : new int[]{10, 14, 18, 20}) {
+ Map net = new LinkedHashMap<>();
+ long running = 0;
+ for (int i = 0; i < n - 1; i++) {
+ long amount = (1 + random.nextInt(900)) * 100L * (random.nextBoolean() ? 1 : -1);
+ net.put("u" + i, amount);
+ running += amount;
+ }
+ net.put("u" + (n - 1), -running);
+ long start = System.nanoTime();
+ List o = optimal.simplify(net);
+ long ms = (System.nanoTime() - start) / 1_000_000;
+ long gMs0 = System.nanoTime();
+ List g = greedy.simplify(net);
+ long gMicros = (System.nanoTime() - gMs0) / 1_000;
+ out.line(String.format("people %2d: exact %d payments in about %d ms, greedy %d payments in about %d microseconds",
+ n, o.size(), ms, g.size(), gMicros));
+ assertTrue(afterPaying(net, o).values().stream().allMatch(v -> v == 0));
+ }
+ assertTrue(true);
+ out.flush();
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ValidationTest.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ValidationTest.java
new file mode 100644
index 0000000..d8fa2c6
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/ValidationTest.java
@@ -0,0 +1,81 @@
+package com.ankurm.interviewlab.splitwise;
+
+import com.ankurm.interviewlab.splitwise.support.Fixtures;
+import com.ankurm.interviewlab.splitwise.support.Transcript;
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.function.Executable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ValidationTest {
+
+ private final Transcript out = Transcript.start("03-validation.txt", "Bad input is rejected before it touches the ledger");
+
+ private void rejected(String label, Class extends Throwable> type, String expectedMessage, Executable action) {
+ Throwable t = assertThrows(type, action);
+ out.line(String.format("%-34s -> %s: %s", label, t.getClass().getSimpleName(), t.getMessage()));
+ assertEquals(expectedMessage, t.getMessage());
+ }
+
+ @Test
+ void rejectsBadSplitsAndBadRequests() {
+ Group trip = Fixtures.goaTrip();
+ Map before = trip.balances();
+ int expensesBefore = trip.expenses().size();
+
+ rejected("exact amounts too small", InvalidSplitException.class,
+ "exact amounts add up to Rs 90.00 but the expense is Rs 100.00",
+ () -> trip.addExpense("Snacks", "asha", Money.ofRupees("100.00"),
+ new ExactSplit(Map.of("asha", Money.ofRupees("50.00"), "bala", Money.ofRupees("40.00")))));
+ rejected("percentages add up to 99.99", InvalidSplitException.class,
+ "percentages add up to 99.99 but must add up to 100",
+ () -> new PercentSplit(Fixtures.percents("asha", "33.33", "bala", "33.33", "chitra", "33.33")));
+ rejected("percentage with 3 decimal places", InvalidSplitException.class,
+ "percent for asha has more than 2 decimal places: 33.333",
+ () -> new PercentSplit(Fixtures.percents("asha", "33.333", "bala", "66.667")));
+ rejected("zero shares", InvalidSplitException.class,
+ "shares for bala must be positive",
+ () -> new ShareSplit(Fixtures.shares("asha", 1, "bala", 0)));
+ rejected("same person listed twice", InvalidSplitException.class,
+ "duplicate participant in [asha, asha]",
+ () -> new EqualSplit(List.of("asha", "asha")));
+ rejected("nobody to split with", InvalidSplitException.class,
+ "an equal split needs at least one participant",
+ () -> new EqualSplit(List.of()));
+ rejected("participant outside the group", IllegalArgumentException.class,
+ "esha is not a member of group Goa trip",
+ () -> trip.addExpense("Taxi", "asha", 5000, new EqualSplit(List.of("asha", "esha"))));
+ rejected("payer outside the group", IllegalArgumentException.class,
+ "esha is not a member of group Goa trip",
+ () -> trip.addExpense("Taxi", "esha", 5000, new EqualSplit(List.of("asha", "bala"))));
+ rejected("zero-rupee expense", IllegalArgumentException.class,
+ "an expense must be positive, got Rs 0.00",
+ () -> trip.addExpense("Nothing", "asha", 0, new EqualSplit(List.of("asha", "bala"))));
+ rejected("paying yourself", IllegalArgumentException.class,
+ "asha cannot pay themselves",
+ () -> trip.settle("asha", "asha", 100));
+ rejected("amount with three decimals", IllegalArgumentException.class,
+ "not a whole number of paise: 10.005",
+ () -> Money.ofRupees("10.005"));
+
+ out.blank().line("After eleven rejected requests: " + trip.expenses().size() + " expenses, balances unchanged = " + before.equals(trip.balances()));
+ assertEquals(before, trip.balances());
+ assertEquals(expensesBefore, trip.expenses().size());
+ assertTrue(trip.isBalanced());
+ out.flush();
+ }
+
+ @Test
+ void exactSplitKeepsInsertionOrder() {
+ Map amounts = new LinkedHashMap<>();
+ amounts.put("dev", 100L);
+ amounts.put("asha", 200L);
+ assertEquals(List.of("dev", "asha"), List.copyOf(new ExactSplit(amounts).split(300).keySet()));
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Fixtures.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Fixtures.java
new file mode 100644
index 0000000..0de86f5
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Fixtures.java
@@ -0,0 +1,83 @@
+package com.ankurm.interviewlab.splitwise.support;
+
+import com.ankurm.interviewlab.splitwise.EqualSplit;
+import com.ankurm.interviewlab.splitwise.ExactSplit;
+import com.ankurm.interviewlab.splitwise.Expense;
+import com.ankurm.interviewlab.splitwise.Group;
+import com.ankurm.interviewlab.splitwise.Money;
+import com.ankurm.interviewlab.splitwise.PercentSplit;
+import com.ankurm.interviewlab.splitwise.ShareSplit;
+import com.ankurm.interviewlab.splitwise.SplitwiseService;
+
+import java.math.BigDecimal;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public final class Fixtures {
+ private Fixtures() {
+ }
+
+ public static final List FRIENDS = List.of("asha", "bala", "chitra", "dev");
+
+ /** The four-friend Goa trip used throughout the article: five expenses, four different split strategies. */
+ public static Group goaTrip() {
+ SplitwiseService service = new SplitwiseService();
+ FRIENDS.forEach(id -> service.registerUser(id, id));
+ Group trip = service.createGroup("goa", "Goa trip", FRIENDS);
+
+ trip.addExpense("Hotel (equal)", "asha", Money.ofRupees("12000.00"), new EqualSplit(FRIENDS));
+ trip.addExpense("Dinner (equal, 3 people)", "bala", Money.ofRupees("100.00"), new EqualSplit(List.of("asha", "bala", "chitra")));
+ Map cab = new LinkedHashMap<>();
+ cab.put("asha", Money.ofRupees("300.00"));
+ cab.put("bala", Money.ofRupees("200.00"));
+ cab.put("chitra", Money.ofRupees("100.00"));
+ cab.put("dev", Money.ofRupees("300.00"));
+ trip.addExpense("Cab (exact)", "chitra", Money.ofRupees("900.00"), new ExactSplit(cab));
+ trip.addExpense("Scuba (percent)", "dev", Money.ofRupees("4000.00"), new PercentSplit(percents(
+ "asha", "40", "bala", "10", "chitra", "10", "dev", "40")));
+ trip.addExpense("Groceries (shares 2:1:1)", "asha", Money.ofRupees("1000.00"), new ShareSplit(shares(
+ "asha", 2, "bala", 1, "chitra", 1)));
+ return trip;
+ }
+
+ public static Map percents(String... pairs) {
+ Map map = new LinkedHashMap<>();
+ for (int i = 0; i < pairs.length; i += 2) {
+ map.put(pairs[i], new BigDecimal(pairs[i + 1]));
+ }
+ return map;
+ }
+
+ public static Map shares(Object... pairs) {
+ Map map = new LinkedHashMap<>();
+ for (int i = 0; i < pairs.length; i += 2) {
+ map.put((String) pairs[i], (Integer) pairs[i + 1]);
+ }
+ return map;
+ }
+
+ /** Each person's net balance recomputed from the pair view: payments they are owed minus payments they owe. */
+ public static Map netFromPairs(List pairs) {
+ Map net = new LinkedHashMap<>();
+ for (com.ankurm.interviewlab.splitwise.Transfer t : pairs) {
+ net.merge(t.to(), t.paise(), Long::sum);
+ net.merge(t.from(), -t.paise(), Long::sum);
+ }
+ return net;
+ }
+
+ public static String describe(Expense e) {
+ String shares = e.shares().entrySet().stream()
+ .map(en -> en.getKey() + "=" + Money.format(en.getValue()))
+ .collect(Collectors.joining(" "));
+ return String.format("#%d %-26s paid by %-7s %11s %s", e.id(), e.description(), e.paidBy(), Money.format(e.totalPaise()), shares);
+ }
+
+ public static String describe(Map balances) {
+ return balances.entrySet().stream()
+ .map(en -> String.format("%-7s %12s", en.getKey(), Money.format(en.getValue())))
+ .collect(Collectors.joining("\n"));
+ }
+}
diff --git a/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Transcript.java b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Transcript.java
new file mode 100644
index 0000000..c55c032
--- /dev/null
+++ b/splitwise/src/test/java/com/ankurm/interviewlab/splitwise/support/Transcript.java
@@ -0,0 +1,43 @@
+package com.ankurm.interviewlab.splitwise.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);
+ }
+ }
+}