Low-level design: live cricket scorecard

Python 3.14 · main.py

LOG = [
    ". 1 wd 4 nb4 2 1 .",
    "W 1 6 . 2 1",
    "4 1 1",
]  # the overs, as the umpire called them


class Card:
    def __init__(self, batters: list[str]) -> None:
        self.striker, self.other, *self.next_in = batters
        self.runs = self.wickets = self.balls = 0

    def deliver(self, token: str) -> None:
        kind = token.rstrip("0123456789")
        runs = int(token[len(kind) :] or 0)
        if kind in ("wd", "nb"):  # a penalty run, and not a ball of the over
            self.runs += 1
        else:
            self.balls += 1
        self.runs += runs
        if kind == "W":
            self.wickets += 1
            self.striker = self.next_in.pop(0)  # the new batter takes strike
        if runs % 2 == 1:  # odd runs change ends
            self.swap()

    def swap(self) -> None:
        self.striker, self.other = self.other, self.striker

    def overs(self) -> str:  # 2.3 is 2 overs and 3 balls, never a decimal
        return f"{self.balls // 6}.{self.balls % 6}"


card = Card(["aditi", "bilal", "chen"])
for number, over in enumerate(LOG, start=1):
    if number > 1:  # each over is bowled from the other end
        card.swap()
    for token in over.split():
        card.deliver(token)
    score = f"{card.runs}/{card.wickets} in {card.overs()} overs"
    print(f"over {number}: {score}, {card.striker} on strike")
rate, wrong = card.runs * 6 / card.balls, card.runs / float(card.overs())
print(f"rate {rate:.2f} from {card.balls} balls, not {wrong:.2f}")

In Python: rstrip with a string of digits splits a token such as nb4 into its kind and its runs, and the two batters change ends in one tuple assignment.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

const LOG = [". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"]; // the overs, as the umpire called them

class Card {
  runs = 0;
  wickets = 0;
  balls = 0;

  constructor([striker, other, ...nextIn]) {
    Object.assign(this, { striker, other, nextIn });
  }

  deliver(token) {
    const kind = token.replace(/\d+$/, "");
    const runs = Number(token.slice(kind.length) || 0);
    if (kind === "wd" || kind === "nb")
      this.runs += 1; // a penalty run, and not a ball of the over
    else this.balls += 1;
    this.runs += runs;
    if (kind === "W") {
      this.wickets += 1;
      this.striker = this.nextIn.shift(); // the new batter takes strike
    }
    if (runs % 2 === 1) this.swap(); // odd runs change ends
  }

  swap() {
    [this.striker, this.other] = [this.other, this.striker];
  }

  overs() {
    return `${Math.floor(this.balls / 6)}.${this.balls % 6}`; // 2 overs and 3 balls, not a decimal
  }
}

const card = new Card(["aditi", "bilal", "chen"]);
LOG.forEach((over, i) => {
  if (i > 0) card.swap(); // each over is bowled from the other end
  for (const token of over.split(" ")) card.deliver(token);
  const score = `${card.runs}/${card.wickets} in ${card.overs()} overs`;
  console.log(`over ${i + 1}: ${score}, ${card.striker} on strike`);
});
const rate = (card.runs * 6) / card.balls;
const wrong = card.runs / Number(card.overs());
console.log(`rate ${rate.toFixed(2)} from ${card.balls} balls, not ${wrong.toFixed(2)}`);

In JavaScript: A regular expression strips a token's trailing digits, and destructuring in the constructor keeps the first two batters and the rest, the batters still to come.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.ArrayDeque;
import java.util.List;
import java.util.Locale;

public class Main {
  // The overs, as the umpire called them.
  static final List<String> LOG = List.of(". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1");

  static class Card {
    String striker;
    String other;
    final ArrayDeque<String> nextIn;
    int runs;
    int wickets;
    int balls;

    Card(String striker, String other, List<String> nextIn) {
      this.striker = striker;
      this.other = other;
      this.nextIn = new ArrayDeque<>(nextIn);
    }

