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 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); + } + } +}