From e418fb5b71b70b34f782eba0ab5294badc54b855 Mon Sep 17 00:00:00 2001
From: Eric Willigers <keiravillekode@gmail.com>
Date: Sat, 20 Jun 2026 11:34:58 +1000
Subject: [PATCH] 31 more exercises

[no important files changed]
---
 .../dnd-character/test_dnd_character.zig      | 28 ++++----
 .../matching-brackets/.meta/supplements.json  | 12 ++++
 .../practice/pangram/.meta/supplements.json   | 12 ++++
 .../queen-attack/.meta/supplements.json       | 10 +++
 .../practice/space-age/test_space_age.zig     |  2 +
 .../sum-of-multiples/.meta/supplements.json   | 14 ++++
 .../test_sum_of_multiples.zig                 |  2 +-
 generators/exercises/acronym.py               | 16 +++++
 generators/exercises/allergies.py             | 40 +++++++++++
 generators/exercises/anagram.py               | 43 ++++++++++++
 generators/exercises/atbash_cipher.py         | 25 +++++++
 generators/exercises/bob.py                   | 15 ++++
 generators/exercises/collatz_conjecture.py    | 20 ++++++
 generators/exercises/darts.py                 | 27 ++++++++
 generators/exercises/difference_of_squares.py | 29 ++++++++
 generators/exercises/dnd_character.py         | 55 +++++++++++++++
 generators/exercises/grains.py                | 39 +++++++++++
 generators/exercises/hamming.py               | 40 +++++++++++
 generators/exercises/hello_world.py           | 13 ++++
 generators/exercises/isogram.py               |  8 +++
 generators/exercises/leap.py                  |  4 ++
 generators/exercises/linked_list.py           | 69 +++++++++++++++++++
 generators/exercises/luhn.py                  | 17 +++++
 generators/exercises/matching_brackets.py     | 24 +++++++
 generators/exercises/nucleotide_count.py      | 20 ++++++
 generators/exercises/pangram.py               |  8 +++
 generators/exercises/proverb.py               | 42 +++++++++++
 generators/exercises/queen_attack.py          | 51 ++++++++++++++
 generators/exercises/raindrops.py             | 18 +++++
 generators/exercises/resistor_color.py        | 35 ++++++++++
 generators/exercises/resistor_color_duo.py    | 20 ++++++
 generators/exercises/rna_transcription.py     | 21 ++++++
 generators/exercises/scrabble_score.py        | 14 ++++
 generators/exercises/secret_handshake.py      | 19 +++++
 generators/exercises/sieve.py                 | 25 +++++++
 generators/exercises/space_age.py             | 25 +++++++
 generators/exercises/sum_of_multiples.py      | 26 +++++++
 generators/exercises/two_fer.py               | 15 ++++
 38 files changed, 888 insertions(+), 15 deletions(-)
 create mode 100644 exercises/practice/matching-brackets/.meta/supplements.json
 create mode 100644 exercises/practice/pangram/.meta/supplements.json
 create mode 100644 exercises/practice/queen-attack/.meta/supplements.json
 create mode 100644 exercises/practice/sum-of-multiples/.meta/supplements.json
 create mode 100644 generators/exercises/acronym.py
 create mode 100644 generators/exercises/allergies.py
 create mode 100644 generators/exercises/anagram.py
 create mode 100644 generators/exercises/atbash_cipher.py
 create mode 100644 generators/exercises/bob.py
 create mode 100644 generators/exercises/collatz_conjecture.py
 create mode 100644 generators/exercises/darts.py
 create mode 100644 generators/exercises/difference_of_squares.py
 create mode 100644 generators/exercises/dnd_character.py
 create mode 100644 generators/exercises/grains.py
 create mode 100644 generators/exercises/hamming.py
 create mode 100644 generators/exercises/hello_world.py
 create mode 100644 generators/exercises/isogram.py
 create mode 100644 generators/exercises/leap.py
 create mode 100644 generators/exercises/linked_list.py
 create mode 100644 generators/exercises/luhn.py
 create mode 100644 generators/exercises/matching_brackets.py
 create mode 100644 generators/exercises/nucleotide_count.py
 create mode 100644 generators/exercises/pangram.py
 create mode 100644 generators/exercises/proverb.py
 create mode 100644 generators/exercises/queen_attack.py
 create mode 100644 generators/exercises/raindrops.py
 create mode 100644 generators/exercises/resistor_color.py
 create mode 100644 generators/exercises/resistor_color_duo.py
 create mode 100644 generators/exercises/rna_transcription.py
 create mode 100644 generators/exercises/scrabble_score.py
 create mode 100644 generators/exercises/secret_handshake.py
 create mode 100644 generators/exercises/sieve.py
 create mode 100644 generators/exercises/space_age.py
 create mode 100644 generators/exercises/sum_of_multiples.py
 create mode 100644 generators/exercises/two_fer.py

diff --git a/exercises/practice/dnd-character/test_dnd_character.zig b/exercises/practice/dnd-character/test_dnd_character.zig
index 402f590d..b81bfbb1 100644
--- a/exercises/practice/dnd-character/test_dnd_character.zig
+++ b/exercises/practice/dnd-character/test_dnd_character.zig
@@ -4,6 +4,20 @@ const testing = std.testing;
 const dnd_character = @import("dnd_character.zig");
 const Character = dnd_character.Character;
 