    void deliver(String token) {
      String kind = token.replaceAll("\\d+$", "");
      int scored = kind.equals(token) ? 0 : Integer.parseInt(token.substring(kind.length()));
      if (kind.equals("wd") || kind.equals("nb")) { // a penalty run, and not a ball of the over
        runs++;
      } else {
        balls++;
      }
      runs += scored;
      if (kind.equals("W")) {
        wickets++;
        striker = nextIn.poll(); // the new batter takes strike
      }
      if (scored % 2 == 1) { // odd runs change ends
        swap();
      }
    }

    void swap() {
      String s = striker;
      striker = other;
      other = s;
    }

    String overs() {
      return balls / 6 + "." + balls % 6; // 2 overs and 3 balls, never a decimal
    }
  }

  public static void main(String[] args) {
    Locale.setDefault(Locale.ROOT);
    Card card = new Card("aditi", "bilal", List.of("chen"));
    for (int i = 0; i < LOG.size(); i++) {
      if (i > 0) { // each over is bowled from the other end
        card.swap();
      }
      for (String token : LOG.get(i).split(" ")) {
        card.deliver(token);
      }
      String score = card.runs + "/" + card.wickets + " in " + card.overs() + " overs";
      System.out.printf("over %d: %s, %s on strike%n", i + 1, score, card.striker);
    }
    double rate = card.runs * 6.0 / card.balls;
    double wrong = card.runs / Double.parseDouble(card.overs());
    System.out.printf("rate %.2f from %d balls, not %.2f%n", rate, card.balls, wrong);
  }
}

In Java: printf follows the default locale, so main sets Locale.ROOT first, and Double.parseDouble reads 2.3 the same way in every locale.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <array>
#include <deque>
#include <print>
#include <sstream>
#include <string>
#include <utility>

// The overs, as the umpire called them.
constexpr std::array<const char *, 3> innings{". 1 wd 4 nb4 2 1 .",
                                              "W 1 6 . 2 1", "4 1 1"};

struct Card {
  std::string striker, other;
  std::deque<std::string> nextIn;
  int runs = 0, wickets = 0, balls = 0;

  void deliver(const std::string &token) {
    const auto at = token.find_first_of("0123456789");
    const std::string kind = token.substr(0, at);
    const int scored =
        at == std::string::npos ? 0 : std::stoi(token.substr(at));
    if (kind == "wd" || kind == "nb") {
      ++runs; // a penalty run, and not a ball of the over
    } else {
      ++balls;
    }
    runs += scored;
    if (kind == "W") {
      ++wickets;
      striker = nextIn.front(); // the new batter takes strike
      nextIn.pop_front();
    }
    if (scored % 2 == 1) { // odd runs change ends
      std::swap(striker, other);
    }
  }

  std::string overs() const { // 2 overs and 3 balls, never a decimal
    return std::to_string(balls / 6) + "." + std::to_string(balls % 6);
  }
};

int main() {
  Card card{"aditi", "bilal", {"chen"}};
  for (std::size_t i = 0; i < innings.size(); ++i) {
    if (i > 0) { // each over is bowled from the other end
      std::swap(card.striker, card.other);
    }
    std::istringstream tokens(innings[i]);
    for (std::string token; tokens >> token;) {
      card.deliver(token);
    }
    std::println("over {}: {}/{} in {} overs, {} on strike", i + 1, card.runs,
                 card.wickets, card.overs(), card.striker);
  }
  const double rate = card.runs * 6.0 / card.balls;
  const double wrong = card.runs / std::stod(card.overs());
  std::println("rate {:.2f} from {} balls, not {:.2f}", rate, card.balls,
               wrong);
}

In C++: std::println formats 12.00 without a locale, and the log is named innings, because log would clash with the math function of that name.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

