Add splitwise module: equal/exact/percent/share split strategies with largest-remainder paise arithmetic, derived ledger, greedy and exact debt simplification, concurrency control (13 tests, 12 transcripts)

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_017ic4b4aCTv6BYCer55YdjZ
This commit is contained in:
Claude
2026-11-17 23:16:53 +05:30
parent c57031aaeb
commit eef175d669
42 changed files with 1772 additions and 0 deletions
@@ -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);
}
}
@@ -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<Transfer> simplify(Map<String, Long> net);
}
@@ -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<String> participants;
private final int tieOffset;
public EqualSplit(List<String> 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<String> 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<String> participants() {
return new LinkedHashSet<>(participants);
}
@Override
public Map<String, Long> split(long totalPaise) {
long[] weights = new long[participants.size()];
java.util.Arrays.fill(weights, 1);
long[] parts = Apportion.split(totalPaise, weights, tieOffset);
Map<String, Long> shares = new LinkedHashMap<>();
for (int i = 0; i < parts.length; i++) {
shares.put(participants.get(i), parts[i]);
}
return shares;
}
}
@@ -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<String, Long> amounts;
public ExactSplit(Map<String, Long> 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<String> participants() {
return new LinkedHashSet<>(amounts.keySet());
}
@Override
public Map<String, Long> 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);
}
}
@@ -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<String, Long> 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));
}
}
}
@@ -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<Balance> BIGGEST_FIRST =
Comparator.comparingLong(Balance::paise).reversed().thenComparing(Balance::user);
@Override
public List<Transfer> simplify(Map<String, Long> 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<Balance> creditors = new PriorityQueue<>(BIGGEST_FIRST);
PriorityQueue<Balance> 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<Transfer> 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;
}
}
@@ -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<String> members;
private final Ledger ledger = new Ledger();
private final List<Expense> expenses = new ArrayList<>();
private final List<Transfer> settlements = new ArrayList<>();
private long nextExpenseId = 1;
public Group(String id, String name, Set<String> 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<String, Long> 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<String, Long> balances() {
Map<String, Long> net = ledger.net();
Map<String, Long> result = new LinkedHashMap<>();
members.forEach(m -> result.put(m, net.getOrDefault(m, 0L)));
return result;
}
public synchronized List<Transfer> pairwiseDebts() {
return ledger.pairwiseDebts();
}
public synchronized List<Transfer> simplifiedDebts(DebtSimplifier simplifier) {
return simplifier.simplify(ledger.net());
}
public synchronized List<Expense> expenses() {
return List.copyOf(expenses);
}
public synchronized List<Transfer> 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);
}
}
}
@@ -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);
}
}
@@ -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<String, Long> net = new TreeMap<>();
private final Map<String, Long> 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<String, Long> 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<Transfer> pairwiseDebts() {
List<Transfer> 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;
}
}
@@ -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);
}
}
@@ -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<Transfer> simplify(Map<String, Long> 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<String> 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<Integer> order = new ArrayList<>();
for (int mask = full; mask != 0; mask ^= 1 << last[mask]) {
order.add(0, (int) last[mask]);
}
List<Transfer> transfers = new ArrayList<>();
Map<String, Long> 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;
}
}
@@ -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<String, BigDecimal> percents;
public PercentSplit(Map<String, BigDecimal> percents) {
if (percents.isEmpty()) {
throw new InvalidSplitException("a percent split needs at least one participant");
}
BigDecimal sum = BigDecimal.ZERO;
for (Map.Entry<String, BigDecimal> 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<String> participants() {
return new LinkedHashSet<>(percents.keySet());
}
@Override
public Map<String, Long> 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<String, Long> shares = new LinkedHashMap<>();
for (int i = 0; i < users.length; i++) {
shares.put(users[i], parts[i]);
}
return shares;
}
}
@@ -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<String, Integer> shares;
public ShareSplit(Map<String, Integer> 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<String> participants() {
return new LinkedHashSet<>(shares.keySet());
}
@Override
public Map<String, Long> 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<String, Long> result = new LinkedHashMap<>();
for (int i = 0; i < users.length; i++) {
result.put(users[i], parts[i]);
}
return result;
}
}
@@ -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<String> participants();
/** Returns user id to share in paise. The shares add up to exactly {@code totalPaise}. */
Map<String, Long> split(long totalPaise);
}
@@ -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<String, User> users = new LinkedHashMap<>();
private final Map<String, Group> 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<String> 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;
}
}
@@ -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);
}
}
@@ -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) {
}
@@ -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<String> 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<Thread> workers = new ArrayList<>();
AtomicReference<Throwable> 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<String> 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<Expense> expenses = group.expenses();
Set<Long> 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<String, Long> unsafe = new HashMap<>();
int threads = 8;
int perThread = 200_000;
CountDownLatch start = new CountDownLatch(1);
List<Thread> 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();
}
}
@@ -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<String, Long> 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<Transfer> 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<Transfer> 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();
}
}
@@ -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<String> 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<String, Long> split, List<String> order) {
return order.stream().mapToLong(split::get).toArray();
}
private static String indent(String text) {
return " " + text.replace("\n", "\n ");
}
}
@@ -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();
}
}
@@ -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<Transfer> 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<String, Long> 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();
}
}
@@ -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<String, Long> afterPaying(Map<String, Long> net, List<Transfer> transfers) {
Map<String, Long> 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<String, Long> balances(Object... pairs) {
Map<String, Long> 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<String, Long> net = balances("a", 4, "b", 3, "c", 3, "d", -4, "e", -6);
List<Transfer> g = greedy.simplify(net);
List<Transfer> 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<String, Long> 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<Transfer> g = greedy.simplify(net);
List<Transfer> 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<String, Long> 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<Transfer> o = optimal.simplify(net);
long ms = (System.nanoTime() - start) / 1_000_000;
long gMs0 = System.nanoTime();
List<Transfer> 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();
}
}
@@ -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<String, Long> 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<String, Long> amounts = new LinkedHashMap<>();
amounts.put("dev", 100L);
amounts.put("asha", 200L);
assertEquals(List.of("dev", "asha"), List.copyOf(new ExactSplit(amounts).split(300).keySet()));
}
}
@@ -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<String> 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<String, Long> 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<String, BigDecimal> percents(String... pairs) {
Map<String, BigDecimal> 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<String, Integer> shares(Object... pairs) {
Map<String, Integer> 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<String, Long> netFromPairs(List<com.ankurm.interviewlab.splitwise.Transfer> pairs) {
Map<String, Long> 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<String, Long> balances) {
return balances.entrySet().stream()
.map(en -> String.format("%-7s %12s", en.getKey(), Money.format(en.getValue())))
.collect(Collectors.joining("\n"));
}
}
@@ -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<String> 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);
}
}
}