Cricket scorecard from ball-by-ball data

Goal

Read an innings as a list of "batter:event" strings and produce the scorecard: team total and wickets, overs from legal balls only, each batter's runs, balls, fours, sixes and strike rate, extras and the run rate.

Why it matters

The rules are the hard part: a wide is not a ball faced, a no-ball is, and neither counts towards the over. Getting those right is exactly the "read the spec carefully" skill every data and backend job needs, on data you already understand.

What it proves

You can turn event data into aggregates with dicts, handle edge cases in the rules and avoid dividing by zero.

Steps · 7 checkpoints

Each step is one function in scorecard.py. In the workspace, press Check next to a step: it runs your file and tells you exactly what is still wrong.

1. 1Split one ball. Write parse_ball(entry): "Gill:4" becomes ("Gill", "4"), with stray spaces stripped from both parts.
2. 2Legal balls and overs. Write is_legal(event) (wides and no-balls are not legal) and finish overs(balls): count the legal balls and return "overs.balls", so 21 legal balls is "3.3" and 6 is "1.0".
3. 3Runs per ball. Write runs_for(event): the runs one ball adds to the team total. A wide or no-ball is 1 extra, a wicket is 0, anything else is the number itself.
4. 4Innings total. Finish innings_total(balls): return (runs including extras, wickets). This innings is 46/2.
5. 5One row per batter. Write batter_stats(balls): {batter: {runs, balls, 4s, 6s, out}} in batting order. A wide is not a ball faced; a no-ball is faced but scores no bat runs; W is faced and sets out to True.
6. 6Strike rate. Write strike_rate(runs, balls): runs per 100 balls, rounded to 2 decimals, and 0.0 when no balls were faced (never divide by zero).
7. 7Run rate and the scorecard. In main(), finish with the run rate (runs per 6 legal balls, 2 decimals): Run rate: 13.14. The check reads the whole scorecard your program printed.

Requirements · rubric

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

• 01Overs count legal balls only (wides and no-balls excluded)
• 02The team total includes 1 extra for each wide and no-ball
• 03Batter stats: a wide is not a ball faced, a no-ball is, W marks the batter out
• 04strike_rate() handles 0 balls without a ZeroDivisionError
• 05The printed scorecard shows not-out batters with * and ends with the run rate

Starter code

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

"""
Cricket scorecard from a ball-by-ball list.

Each entry is "batter:event". Events:
    "0".."6"  runs off the bat
    "W"       wicket (the batter is out, 0 runs)
    "wd"      wide: 1 extra run, not a legal ball, not faced by the batter
    "nb"      no-ball: 1 extra run, not a legal ball, but faced by the batter

Fill in one function per step, press Run, then press "Check step".
"""

BALLS = [
    "Rohit:1", "Gill:4", "Gill:0", "Gill:wd", "Gill:6", "Gill:1", "Rohit:0",
    "Rohit:4", "Rohit:4", "Rohit:nb", "Rohit:1", "Gill:W", "Kohli:0",
    "Kohli:2", "Kohli:1", "Rohit:6", "Rohit:0", "Rohit:1", "Kohli:4",
    "Kohli:wd", "Kohli:1", "Rohit:W", "Iyer:1", "Kohli:6",
]

EXTRAS = {"wd", "nb"}


def parse_ball(entry: str) -> tuple[str, str]:
    # TODO: "Gill:4" -> ("Gill", "4"). Strip stray spaces from both parts.
    raise NotImplementedError("step 1, parse_ball(): split one entry")


def is_legal(event: str) -> bool:
    # TODO: wides and no-balls are not legal balls; everything else is.
    raise NotImplementedError("step 2, is_legal(): does this ball count?")


def overs(balls: list[str]) -> str:
    legal = 0
    for b in balls:
        _, event = parse_ball(b)
        # TODO: add 1 to legal when is_legal(event) is True
    # TODO: return overs as "O.B"; 21 legal balls is "3.3" (3 overs, 3 balls)
    raise NotImplementedError("step 2, overs(): legal balls -> overs")


def runs_for(event: str) -> int:
    # TODO: runs this ball adds to the TEAM total:
    # "wd" / "nb" -> 1, "W" -> 0, "0".."6" -> that number
    raise NotImplementedError("step 3, runs_for(): runs one ball is worth")


def innings_total(balls: list[str]) -> tuple[int, int]:
    runs = wickets = 0
    for b in balls:
        _, event = parse_ball(b)
        runs += runs_for(event)
        # TODO: count a wicket for every "W"
    # TODO: return (total runs including extras, number of wickets)
    raise NotImplementedError("step 4, innings_total(): runs and wickets")