// The overs, as the umpire called them.
string[] log = [". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"];
var card = new Card("aditi", "bilal", ["chen"]);
for (int i = 0; i < log.Length; i++)
{
    if (i > 0)
    {
        card.Swap(); // each over is bowled from the other end
    }
    foreach (string token in log[i].Split(' '))
    {
        card.Deliver(token);
    }
    string score = $"{card.Runs}/{card.Wickets} in {card.Overs()} overs";
    Console.WriteLine($"over {i + 1}: {score}, {card.Striker} on strike");
}
double rate = card.Runs * 6.0 / card.Balls;
double wrong = card.Runs / double.Parse(card.Overs(), CultureInfo.InvariantCulture);
Console.WriteLine(FormattableString.Invariant(
    $"rate {rate:F2} from {card.Balls} balls, not {wrong:F2}"));

class Card(string striker, string other, IEnumerable<string> nextIn)
{
    readonly Queue<string> next = new(nextIn);
    string other = other;
    public string Striker { get; private set; } = striker;
    public int Runs { get; private set; }
    public int Wickets { get; private set; }
    public int Balls { get; private set; }

    public void Deliver(string token)
    {
        string kind = token.TrimEnd("0123456789".ToCharArray());
        string digits = token[kind.Length..];
        int runs = digits == "" ? 0 : int.Parse(digits, CultureInfo.InvariantCulture);
        if (kind is "wd" or "nb")
        {
            Runs++; // a penalty run, and not a ball of the over
        }
        else
        {
            Balls++;
        }
        Runs += runs;
        if (kind == "W")
        {
            Wickets++;
            Striker = next.Dequeue(); // the new batter takes strike
        }
        if (runs % 2 == 1)
        {
            Swap(); // odd runs change ends
        }
    }

    public void Swap() => (Striker, other) = (other, Striker);

    public string Overs() => $"{Balls / 6}.{Balls % 6}"; // 2 overs and 3 balls, never a decimal
}

In C#: double.Parse and the interpolated text use the invariant culture, so 2.3 is never read as 23 or 12.00 printed as 12,00 where the decimal sign is a comma.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// The overs, as the umpire called them.
static const char *const LOG[] = {". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"};

typedef struct {
  const char *striker, *other, *next_in;
  int runs, wickets, balls;
} Card;

static void swap_ends(Card *card) {
  const char *s = card->striker;
  card->striker = card->other;
  card->other = s;
}

static void deliver(Card *card, const char *token) {
  size_t len = strcspn(token, "0123456789"); // the letters before the runs
  int runs = atoi(token + len);
  if (len == 2 &&
      (strncmp(token, "wd", 2) == 0 || strncmp(token, "nb", 2) == 0)) {
    card->runs++; // a penalty run, and not a ball of the over
  } else {
    card->balls++;
  }
  card->runs += runs;
  if (strcmp(token, "W") == 0) {
    card->wickets++;
    card->striker = card->next_in; // the new batter takes strike
  }
  if (runs % 2 == 1) { // odd runs change ends
    swap_ends(card);
  }
}

int main(void) {
  Card card = {.striker = "aditi", .other = "bilal", .next_in = "chen"};
  for (size_t i = 0; i < sizeof LOG / sizeof LOG[0]; i++) {
    if (i > 0) { // each over is bowled from the other end
      swap_ends(&card);
    }
    char over[32];
    snprintf(over, sizeof over, "%s", LOG[i]);
    for (char *token = strtok(over, " "); token; token = strtok(NULL, " ")) {
      deliver(&card, token);
    }
    // 2.3 is 2 overs and 3 balls, never a decimal
    printf("over %zu: %d/%d in %d.%d overs, %s on strike\n", i + 1, card.runs,
           card.wickets, card.balls / 6, card.balls % 6, card.striker);
  }
  double rate = card.runs * 6.0 / card.balls;
  double wrong = card.runs / (card.balls / 6 + card.balls % 6 / 10.0);
  printf("rate %.2f from %d balls, not %.2f\n", rate, card.balls, wrong);
  return 0;
}

