Split the trip bill fairly

Goal

Take a list of trip expenses and the friends who went, work out each person's fair share and balance, then print the payments that make everyone square.

Why it matters

Splitting a bill is a real problem with real edge cases: someone who paid nothing, shares that don't divide evenly, and turning balances into actual payments. Six small functions, each checked on its own.

What it proves

You can model real data with tuples and dicts, keep money to 2 decimals and turn a messy situation into a clear plan.

Steps · 6 checkpoints

Each step is one function in trip_split.py. In the workspace, press Check next to a step: it runs your file and tells you exactly what is still wrong. Step 1 is free; the rest are part of Pro or your 7-day free trial.

1. 1Add up the trip. Write total_spent(expenses): return the sum of every expense's amount (the third item of each tuple). This trip comes to 31,400.
2. 2Everyone's fair share. Write fair_share(expenses, friends): the total divided by the number of friends, rounded to 2 decimals. Here that is 7850.0. ₹100 between three friends is 33.33.
3. 3Who paid how much. Write paid_by(expenses, friends): a dict of each friend's name to the total they paid. Aarav paid for the hotel and the petrol, 16,200. A friend who paid for nothing must still be in the dict with 0.
4. 4Balances. Write balances(expenses, friends): each friend's paid amount minus the fair share, rounded to 2 decimals. Aarav is owed 8,350 (positive) and Kabir owes 3,600 (negative). The balances always add up to about zero.
5. 5Settle up. Write settle(balance): return a list of (payer, receiver, amount) tuples that brings everyone to zero. The person who owes most pays the person owed most, as much as one of them needs; whoever reaches zero drops out; repeat. For this trip: Kabir pays Aarav 3,600, Diya pays Aarav 2,900, Meera pays Aarav 1,850.
6. 6Print the plan. In main(), print one line per payment (Kabir pays Aarav ₹3,600) and finish with Everyone is square after 3 payments. The check reads everything your program printed.

Requirements · rubric

Build against this exact list — it is the spec your published project is judged on.

• 01total_spent() and fair_share() work for any expenses and any group size
• 02paid_by() includes friends who paid nothing, at 0
• 03balances() add up to zero and are rounded to 2 decimals
• 04settle() returns payments that bring every balance to zero, at most one fewer than the number of people
• 05The printed plan has one line per payment and a final summary line

Starter code

Copy this into a new file — or open it in a workspace as trip_split.py. The TODO parts are yours to fill.

"""
Trip bill splitter.

Works out what every friend owes after a trip and prints the payments
that settle it. Fill in one function per step, press Run, then press
"Check" on that step in the Checkpoints panel.
"""

FRIENDS = ["Aarav", "Diya", "Kabir", "Meera"]

# (who paid, what for, amount in ₹)
EXPENSES = [
    ("Aarav", "Hotel", 14400),
    ("Diya", "Scooters", 3600),
    ("Kabir", "Dinner at the shack", 4250),
    ("Aarav", "Petrol", 1800),
    ("Meera", "Cruise tickets", 6000),
    ("Diya", "Breakfast", 1350),
]


def total_spent(expenses: list[tuple[str, str, int]]) -> int:
    # TODO: add up the amount (the third item) of every expense.
    raise NotImplementedError("step 1, total_spent(): add up every expense")


def fair_share(expenses: list[tuple[str, str, int]], friends: list[str]) -> float:
    # TODO: the total divided by the number of friends, rounded to 2 decimals.
    raise NotImplementedError("step 2, fair_share(): total divided by the number of friends")


def paid_by(expenses: list[tuple[str, str, int]], friends: list[str]) -> dict[str, int]:
    # TODO: a dict of name -> how much that friend paid in total.
    # Every friend must be in it, even someone who paid nothing (0).
    raise NotImplementedError("step 3, paid_by(): how much each friend paid")


def balances(expenses: list[tuple[str, str, int]], friends: list[str]) -> dict[str, float]:
    # TODO: name -> what they paid minus the fair share, rounded to 2 decimals.
    # Positive: the group owes them. Negative: they owe the group.
    raise NotImplementedError("step 4, balances(): paid minus fair share")


def settle(balance: dict[str, float]) -> list[tuple[str, str, float]]:
    # TODO: return a list of (payer, receiver, amount) that makes everyone 0.
    # One way: the person who owes most pays the person owed most, as much
    # as one of them needs; whoever reaches 0 drops out; repeat.
    raise NotImplementedError("step 5, settle(): the payments that make everyone square")


def main() -> None:
    total = total_spent(EXPENSES)
    print(f"Trip total ₹{total:,} → ₹{fair_share(EXPENSES, FRIENDS):,.0f} each")
    print("Paid: " + ", ".join(f"{n} ₹{a:,}" for n, a in paid_by(EXPENSES, FRIENDS).items()))
    plan = settle(balances(EXPENSES, FRIENDS))
    # TODO: print one line per payment, like "Kabir pays Aarav ₹3,600",
    # then "Everyone is square after 3 payments".
    raise NotImplementedError("step 6, main(): print the payment plan")


if __name__ == "__main__":
    try:
        main()
    except NotImplementedError as todo:
        # A fresh starter is SUPPOSED to stop here. Say which step is next
        # instead of printing a traceback that looks like a bug.
        print(f"Not built yet: {todo}")
        print("Write that function, then press Run again. Each step you finish moves this message forward.")