def batter_stats(balls: list[str]) -> dict[str, dict]:
    # TODO: {batter: {"runs", "balls", "4s", "6s", "out"}} in batting order.
    # - a wide is not a ball faced; a no-ball IS faced but scores 0 bat runs
    # - "W" is a ball faced and sets "out" to True
    # Hint: stats.setdefault(batter, {...})
    raise NotImplementedError("step 5, batter_stats(): one row per batter")


def strike_rate(runs: int, balls: int) -> float:
    # TODO: runs per 100 balls, 2 decimals; 0.0 if no balls faced.
    raise NotImplementedError("step 6, strike_rate(): runs per 100 balls")


def main() -> None:
    played = overs(BALLS)
    runs, wickets = innings_total(BALLS)
    print(f"India {runs}/{wickets} in {played} overs")
    print(f"{'Batter':<8}{'R':>4}{'B':>4}{'4s':>4}{'6s':>4}{'SR':>8}")
    for name, s in batter_stats(BALLS).items():
        mark = "" if s["out"] else "*"
        sr = strike_rate(s["runs"], s["balls"])
        print(f"{name + mark:<8}{s['runs']:>4}{s['balls']:>4}{s['4s']:>4}{s['6s']:>4}{sr:>8.2f}")
    extras = sum(1 for b in BALLS if parse_ball(b)[1] in EXTRAS)
    print(f"Extras: {extras}")
    # TODO: print the run rate (runs per 6 legal balls), 2 decimals:
    # "Run rate: 13.14"
    raise NotImplementedError("step 7, main(): print the run rate")


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.")

Reference solution

"""
Cricket scorecard from a ball-by-ball list.

Each entry is "batter:event". Events:
    "0".."6"  runs off the bat
    "W"       wicket (the batter is out, 0 runs)
    "wd"      wide: 1 extra run, not a legal ball, not faced by the batter
    "nb"      no-ball: 1 extra run, not a legal ball, but faced by the batter
"""

BALLS = [
    "Rohit:1", "Gill:4", "Gill:0", "Gill:wd", "Gill:6", "Gill:1", "Rohit:0",
    "Rohit:4", "Rohit:4", "Rohit:nb", "Rohit:1", "Gill:W", "Kohli:0",
    "Kohli:2", "Kohli:1", "Rohit:6", "Rohit:0", "Rohit:1", "Kohli:4",
    "Kohli:wd", "Kohli:1", "Rohit:W", "Iyer:1", "Kohli:6",
]

EXTRAS = {"wd", "nb"}


def parse_ball(entry: str) -> tuple[str, str]:
    batter, event = entry.split(":")
    return batter.strip(), event.strip()


def runs_for(event: str) -> int:
    if event in EXTRAS:
        return 1
    if event == "W":
        return 0
    return int(event)


def is_legal(event: str) -> bool:
    return event not in EXTRAS


def overs(balls: list[str]) -> str:
    legal = sum(is_legal(parse_ball(b)[1]) for b in balls)
    return f"{legal // 6}.{legal % 6}"


def innings_total(balls: list[str]) -> tuple[int, int]:
    runs = wickets = 0
    for b in balls:
        _, event = parse_ball(b)
        runs += runs_for(event)
        wickets += event == "W"
    return runs, wickets


def batter_stats(balls: list[str]) -> dict[str, dict]:
    stats: dict[str, dict] = {}
    for b in balls:
        batter, event = parse_ball(b)
        s = stats.setdefault(batter, {"runs": 0, "balls": 0, "4s": 0, "6s": 0, "out": False})
        if event == "wd":
            continue
        s["balls"] += 1
        if event == "W":
            s["out"] = True
        elif event != "nb":
            s["runs"] += int(event)
            s["4s"] += event == "4"
            s["6s"] += event == "6"
    return stats


def strike_rate(runs: int, balls: int) -> float:
    return round(runs * 100 / balls, 2) if balls else 0.0


def main() -> None:
    played = overs(BALLS)
    runs, wickets = innings_total(BALLS)
    print(f"India {runs}/{wickets} in {played} overs")
    print(f"{'Batter':<8}{'R':>4}{'B':>4}{'4s':>4}{'6s':>4}{'SR':>8}")
    for name, s in batter_stats(BALLS).items():
        mark = "" if s["out"] else "*"
        sr = strike_rate(s["runs"], s["balls"])
        print(f"{name + mark:<8}{s['runs']:>4}{s['balls']:>4}{s['4s']:>4}{s['6s']:>4}{sr:>8.2f}")
    extras = sum(1 for b in BALLS if parse_ball(b)[1] in EXTRAS)
    print(f"Extras: {extras}")
    legal = sum(is_legal(parse_ball(b)[1]) for b in BALLS)
    print(f"Run rate: {runs / (legal / 6):.2f}")


if __name__ == "__main__":
    main()