In C: strtok walks a copy of each over, and the wrong rate divides by the overs plus the balls over ten instead of parsing text; printf runs in the C locale.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

const LOG = ['. 1 wd 4 nb4 2 1 .', 'W 1 6 . 2 1', '4 1 1']; // the overs, as the umpire called them

final class Card
{
    public int $runs = 0;
    public int $wickets = 0;
    public int $balls = 0;

    /** @param list<string> $nextIn */
    public function __construct(
        public string $striker,
        private string $other,
        private array $nextIn,
    ) {}

    public function deliver(string $token): void
    {
        $kind = rtrim($token, '0123456789');
        $runs = (int) substr($token, strlen($kind));
        if ($kind === 'wd' || $kind === 'nb') {
            $this->runs++; // a penalty run, and not a ball of the over
        } else {
            $this->balls++;
        }
        $this->runs += $runs;
        if ($kind === 'W') {
            $this->wickets++;
            $this->striker = array_shift($this->nextIn); // the new batter takes strike
        }
        if ($runs % 2 === 1) { // odd runs change ends
            $this->swap();
        }
    }

    public function swap(): void
    {
        [$this->striker, $this->other] = [$this->other, $this->striker];
    }

    public function overs(): string // 2 overs and 3 balls, never a decimal
    {
        return intdiv($this->balls, 6) . '.' . $this->balls % 6;
    }
}

$card = new Card('aditi', 'bilal', ['chen']);
foreach (LOG as $i => $over) {
    if ($i > 0) {
        $card->swap(); // each over is bowled from the other end
    }
    foreach (explode(' ', $over) as $token) {
        $card->deliver($token);
    }
    $score = "{$card->runs}/{$card->wickets} in {$card->overs()} overs";
    echo 'over ', $i + 1, ": $score, {$card->striker} on strike\n";
}
$rate = $card->runs * 6 / $card->balls;
$wrong = $card->runs / (float) $card->overs();
printf("rate %.2F from %d balls, not %.2F\n", $rate, $card->balls, $wrong);

In PHP: %.2F, with a capital F, formats without the locale, where %.2f would follow it, and rtrim with a list of digits splits a token into its kind and its runs.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

const LOG: [&str; 3] = [". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"]; // the overs, as called

struct Card {
    striker: &'static str,
    other: &'static str,
    next_in: Vec<&'static str>,
    runs: u32,
    wickets: u32,
    balls: u32,
}

impl Card {
    fn deliver(&mut self, token: &str) {
        let kind = token.trim_end_matches(|c: char| c.is_ascii_digit());
        let runs: u32 = token[kind.len()..].parse().unwrap_or(0);
        if kind == "wd" || kind == "nb" {
            self.runs += 1; // a penalty run, and not a ball of the over
        } else {
            self.balls += 1;
        }
        self.runs += runs;
        if kind == "W" {
            self.wickets += 1;
            self.striker = self.next_in.remove(0); // the new batter takes strike
        }
        if runs % 2 == 1 {
            self.swap(); // odd runs change ends
        }
    }

    fn swap(&mut self) {
        std::mem::swap(&mut self.striker, &mut self.other);
    }

    fn overs(&self) -> String {
        format!("{}.{}", self.balls / 6, self.balls % 6) // 2 overs and 3 balls, not a decimal
    }
}

fn main() {
    let (striker, other, next_in) = ("aditi", "bilal", vec!["chen"]);
    let mut card = Card {
        striker,
        other,
        next_in,
        runs: 0,
        wickets: 0,
        balls: 0,
    };
    for (i, over) in LOG.iter().enumerate() {
        if i > 0 {
            card.swap(); // each over is bowled from the other end
        }
        over.split(' ').for_each(|token| card.deliver(token));
        let score = format!("{}/{} in {} overs", card.runs, card.wickets, card.overs());
        println!("over {}: {score}, {} on strike", i + 1, card.striker);
    }
    let rate = f64::from(card.runs) * 6.0 / f64::from(card.balls);
    let wrong = f64::from(card.runs) / card.overs().parse::<f64>().unwrap_or(1.0);
    println!("rate {rate:.2} from {} balls, not {wrong:.2}", card.balls);
}