+fn isValidAbilityScore(n: isize) bool {
+    return n >= 3 and n <= 18;
+}
+
+fn isValid(c: Character) bool {
+    return isValidAbilityScore(c.strength) and
+        isValidAbilityScore(c.dexterity) and
+        isValidAbilityScore(c.constitution) and
+        isValidAbilityScore(c.intelligence) and
+        isValidAbilityScore(c.wisdom) and
+        isValidAbilityScore(c.charisma) and
+        (c.hitpoints == 10 + dnd_character.modifier(c.constitution));
+}
+
 test "ability modifier for score 3 is -4" {
     const expected: i8 = -4;
     const actual = dnd_character.modifier(3);
@@ -100,10 +114,6 @@ test "ability modifier for score 18 is +4" {
     try testing.expectEqual(expected, actual);
 }
 
-fn isValidAbilityScore(n: isize) bool {
-    return n >= 3 and n <= 18;
-}
-
 test "random ability is within range" {
     for (0..20) |_| {
         const actual = dnd_character.ability();
@@ -111,16 +121,6 @@ test "random ability is within range" {
     }
 }
 
-fn isValid(c: Character) bool {
-    return isValidAbilityScore(c.strength) and
-        isValidAbilityScore(c.dexterity) and
-        isValidAbilityScore(c.constitution) and
-        isValidAbilityScore(c.intelligence) and
-        isValidAbilityScore(c.wisdom) and
-        isValidAbilityScore(c.charisma) and
-        (c.hitpoints == 10 + dnd_character.modifier(c.constitution));
-}
-
 test "random character is valid" {
     for (0..20) |_| {
         const character = Character.init();
diff --git a/exercises/practice/matching-brackets/.meta/supplements.json b/exercises/practice/matching-brackets/.meta/supplements.json
new file mode 100644
index 00000000..afaa26ed
--- /dev/null
+++ b/exercises/practice/matching-brackets/.meta/supplements.json
@@ -0,0 +1,12 @@
+{
+  "cases": [
+    {
+      "description": "maximum required level of nesting",
+      "property": "isPaired",
+      "input": {
+        "value": "(((_[[[_{{{_()_}}}_]]]_)))"
+      },
+      "expected": true
+    }
+  ]
+}
diff --git a/exercises/practice/pangram/.meta/supplements.json b/exercises/practice/pangram/.meta/supplements.json
new file mode 100644
index 00000000..6678da07
--- /dev/null
+++ b/exercises/practice/pangram/.meta/supplements.json
@@ -0,0 +1,12 @@
+{
+  "cases": [
+    {
+      "description": "non-alphanumeric printable ASCII",
+      "property": "isPangram",
+      "input": {
+        "sentence": " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+      },
+      "expected": false
+    }
+  ]
+}
diff --git a/exercises/practice/queen-attack/.meta/supplements.json b/exercises/practice/queen-attack/.meta/supplements.json
new file mode 100644
index 00000000..4ff50e7c
--- /dev/null
+++ b/exercises/practice/queen-attack/.meta/supplements.json
@@ -0,0 +1,10 @@
+{
+  "cases": [
+    {
+      "description": "queen has exactly two fields",
+      "property": "fields",
+      "input": {},
+      "expected": 2
+    }
+  ]
+}
diff --git a/exercises/practice/space-age/test_space_age.zig b/exercises/practice/space-age/test_space_age.zig
index 918879ee..87169c75 100644
--- a/exercises/practice/space-age/test_space_age.zig
+++ b/exercises/practice/space-age/test_space_age.zig
@@ -1,4 +1,6 @@
 const std = @import("std");
+const testing = std.testing;
+
 const expectApproxEqAbs = std.testing.expectApproxEqAbs;
 
 const space_age = @import("space_age.zig");
diff --git a/exercises/practice/sum-of-multiples/.meta/supplements.json b/exercises/practice/sum-of-multiples/.meta/supplements.json
new file mode 100644
index 00000000..ddf3cf82
--- /dev/null
+++ b/exercises/practice/sum-of-multiples/.meta/supplements.json
@@ -0,0 +1,14 @@
+{
+  "cases": [
+    {
+      "description": "sum is greater than maximum value of u32",
+      "property": "sum",
+      "comment": "Note that for a u32 `limit`, the maximum sum of multiples fits in a u64.",
+      "input": {
+        "factors": [100000000],
+        "limit": 1000000000
+      },
+      "expected": 4500000000
+    }
+  ]
+}
diff --git a/exercises/practice/sum-of-multiples/test_sum_of_multiples.zig b/exercises/practice/sum-of-multiples/test_sum_of_multiples.zig
index 0c9c5a40..3967aac3 100644
--- a/exercises/practice/sum-of-multiples/test_sum_of_multiples.zig
+++ b/exercises/practice/sum-of-multiples/test_sum_of_multiples.zig
@@ -92,7 +92,7 @@ test "much larger factors" {
 }
 
 test "all numbers are multiples of 1" {
-    const expected: u64 = 4_950;
+    const expected: u64 = 4950;
     const factors = [_]u32{1};
     const limit = 100;
     const actual = try sum(testing.allocator, &factors, limit);
diff --git a/generators/exercises/acronym.py b/generators/exercises/acronym.py
new file mode 100644
index 00000000..496e6fd3
--- /dev/null
+++ b/generators/exercises/acronym.py
@@ -0,0 +1,16 @@
+from lib import zstr
+
+IMPORT_SELF = False
+
+HEADER = 'const abbreviate = @import("acronym.zig").abbreviate;'
+
+
+def gen_case(case):
+    phrase = case["input"]["phrase"]
+    expected = case["expected"]
+    return (
+        f"    const expected = {zstr(expected)};\n"
+        f"    const actual = try abbreviate(testing.allocator, {zstr(phrase)});\n"
+        f"    defer testing.allocator.free(actual);\n"
+        f"    try testing.expectEqualStrings(expected, actual);\n"
+    )
diff --git a/generators/exercises/allergies.py b/generators/exercises/allergies.py
new file mode 100644
index 00000000..53e31040
--- /dev/null
+++ b/generators/exercises/allergies.py
@@ -0,0 +1,40 @@
+from lib import zint
+
+HEADER = (
+    "const isAllergicTo = allergies.isAllergicTo;\n"
+    "const initAllergenSet = allergies.initAllergenSet;\n"
+)
+
+
+def describe(case, parent):
+    # Leaf cases carry their own description; group nodes pass it down via `parent`.
+    if "cases" in case:
+        return case["description"]
+    prop = case.get("property")
+    desc = case["description"]
+    if prop == "allergicTo":
+        return f"{case['input']['item']}: {desc}"
+    if prop == "list":
+        return f"initAllergenSet: {desc}"
+    return desc
+
+
+def gen_case(case):
+    prop = case["property"]
+    if prop == "allergicTo":
+        item = case["input"]["item"]
+        score = case["input"]["score"]
+        expected = case["expected"]
+        bang = "" if expected else "!"
+        return f"    try testing.expect({bang}isAllergicTo({zint(score)}, .{item}));\n"
+    # property == "list": exercise the EnumSet returned by initAllergenSet.
+    score = case["input"]["score"]
+    allergens = case["expected"]
+    s = (
+        f"    const expected_count: usize = {len(allergens)};\n"
+        f"    const actual = initAllergenSet({zint(score)});\n"
+        f"    try testing.expectEqual(expected_count, actual.count());\n"
+    )
+    for a in allergens:
+        s += f"    try testing.expect(actual.contains(.{a}));\n"
+    return s
diff --git a/generators/exercises/anagram.py b/generators/exercises/anagram.py
new file mode 100644
index 00000000..c65334e8
--- /dev/null
+++ b/generators/exercises/anagram.py
@@ -0,0 +1,43 @@
+from lib import zstr
+
+IMPORT_SELF = False
+
+HEADER = """const detectAnagrams = @import("anagram.zig").detectAnagrams;
+
+fn testAnagrams(
+    allocator: std.mem.Allocator,
+    expected: []const []const u8,
+    word: []const u8,
+    candidates: []const []const u8,
+) !void {
+    var actual = try detectAnagrams(allocator, word, candidates);
+    defer actual.deinit();
+    try testing.expectEqual(expected.len, actual.count());
+    for (expected) |e| {
+        try testing.expect(actual.contains(e));
+    }
+}
+"""
+
+
+def _strlist(values):
+    if not values:
+        return "[_][]const u8{}"
+    inner = ", ".join(zstr(v) for v in values)
+    return f"[_][]const u8{{ {inner} }}"
+
+
+def gen_case(case):
+    word = case["input"]["subject"]
+    candidates = case["input"]["candidates"]
+    expected = case["expected"]
+    return (
+        f"    const expected = {_strlist(expected)};\n"
+        f"    const word = {zstr(word)};\n"
+        f"    const candidates = {_strlist(candidates)};\n"
+        f"    try std.testing.checkAllAllocationFailures(\n"
+        f"        std.testing.allocator,\n"
+        f"        testAnagrams,\n"
+        f"        .{{ &expected, word, &candidates }},\n"
+        f"    );\n"
+    )
diff --git a/generators/exercises/atbash_cipher.py b/generators/exercises/atbash_cipher.py
new file mode 100644
index 00000000..dca8def1
--- /dev/null
+++ b/generators/exercises/atbash_cipher.py
@@ -0,0 +1,25 @@
+from lib import zstr
+
+HEADER = """const encode = atbash_cipher.encode;
+const decode = atbash_cipher.decode;"""
+
+
+def describe(case, parent):
+    # The target uses only the leaf description (no parent group prefix) and
+    # lowercases it, so "encode OMG" becomes "encode omg".
+    if "cases" in case:
+        return None
+    return case["description"].lower()
+
+
+def gen_case(case):
+    fn = case["property"]  # "encode" or "decode"
+    phrase = case["input"]["phrase"]
+    expected = case["expected"]
+    return (
+        f"    const expected = {zstr(expected)};\n"
+        f"    const s = {zstr(phrase)};\n"
+        f"    const actual = try {fn}(testing.allocator, s);\n"
+        f"    defer testing.allocator.free(actual);\n"
+        f"    try testing.expectEqualStrings(expected, actual);\n"
+    )
diff --git a/generators/exercises/bob.py b/generators/exercises/bob.py
new file mode 100644
index 00000000..ba248320
--- /dev/null
+++ b/generators/exercises/bob.py
@@ -0,0 +1,15 @@
+from lib import zstr
+
+IMPORT_SELF = False
+
+HEADER = 'const response = @import("bob.zig").response;'
+
+
+def gen_case(case):
+    s = case["input"]["heyBob"]
+    expected = case["expected"]
+    return (
+        f"    const expected = {zstr(expected)};\n"
+        f"    const actual = response({zstr(s)});\n"
+        f"    try testing.expectEqualStrings(expected, actual);\n"
+    )
diff --git a/generators/exercises/collatz_conjecture.py b/generators/exercises/collatz_conjecture.py
new file mode 100644
index 00000000..e8be8c71
--- /dev/null
+++ b/generators/exercises/collatz_conjecture.py
@@ -0,0 +1,20 @@
+from lib import zint, is_error
+
+IMPORT_SELF = True
+HEADER = "const ComputationError = collatz_conjecture.ComputationError;"
+
+
+def gen_case(case):
+    number = zint(case["input"]["number"])
+    expected = case["expected"]
+    if is_error(expected):
+        return (
+            "    const expected = ComputationError.IllegalArgument;\n"
+            f"    const actual = collatz_conjecture.steps({number});\n"
+            "    try testing.expectError(expected, actual);\n"
+        )
+    return (
+        f"    const expected: usize = {zint(expected)};\n"
+        f"    const actual = try collatz_conjecture.steps({number});\n"
+        "    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/darts.py b/generators/exercises/darts.py
new file mode 100644
index 00000000..ea6513ec
--- /dev/null
+++ b/generators/exercises/darts.py
@@ -0,0 +1,27 @@
+from lib import zfloat
+
+IMPORT_SELF = True
+
+
+def describe(case, parent):
+    return case["description"][0].lower() + case["description"][1:]
+
+
+# The committed target flips the signs on this symmetric case (score depends only
+# on x^2 + y^2, so it is equivalent to the canonical x=-3.5, y=3.5).
+_INPUT_OVERRIDE = {
+    "just within the middle circle": {"x": 3.5, "y": -3.5},
+}
+
+
+def gen_case(case):
+    inp = _INPUT_OVERRIDE.get(case["description"], case["input"])
+    x = zfloat(inp["x"])
+    y = zfloat(inp["y"])
+    e = case["expected"]
+    return (
+        f"    const expected: usize = {e};\n"
+        f"    const coordinate = darts.Coordinate.init({x}, {y});\n"
+        f"    const actual = coordinate.score();\n"
+        f"    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/difference_of_squares.py b/generators/exercises/difference_of_squares.py
new file mode 100644
index 00000000..f53b8020
--- /dev/null
+++ b/generators/exercises/difference_of_squares.py
@@ -0,0 +1,29 @@
+from lib import zint
+
+IMPORT_SELF = True
+
+_LABEL = {
+    "squareOfSum": "square of sum up to",
+    "sumOfSquares": "sum of squares up to",
+    "differenceOfSquares": "difference of squares up to",
+}
+
+
+def describe(case, parent):
+    # Leaf cases carry a property; group nodes do not. Group descriptions are
+    # dropped so leaves get a clean "<label> up to <n>" name.
+    if "cases" in case:
+        return None
+    number = case["input"]["number"]
+    return f"{_LABEL[case['property']]} {number}"
+
+
+def gen_case(case):
+    number = zint(case["input"]["number"])
+    expected = zint(case["expected"])
+    prop = case["property"]
+    return (
+        f"    const expected: usize = {expected};\n"
+        f"    const actual = difference_of_squares.{prop}({number});\n"
+        "    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/dnd_character.py b/generators/exercises/dnd_character.py
new file mode 100644
index 00000000..fb9689f1
--- /dev/null
+++ b/generators/exercises/dnd_character.py
@@ -0,0 +1,55 @@
+HEADER = """const Character = dnd_character.Character;
+
+fn isValidAbilityScore(n: isize) bool {
+    return n >= 3 and n <= 18;
+}
+
+fn isValid(c: Character) bool {
+    return isValidAbilityScore(c.strength) and
+        isValidAbilityScore(c.dexterity) and
+        isValidAbilityScore(c.constitution) and
+        isValidAbilityScore(c.intelligence) and
+        isValidAbilityScore(c.wisdom) and
+        isValidAbilityScore(c.charisma) and
+        (c.hitpoints == 10 + dnd_character.modifier(c.constitution));
+}"""
+
+
+def describe(case, parent):
+    # The "ability modifier" group is flattened away; use just the leaf description.
+    return case["description"]
+
+
+def order_key(case):
+    # Property tests for the random generators come after all modifier cases.
+    if case["property"] == "ability":
+        return 1
+    if case["property"] == "character":
+        return 2
+    return 0
+
+
+def gen_case(case):
+    prop = case["property"]
+    if prop == "modifier":
+        score = case["input"]["score"]
+        expected = case["expected"]
+        return (
+            f"    const expected: i8 = {expected};\n"
+            f"    const actual = dnd_character.modifier({score});\n"
+            f"    try testing.expectEqual(expected, actual);\n"
+        )
+    if prop == "ability":
+        return (
+            "    for (0..20) |_| {\n"
+            "        const actual = dnd_character.ability();\n"
+            "        try testing.expect(isValidAbilityScore(actual));\n"
+            "    }\n"
+        )
+    # character
+    return (
+        "    for (0..20) |_| {\n"
+        "        const character = Character.init();\n"
+        "        try testing.expect(isValid(character));\n"
+        "    }\n"
+    )
diff --git a/generators/exercises/grains.py b/generators/exercises/grains.py
new file mode 100644
index 00000000..d973bc73
--- /dev/null
+++ b/generators/exercises/grains.py
@@ -0,0 +1,39 @@
+from lib import zint, is_error
+
+HEADER = "const ChessboardError = grains.ChessboardError;\n"
+
+_RENAME = {
+    "square 0 is invalid": "square 0 produces an error",
+    "square greater than 64 is invalid": "square greater than 64 produces an error",
+}
+
+
+def describe(case, parent):
+    if "cases" in case:
+        return case["description"]
+    return _RENAME.get(case["description"], case["description"])
+
+
+def gen_case(case):
+    prop = case["property"]
+    if prop == "total":
+        expected = case["expected"]
+        return (
+            f"    const expected: u64 = {zint(expected)};\n"
+            f"    const actual = grains.total();\n"
+            f"    try testing.expectEqual(expected, actual);\n"
+        )
+    # property == "square"
+    index = case["input"]["square"]
+    expected = case["expected"]
+    if is_error(expected):
+        return (
+            f"    const expected = ChessboardError.IndexOutOfBounds;\n"
+            f"    const actual = grains.square({zint(index)});\n"
+            f"    try testing.expectError(expected, actual);\n"
+        )
+    return (
+        f"    const expected: u64 = {zint(expected)};\n"
+        f"    const actual = try grains.square({zint(index)});\n"
+        f"    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/hamming.py b/generators/exercises/hamming.py
new file mode 100644
index 00000000..76a40637
--- /dev/null
+++ b/generators/exercises/hamming.py
@@ -0,0 +1,40 @@
+from lib import zstr
+
+IMPORT_SELF = True
+HEADER = "const DnaError = hamming.DnaError;\n"
+
+# Canonical reimplements rename the empty-strand cases to "first/second"; the
+# committed target keeps the original "left/right" wording.
+_RENAME = {
+    "disallow empty first strand": "disallow left empty strand",
+    "disallow empty second strand": "disallow right empty strand",
+}
+
+
+def describe(case, parent):
+    return _RENAME.get(case["description"], case["description"])
+
+
+def gen_case(case):
+    s1 = case["input"]["strand1"]
+    s2 = case["input"]["strand2"]
+    a = zstr(s1)
+    b = zstr(s2)
+    if len(s1) == 0 or len(s2) == 0:
+        return (
+            "    const expected = DnaError.EmptyDnaStrands;\n"
+            f"    const actual = hamming.compute({a}, {b});\n"
+            "    try testing.expectError(expected, actual);\n"
+        )
+    if len(s1) != len(s2):
+        return (
+            "    const expected = DnaError.UnequalDnaStrands;\n"
+            f"    const actual = hamming.compute({a}, {b});\n"
+            "    try testing.expectError(expected, actual);\n"
+        )
+    e = case["expected"]
+    return (
+        f"    const expected: usize = {e};\n"
+        f"    const actual = try hamming.compute({a}, {b});\n"
+        "    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/hello_world.py b/generators/exercises/hello_world.py
new file mode 100644
index 00000000..43928a0a
--- /dev/null
+++ b/generators/exercises/hello_world.py
@@ -0,0 +1,13 @@
+from lib import zstr
+
+
+def describe(case, parent):
+    return case["description"].lower()
+
+
+def gen_case(case):
+    return (
+        f"    const expected = {zstr(case['expected'])};\n"
+        f"    const actual = hello_world.hello();\n"
+        f"    try testing.expectEqualStrings(expected, actual);\n"
+    )
diff --git a/generators/exercises/isogram.py b/generators/exercises/isogram.py
new file mode 100644
index 00000000..0eb496c9
--- /dev/null
+++ b/generators/exercises/isogram.py
@@ -0,0 +1,8 @@
+from lib import zstr
+
+
+def gen_case(case):
+    phrase = case["input"]["phrase"]
+    expected = case["expected"]
+    neg = "" if expected else "!"
+    return f"    try testing.expect({neg}isogram.isIsogram({zstr(phrase)}));\n"
diff --git a/generators/exercises/leap.py b/generators/exercises/leap.py
new file mode 100644
index 00000000..12dc65e3
--- /dev/null
+++ b/generators/exercises/leap.py
@@ -0,0 +1,4 @@
+def gen_case(case):
+    year = case["input"]["year"]
+    bang = "" if case["expected"] else "!"
+    return f"    try testing.expect({bang}leap.isLeapYear({year}));\n"
diff --git a/generators/exercises/linked_list.py b/generators/exercises/linked_list.py
new file mode 100644
index 00000000..413c6e52
--- /dev/null
+++ b/generators/exercises/linked_list.py
@@ -0,0 +1,69 @@
+HEADER = "const List = linked_list.LinkedList(usize);"
+IMPORT_SELF = True
+
+
+def describe(case, parent):
+    return case["description"]
+
+
+_NAMES = "abcdefghijklmnopqrstuvwxyz"
+
+
+def gen_case(case):
+    ops = case["input"]["operations"]
+
+    # A node variable is declared for every value introduced by push/unshift, in order.
+    # delete(value) targets the first not-yet-deleted node holding that value.
+    nodes = []  # list of (name, value)
+    plan = []  # list of (kind, payload)
+    deleted = set()
+
+    for op in ops:
+        kind = op["operation"]
+        if kind in ("push", "unshift"):
+            name = _NAMES[len(nodes)]
+            nodes.append((name, op["value"]))
+            plan.append((kind, name))
+        elif kind == "delete":
+            value = op["value"]
+            target = None
+            for i, (name, val) in enumerate(nodes):
+                if val == value and i not in deleted:
+                    target = name
+                    deleted.add(i)
+                    break
+            if target is None:
+                # Deleting a value not in the list: still declare a node holding it.
+                target = _NAMES[len(nodes)]
+                nodes.append((target, value))
+                deleted.add(len(nodes) - 1)
+            plan.append(("delete", target))
+        elif kind in ("pop", "shift"):
+            plan.append((kind, op.get("expected")))
+        elif kind == "count":
+            plan.append(("count", op["expected"]))
+
+    mutates = any(k != "count" for k, _ in plan)
+    lines = []
+    lines.append(f"    {'var' if mutates else 'const'} list = List{{}};")
+    for name, value in nodes:
+        lines.append(f"    var {name} = List.Node{{ .data = {value} }};")
+
+    for kind, payload in plan:
+        if kind in ("push", "unshift"):
+            lines.append(f"    list.{kind}(&{payload});")
+        elif kind == "delete":
+            lines.append(f"    list.delete(&{payload});")
+        elif kind in ("pop", "shift"):
+            if payload is None:
+                lines.append(f"    _ = list.{kind}();")
+            else:
+                lines.append(
+                    f"    try testing.expectEqual(@as(usize, {payload}), list.{kind}().?.data);"
+                )
+        elif kind == "count":
+            lines.append(
+                f"    try testing.expectEqual(@as(usize, {payload}), list.len);"
+            )
+
+    return "\n".join(lines) + "\n"
diff --git a/generators/exercises/luhn.py b/generators/exercises/luhn.py
new file mode 100644
index 00000000..019f46c7
--- /dev/null
+++ b/generators/exercises/luhn.py
@@ -0,0 +1,17 @@
+from lib import zstr
+
+IMPORT_SELF = False
+
+HEADER = 'const isValid = @import("luhn.zig").isValid;'
+
+
+def describe(case, parent):
+    # The target uses "cannot" where the canonical data uses "can not".
+    return case["description"].replace("can not", "cannot")
+
+
+def gen_case(case):
+    value = case["input"]["value"]
+    expected = case["expected"]
+    neg = "" if expected else "!"
+    return f"    try testing.expect({neg}isValid({zstr(value)}));\n"
diff --git a/generators/exercises/matching_brackets.py b/generators/exercises/matching_brackets.py
new file mode 100644
index 00000000..54efa4a1
--- /dev/null
+++ b/generators/exercises/matching_brackets.py
@@ -0,0 +1,24 @@
+from lib import zstr
+
+IMPORT_SELF = False
+
+HEADER = 'const isBalanced = @import("matching_brackets.zig").isBalanced;'
+
+
+def gen_case(case):
+    value = case["input"]["value"]
+    expected = case["expected"]
+    neg = "" if expected else "!"
+    lit = zstr(value)
+    # Inputs with backslashes or underscores (the latex and deeply-nested cases) are
+    # hoisted into a `const s` to keep the call readable, matching the target test file.
+    if "\\" in value or "_" in value:
+        return (
+            f"    const s = {lit};\n"
+            f"    const actual = try isBalanced(testing.allocator, s);\n"
+            f"    try testing.expect({neg}actual);\n"
+        )
+    return (
+        f"    const actual = try isBalanced(testing.allocator, {lit});\n"
+        f"    try testing.expect({neg}actual);\n"
+    )
diff --git a/generators/exercises/nucleotide_count.py b/generators/exercises/nucleotide_count.py
new file mode 100644
index 00000000..d788fc6d
--- /dev/null
+++ b/generators/exercises/nucleotide_count.py
@@ -0,0 +1,20 @@
+from lib import zstr, zint, is_error
+
+HEADER = "const countNucleotides = nucleotide_count.countNucleotides;\n"
+
+
+def gen_case(case):
+    strand = case["input"]["strand"]
+    expected = case["expected"]
+    if is_error(expected):
+        return (
+            f"    const actual = countNucleotides({zstr(strand)});\n"
+            f"    try testing.expectError(nucleotide_count.NucleotideError.Invalid, actual);\n"
+        )
+    s = f"    const actual = try countNucleotides({zstr(strand)});\n"
+    for letter, field in (("A", "a"), ("C", "c"), ("G", "g"), ("T", "t")):
+        s += (
+            f"    try testing.expectEqual(@as(u32, {zint(expected[letter])}), "
+            f"actual.{field});\n"
+        )
+    return s
diff --git a/generators/exercises/pangram.py b/generators/exercises/pangram.py
new file mode 100644
index 00000000..3c8bbcd2
--- /dev/null
+++ b/generators/exercises/pangram.py
@@ -0,0 +1,8 @@
+from lib import zstr
+
+
+def gen_case(case):
+    sentence = case["input"]["sentence"]
+    expected = case["expected"]
+    neg = "" if expected else "!"
+    return f"    try testing.expect({neg}pangram.isPangram({zstr(sentence)}));\n"
diff --git a/generators/exercises/proverb.py b/generators/exercises/proverb.py
new file mode 100644
index 00000000..f4578f95
--- /dev/null
+++ b/generators/exercises/proverb.py
@@ -0,0 +1,42 @@
+from lib import zstr
+
+HEADER = """
+fn free(slices: [][]u8) void {
+    for (slices) |s| {
+        testing.allocator.free(s);
+    }
+    testing.allocator.free(slices); // No problem when `slices` has zero length.
+}
+
+fn reciteTest(allocator: std.mem.Allocator, input: []const []const u8, expected: []const []const u8) anyerror!void {
+    const actual = try proverb.recite(allocator, input);
+    defer free(actual);
+
+    for (expected, 0..) |expected_slice, i| {
+        try testing.expectEqualSlices(u8, expected_slice, actual[i]);
+    }
+}"""
+
+
+def _array(values):
+    if not values:
+        return "[_][]const u8{}"
+    body = "".join(f"\n        {zstr(v)}," for v in values)
+    return "[_][]const u8{" + body + "\n    }"
+
+
+def gen_case(case):
+    strings = case["input"]["strings"]
+    # The recited lines each end with a newline in the expected output.
+    expected = [line + "\n" for line in case["expected"]]
+    # zig fmt keeps no blank line between two empty one-line arrays (zero pieces).
+    sep = "\n\n" if strings else "\n"
+    return (
+        f"    const input = {_array(strings)};{sep}"
+        f"    const expected = {_array(expected)};\n\n"
+        "    try std.testing.checkAllAllocationFailures(\n"
+        "        std.testing.allocator,\n"
+        "        reciteTest,\n"
+        "        .{ &input, &expected },\n"
+        "    );\n"
+    )
diff --git a/generators/exercises/queen_attack.py b/generators/exercises/queen_attack.py
new file mode 100644
index 00000000..29a8488e
--- /dev/null
+++ b/generators/exercises/queen_attack.py
@@ -0,0 +1,51 @@
+from lib import is_error
+
+HEADER = "const QueenError = queen_attack.QueenError;"
+
+
+def describe(case, parent):
+    # The target uses only the leaf description, dropping the canonical group name.
+    return case["description"]
+
+
+def order_key(case):
+    # The "fields" supplement is the first test in the target; everything else keeps
+    # canonical order (stable sort).
+    return 0 if case["property"] == "fields" else 1
+
+
+def gen_case(case):
+    prop = case["property"]
+    inp = case["input"]
+    if prop == "fields":
+        n = case["expected"]
+        return f"    try testing.expectEqual({n}, std.meta.fields(queen_attack.Queen).len);\n"
+    if prop == "create":
+        pos = inp["queen"]["position"]
+        row, col = pos["row"], pos["column"]
+        if is_error(case["expected"]):
+            return (
+                f"    const queen = queen_attack.Queen.init({row}, {col});\n"
+                f"    try testing.expectError(QueenError.InitializationFailure, queen);\n"
+            )
+        # Valid position: allow any field names, all equal to the input value.
+        return (
+            f"    const queen = try queen_attack.Queen.init({row}, {col});\n"
+            f"    // Allow the fields to have any name.\n"
+            f"    const fields = std.meta.fields(@TypeOf(queen));\n"
+            f"    inline for (fields) |f| {{\n"
+            f"        const actual = @field(queen, f.name);\n"
+            f"        const expected = @as(@TypeOf(actual), {row});\n"
+            f"        try testing.expectEqual(expected, actual);\n"
+            f"    }}\n"
+        )
+    # canAttack
+    w = inp["white_queen"]["position"]
+    b = inp["black_queen"]["position"]
+    expected = case["expected"]
+    bang = "" if expected else "!"
+    return (
+        f"    const white = try queen_attack.Queen.init({w['row']}, {w['column']});\n"
+        f"    const black = try queen_attack.Queen.init({b['row']}, {b['column']});\n"
+        f"    try testing.expect({bang}try white.canAttack(black));\n"
+    )
diff --git a/generators/exercises/raindrops.py b/generators/exercises/raindrops.py
new file mode 100644
index 00000000..c2283651
--- /dev/null
+++ b/generators/exercises/raindrops.py
@@ -0,0 +1,18 @@
+from lib import zstr
+
+IMPORT_SELF = True
+
+HEADER = """
+fn testConvert(comptime n: u32, expected: []const u8) !void {
+    const buffer_size = 15; // The maximum length is for PlingPlangPlong
+    var buffer: [buffer_size]u8 = undefined;
+    const actual = raindrops.convert(&buffer, n);
+    try testing.expectEqualStrings(expected, actual);
+}
+"""
+
+
+def gen_case(case):
+    n = case["input"]["number"]
+    expected = zstr(case["expected"])
+    return f"    try testConvert({n}, {expected});\n"
diff --git a/generators/exercises/resistor_color.py b/generators/exercises/resistor_color.py
new file mode 100644
index 00000000..ba9d4c84
--- /dev/null
+++ b/generators/exercises/resistor_color.py
@@ -0,0 +1,35 @@
+from lib import zint
+
+HEADER = "const ColorBand = resistor_color.ColorBand;\n"
+
+
+def describe(case, parent):
+    if "cases" in case:
+        return case["description"]
+    if case.get("property") == "colorCode":
+        return case["input"]["color"]
+    return "colors"
+
+
+def gen_case(case):
+    prop = case["property"]
+    if prop == "colorCode":
+        color = case["input"]["color"]
+        expected = case["expected"]
+        return (
+            f"    const expected: usize = {zint(expected)};\n"
+            f"    const actual = resistor_color.colorCode(.{color});\n"
+            f"    try testing.expectEqual(expected, actual);\n"
+        )
+    # property == "colors": the ordered list of all color bands. Emit five per row
+    # with a trailing comma so `zig fmt` keeps (and column-aligns) the grid layout.
+    bands = ["." + c for c in case["expected"]]
+    rows = []
+    for i in range(0, len(bands), 5):
+        rows.append("        " + ", ".join(bands[i : i + 5]) + ",")
+    grid = "\n".join(rows)
+    return (
+        f"    const expected = &[_]ColorBand{{\n{grid}\n    }};\n"
+        f"    const actual = resistor_color.colors();\n"
+        f"    try testing.expectEqualSlices(ColorBand, expected, actual);\n"
+    )
diff --git a/generators/exercises/resistor_color_duo.py b/generators/exercises/resistor_color_duo.py
new file mode 100644
index 00000000..ed085626
--- /dev/null
+++ b/generators/exercises/resistor_color_duo.py
@@ -0,0 +1,20 @@
+from lib import zint
+
+HEADER = "const ColorBand = resistor_color_duo.ColorBand;\n"
+
+
+def describe(case, parent):
+    if "cases" in case:
+        return case["description"]
+    return case["description"][0].lower() + case["description"][1:]
+
+
+def gen_case(case):
+    bands = ", ".join("." + c for c in case["input"]["colors"])
+    expected = case["expected"]
+    return (
+        f"    const array = [_]ColorBand{{ {bands} }};\n"
+        f"    const expected: usize = {zint(expected)};\n"
+        f"    const actual = resistor_color_duo.colorCode(array);\n"
+        f"    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/rna_transcription.py b/generators/exercises/rna_transcription.py
new file mode 100644
index 00000000..29c785ba
--- /dev/null
+++ b/generators/exercises/rna_transcription.py
@@ -0,0 +1,21 @@
+from lib import zstr
+
+USE_MEM = True
+
+HEADER = """
+fn testTranscription(dna: []const u8, expected: []const u8) !void {
+    const rna = try rna_transcription.toRna(testing.allocator, dna);
+    defer testing.allocator.free(rna);
+    try testing.expectEqualStrings(expected, rna);
+}"""
+
+
+def describe(case, parent):
+    # The target lowercases the canonical descriptions.
+    return case["description"].lower()
+
+
+def gen_case(case):
+    dna = case["input"]["dna"]
+    expected = case["expected"]
+    return f"    try testTranscription({zstr(dna)}, {zstr(expected)});\n"
diff --git a/generators/exercises/scrabble_score.py b/generators/exercises/scrabble_score.py
new file mode 100644
index 00000000..1a19e380
--- /dev/null
+++ b/generators/exercises/scrabble_score.py
@@ -0,0 +1,14 @@
+from lib import zstr, zint
+
+IMPORT_SELF = False
+HEADER = 'const score = @import("scrabble_score.zig").score;\n'
+
+
+def gen_case(case):
+    word = case["input"]["word"]
+    expected = case["expected"]
+    return (
+        f"    const expected: u32 = {zint(expected)};\n"
+        f"    const actual = score({zstr(word)});\n"
+        f"    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/secret_handshake.py b/generators/exercises/secret_handshake.py
new file mode 100644
index 00000000..0e827198
--- /dev/null
+++ b/generators/exercises/secret_handshake.py
@@ -0,0 +1,19 @@
+from lib import zint
+
+
+def _signal(name):
+    return "." + name.replace(" ", "_")
+
+
+def gen_case(case):
+    number = case["input"]["number"]
+    expected = case["expected"]
+    signals = ", ".join(_signal(name) for name in expected)
+    if signals:
+        signals = " " + signals + " "
+    return (
+        f"    const expected = &[_]secret_handshake.Signal{{{signals}}};\n"
+        f"    const actual = try secret_handshake.calculateHandshake(testing.allocator, {zint(number)});\n"
+        f"    defer testing.allocator.free(actual);\n"
+        f"    try testing.expectEqualSlices(secret_handshake.Signal, expected, actual);\n"
+    )
diff --git a/generators/exercises/sieve.py b/generators/exercises/sieve.py
new file mode 100644
index 00000000..ab4db6b2
--- /dev/null
+++ b/generators/exercises/sieve.py
@@ -0,0 +1,25 @@
+IMPORT_SELF = True
+HEADER = "const buffer_len = 200; // There are 168 primes under 1000.\n"
+
+
+def gen_case(case):
+    limit = case["input"]["limit"]
+    primes = case["expected"]
+    elems = [str(p) for p in primes]
+    body = ", ".join(elems)
+    if not primes:
+        expected = "[_]u32{}"
+    elif len(body) > 66:
+        # Emit 10 per row with a trailing comma; `zig fmt` then right-aligns the
+        # columns into a readable grid (a single over-long line otherwise).
+        rows = [elems[i : i + 10] for i in range(0, len(elems), 10)]
+        grid = "\n".join("    " + ", ".join(row) + "," for row in rows)
+        expected = "[_]u32{\n" + grid + "\n}"
+    else:
+        expected = "[_]u32{ " + body + " }"
+    return (
+        f"    var buffer: [buffer_len]u32 = undefined;\n"
+        f"    const expected = {expected};\n"
+        f"    const actual = sieve.primes(&buffer, {limit});\n"
+        f"    try testing.expectEqualSlices(u32, &expected, actual);\n"
+    )
diff --git a/generators/exercises/space_age.py b/generators/exercises/space_age.py
new file mode 100644
index 00000000..674c8154
--- /dev/null
+++ b/generators/exercises/space_age.py
@@ -0,0 +1,25 @@
+from lib import zint, zfloat
+
+IMPORT_SELF = False
+HEADER = (
+    "const expectApproxEqAbs = std.testing.expectApproxEqAbs;\n\n"
+    'const space_age = @import("space_age.zig");\n'
+    "const Planet = space_age.Planet;\n\n"
+    "fn testAge(planet: Planet, seconds: usize, expected_age_in_earth_years: f64) !void {\n"
+    "    const tolerance = 0.01;\n"
+    "    const actual = planet.age(seconds);\n"
+    "    try expectApproxEqAbs(expected_age_in_earth_years, actual, tolerance);\n"
+    "}\n"
+)
+
+
+def describe(case, parent):
+    # The committed target lowercases the planet name in each test title.
+    return case["description"].lower()
+
+
+def gen_case(case):
+    planet = case["input"]["planet"].lower()
+    seconds = zint(case["input"]["seconds"])
+    expected = zfloat(case["expected"])
+    return f"    try testAge(Planet.{planet}, {seconds}, {expected});\n"
diff --git a/generators/exercises/sum_of_multiples.py b/generators/exercises/sum_of_multiples.py
new file mode 100644
index 00000000..ec4172de
--- /dev/null
+++ b/generators/exercises/sum_of_multiples.py
@@ -0,0 +1,26 @@
+from lib import zint, zarray
+
+IMPORT_SELF = False
+HEADER = 'const sum = @import("sum_of_multiples.zig").sum;'
+
+
+def _gz(n):
+    # The track test file only digit-groups values that are five digits or more.
+    return zint(n) if int(n) >= 10000 else str(n)
+
+
+def gen_case(case):
+    factors = zarray([_gz(f) for f in case["input"]["factors"]], "u32")
+    limit = _gz(case["input"]["limit"])
+    expected = _gz(case["expected"])
+    comment = ""
+    if case.get("comment"):
+        comment = f"    // {case['comment']}\n"
+    return (
+        f"{comment}"
+        f"    const expected: u64 = {expected};\n"
+        f"    const factors = {factors};\n"
+        f"    const limit = {limit};\n"
+        "    const actual = try sum(testing.allocator, &factors, limit);\n"
+        "    try testing.expectEqual(expected, actual);\n"
+    )
diff --git a/generators/exercises/two_fer.py b/generators/exercises/two_fer.py
new file mode 100644
index 00000000..85319c53
--- /dev/null
+++ b/generators/exercises/two_fer.py
@@ -0,0 +1,15 @@
+from lib import zstr
+
+HEADER = "\nconst buffer_size = 100;"
+
+
+def gen_case(case):
+    name = case["input"]["name"]
+    expected = case["expected"]
+    arg = "null" if name is None else zstr(name)
+    return (
+        f"    var response: [buffer_size]u8 = undefined;\n"
+        f"    const expected = {zstr(expected)};\n"
+        f"    const actual = try two_fer.twoFer(&response, {arg});\n"
+        f"    try testing.expectEqualStrings(expected, actual);\n"
+    )