In Rust: trim_end_matches with a closure splits the token, the runs are a u32, which cannot be negative, and f64::from converts them without a lossy cast.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

const LOG = [". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"]; // the overs, as the umpire called them

class Card {
  runs = 0;
  wickets = 0;
  balls = 0;
  striker: string;
  other: string;
  readonly nextIn: string[];

  constructor([striker, other, ...nextIn]: string[]) {
    this.striker = striker;
    this.other = other;
    this.nextIn = nextIn;
  }

  deliver(token: string): void {
    const kind = token.replace(/\d+$/, "");
    const runs = Number(token.slice(kind.length) || 0);
    if (kind === "wd" || kind === "nb")
      this.runs += 1; // a penalty run, and not a ball of the over
    else this.balls += 1;
    this.runs += runs;
    if (kind === "W") {
      this.wickets += 1;
      this.striker = this.nextIn.shift() ?? "nobody"; // the new batter takes strike
    }
    if (runs % 2 === 1) this.swap(); // odd runs change ends
  }

  swap(): void {
    [this.striker, this.other] = [this.other, this.striker];
  }

  overs(): string {
    return `${Math.floor(this.balls / 6)}.${this.balls % 6}`; // 2 overs and 3 balls, not a decimal
  }
}

const card = new Card(["aditi", "bilal", "chen"]);
LOG.forEach((over, i) => {
  if (i > 0) card.swap(); // each over is bowled from the other end
  for (const token of over.split(" ")) card.deliver(token);
  const score = `${card.runs}/${card.wickets} in ${card.overs()} overs`;
  console.log(`over ${i + 1}: ${score}, ${card.striker} on strike`);
});
const rate = (card.runs * 6) / card.balls;
const wrong = card.runs / Number(card.overs());
console.log(`rate ${rate.toFixed(2)} from ${card.balls} balls, not ${wrong.toFixed(2)}`);

In TypeScript: shift() returns undefined once no batter is left, so ?? names one, and the compiler would refuse a striker of type string | undefined.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strconv"
	"strings"
)

var innings = []string{". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"} // the overs, as called

type Card struct {
	striker, other       string
	nextIn               []string
	runs, wickets, balls int
}

func (c *Card) Deliver(token string) {
	kind := strings.TrimRight(token, "0123456789")
	runs, _ := strconv.Atoi(token[len(kind):])
	if kind == "wd" || kind == "nb" {
		c.runs++ // a penalty run, and not a ball of the over
	} else {
		c.balls++
	}
	c.runs += runs
	if kind == "W" {
		c.wickets++
		c.striker, c.nextIn = c.nextIn[0], c.nextIn[1:] // the new batter takes strike
	}
	if runs%2 == 1 { // odd runs change ends
		c.Swap()
	}
}

func (c *Card) Swap() { c.striker, c.other = c.other, c.striker }

func (c *Card) Overs() string { // 2 overs and 3 balls, never a decimal
	return fmt.Sprintf("%d.%d", c.balls/6, c.balls%6)
}

func main() {
	card := &Card{striker: "aditi", other: "bilal", nextIn: []string{"chen"}}
	for i, over := range innings {
		if i > 0 { // each over is bowled from the other end
			card.Swap()
		}
		for _, token := range strings.Fields(over) {
			card.Deliver(token)
		}
		score := fmt.Sprintf("%d/%d in %s overs", card.runs, card.wickets, card.Overs())
		fmt.Printf("over %d: %s, %s on strike\n", i+1, score, card.striker)
	}
	rate := float64(card.runs) * 6 / float64(card.balls)
	overs, _ := strconv.ParseFloat(card.Overs(), 64)
	fmt.Printf("rate %.2f from %d balls, not %.2f\n", rate, card.balls, float64(card.runs)/overs)
}

In Go: strings.TrimRight cuts the trailing digits, and Atoi of an empty string fails, so the ignored error leaves the runs of a token such as wd at 0.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

let log = [". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1"]  // the overs, as the umpire called them

/// Two decimals, without Foundation's formatting.
func twoDecimals(_ x: Double) -> String {
  let cents = Int((x * 100).rounded())
  return "\(cents / 100)." + (cents % 100 < 10 ? "0" : "") + "\(cents % 100)"
}

struct Card {
  var striker: String, other: String
  var nextIn: [String]
  var runs = 0, wickets = 0, balls = 0

  mutating func deliver(_ token: Substring) {
    let kind = String(token.prefix { !$0.isNumber })
    let runs = Int(token.dropFirst(kind.count)) ?? 0
    if kind == "wd" || kind == "nb" {
      self.runs += 1  // a penalty run, and not a ball of the over
    } else {
      balls += 1
    }
    self.runs += runs
    if kind == "W" {
      wickets += 1
      striker = nextIn.removeFirst()  // the new batter takes strike
    }
    if runs % 2 == 1 {  // odd runs change ends
      swapEnds()
    }
  }

  mutating func swapEnds() { (striker, other) = (other, striker) }

  var overs: String { "\(balls / 6).\(balls % 6)" }  // 2 overs and 3 balls, never a decimal
}

var card = Card(striker: "aditi", other: "bilal", nextIn: ["chen"])
for (i, over) in log.enumerated() {
  if i > 0 {  // each over is bowled from the other end
    card.swapEnds()
  }
  for token in over.split(separator: " ") {
    card.deliver(token)
  }
  let score = "\(card.runs)/\(card.wickets) in \(card.overs) overs"
  print("over \(i + 1): \(score), \(card.striker) on strike")
}
let rate = Double(card.runs) * 6 / Double(card.balls)
let wrong = Double(card.runs) / (Double(card.overs) ?? 1)
print("rate \(twoDecimals(rate)) from \(card.balls) balls, not \(twoDecimals(wrong))")

In Swift: There is no String(format:) without Foundation, so twoDecimals rounds to cents and pads. The batters change ends with a tuple assignment, because swap on two properties of the global card is two overlapping accesses to card.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

LOG = ['. 1 wd 4 nb4 2 1 .', 'W 1 6 . 2 1', '4 1 1'].freeze # the overs, as the umpire called them

# The scorecard, folded from the deliveries one at a time.
class Card
  attr_reader :runs, :wickets, :balls, :striker

  def initialize(striker, other, next_in)
    @striker = striker
    @other = other
    @next_in = next_in
    @runs = @wickets = @balls = 0
  end

  def deliver(token)
    kind = token.sub(/\d+\z/, '')
    runs = token.delete_prefix(kind).to_i
    if %w[wd nb].include?(kind) # a penalty run, and not a ball of the over
      @runs += 1
    else
      @balls += 1
    end
    @runs += runs
    new_batter if kind == 'W'
    swap if runs.odd? # odd runs change ends
  end

  def swap
    @striker, @other = @other, @striker
  end

  # 2.3 is 2 overs and 3 balls, never a decimal.
  def overs = "#{@balls / 6}.#{@balls % 6}"

  private

  def new_batter
    @wickets += 1
    @striker = @next_in.shift # the new batter takes strike
  end
end

card = Card.new('aditi', 'bilal', ['chen'])
LOG.each_with_index do |over, i|
  card.swap if i.positive? # each over is bowled from the other end
  over.split.each { |token| card.deliver(token) }
  score = "#{card.runs}/#{card.wickets} in #{card.overs} overs"
  puts "over #{i + 1}: #{score}, #{card.striker} on strike"
end
rate = card.runs * 6.0 / card.balls
wrong = card.runs / Float(card.overs)
puts format('rate %<rate>.2f from %<balls>d balls, not %<wrong>.2f',
            rate:, balls: card.balls, wrong:)

In Ruby: delete_prefix and to_i give 0 runs for a token without digits, and Kernel#format with named references prints the two decimals.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

import kotlin.math.roundToInt

val log = listOf(". 1 wd 4 nb4 2 1 .", "W 1 6 . 2 1", "4 1 1") // the overs, as called

/** Two decimals: String.format exists only on the JVM. */
fun twoDecimals(x: Double): String {
    val cents = (x * 100).roundToInt()
    return "${cents / 100}." + (cents % 100).toString().padStart(2, '0')
}

class Card(
    var striker: String,
    private var other: String,
    private val nextIn: ArrayDeque<String>,
) {
    var runs = 0
    var wickets = 0
    var balls = 0

    fun deliver(token: String) {
        val kind = token.trimEnd { it.isDigit() }
        val scored = token.removePrefix(kind).toIntOrNull() ?: 0
        if (kind == "wd" || kind == "nb") runs++ else balls++ // a penalty run, not a ball
        runs += scored
        if (kind == "W") {
            wickets++
            striker = nextIn.removeFirst() // the new batter takes strike
        }
        if (scored % 2 == 1) swap() // odd runs change ends
    }

    fun swap() {
        striker = other.also { other = striker }
    }

    fun overs() = "${balls / 6}.${balls % 6}" // 2 overs and 3 balls, never a decimal
}

fun main() {
    val card = Card("aditi", "bilal", ArrayDeque(listOf("chen")))
    log.forEachIndexed { i, over ->
        if (i > 0) card.swap() // each over is bowled from the other end
        over.split(" ").forEach(card::deliver)
        val score = "${card.runs}/${card.wickets} in ${card.overs()} overs"
        println("over ${i + 1}: $score, ${card.striker} on strike")
    }
    val rate = card.runs * 6.0 / card.balls
    val wrong = card.runs / card.overs().toDouble()
    println("rate ${twoDecimals(rate)} from ${card.balls} balls, not ${twoDecimals(wrong)}")
}

In Kotlin: String.format exists only on the JVM, so twoDecimals rounds to cents and pads with padStart, and also swaps the two batters in one expression.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

const log = [
  '. 1 wd 4 nb4 2 1 .',
  'W 1 6 . 2 1',
  '4 1 1',
]; // the overs, as called

class Card {
  Card(this.striker, this._other, this._nextIn);

  String striker;
  String _other;
  final List<String> _nextIn;
  var runs = 0, wickets = 0, balls = 0;

  void deliver(String token) {
    final kind = token.replaceAll(RegExp(r'\d+$'), '');
    final scored = int.tryParse(token.substring(kind.length)) ?? 0;
    if (kind == 'wd' || kind == 'nb') {
      runs++; // a penalty run, and not a ball of the over
    } else {
      balls++;
    }
    runs += scored;
    if (kind == 'W') {
      wickets++;
      striker = _nextIn.removeAt(0); // the new batter takes strike
    }
    if (scored.isOdd) swap(); // odd runs change ends
  }

  void swap() {
    final s = striker;
    striker = _other;
    _other = s;
  }

  String get overs =>
      '${balls ~/ 6}.${balls % 6}'; // 2 overs and 3 balls, not a decimal
}

void main() {
  final card = Card('aditi', 'bilal', ['chen']);
  for (final (i, over) in log.indexed) {
    if (i > 0) card.swap(); // each over is bowled from the other end
    over.split(' ').forEach(card.deliver);
    final score = '${card.runs}/${card.wickets} in ${card.overs} overs';
    print('over ${i + 1}: $score, ${card.striker} on strike');
  }
  final rate = card.runs * 6 / card.balls;
  final wrong = card.runs / double.parse(card.overs);
  print(
    'rate ${rate.toStringAsFixed(2)} from ${card.balls} balls, '
    'not ${wrong.toStringAsFixed(2)}',
  );
}

In Dart: toStringAsFixed(2) prints the two decimals, and a pattern assignment cannot write to fields, so swap uses a local variable.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart