| |
|
|
| """Procedural problem generators for the eight CrossDomain task families. |
| |
| Every generator takes a ``random.Random`` and returns a :class:`Problem` whose |
| reference answer is computed by the generator itself, so every problem is |
| exactly verifiable and the supply of problems is unlimited. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import base64 |
| import codecs |
| import datetime as dt |
| import hashlib |
| import heapq |
| import ipaddress |
| import itertools |
| import json |
| import math |
| import random |
| import re |
| import string |
| from dataclasses import dataclass |
| from fractions import Fraction |
| from typing import Callable |
|
|
|
|
| @dataclass |
| class Problem: |
| prompt: str |
| answer: str |
| kind: str = "num" |
| abs_tol: float = 0.0 |
| rel_tol: float = 1e-3 |
|
|
|
|
| |
| |
| |
|
|
| _NUM_RE = re.compile(r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?") |
|
|
|
|
| def _parse_number(text: str) -> float | None: |
| t = text.strip().replace("−", "-") |
| t = re.sub(r"(?<=\d),(?=\d{3}\b)", "", t) |
| t = t.replace("$", "").replace("%", "") |
| frac = re.search(r"(?<![\d.])([-+]?\d+)\s*/\s*(\d+)(?!\d|\.\d)", t) |
| if frac and int(frac.group(2)) != 0: |
| return int(frac.group(1)) / int(frac.group(2)) |
| m = _NUM_RE.search(t) |
| if not m: |
| return None |
| try: |
| return float(m.group(0)) |
| except ValueError: |
| return None |
|
|
|
|
| def _norm_text(text: str, case_sensitive: bool = False) -> str: |
| t = text.strip().strip("`'\"").strip() |
| t = re.sub(r"\s+", " ", t).rstrip(".") |
| return t if case_sensitive else t.lower() |
|
|
|
|
| def grade(problem: Problem, submitted: str) -> bool: |
| if problem.kind in ("num", "int"): |
| got = _parse_number(submitted) |
| if got is None or not math.isfinite(got): |
| return False |
| want = float(problem.answer) |
| if problem.kind == "int": |
| return abs(got - want) < 1e-9 |
| return abs(got - want) <= max(problem.abs_tol, problem.rel_tol * abs(want)) |
| if problem.kind == "list": |
| got = [_norm_text(x) for x in submitted.split(",") if x.strip()] |
| want = [_norm_text(x) for x in problem.answer.split(",")] |
| return got == want |
| if problem.kind == "text_cs": |
| return _norm_text(submitted, True) == _norm_text(problem.answer, True) |
| return _norm_text(submitted) == _norm_text(problem.answer) |
|
|
|
|
| def _fmt(x: float, nd: int = 2) -> str: |
| return f"{x:.{nd}f}" |
|
|
|
|
| |
| |
| |
|
|
| _PKG = ["auth", "cache", "cli", "core", "db", "http", "log", "metrics", "orm", "parser", |
| "queue", "router", "schema", "storage", "utils", "web", "worker", "config"] |
|
|
|
|
| def se_topo_order(rng: random.Random) -> Problem: |
| names = rng.sample(_PKG, rng.randint(6, 9)) |
| order = names[:] |
| rng.shuffle(order) |
| deps = {n: set() for n in names} |
| for i, n in enumerate(order): |
| for m in order[:i]: |
| if rng.random() < 0.3: |
| deps[n].add(m) |
| lines = [f"- {n}: depends on {', '.join(sorted(deps[n])) or '(nothing)'}" for n in sorted(names)] |
| indeg = {n: len(deps[n]) for n in names} |
| users = {n: [m for m in names if n in deps[m]] for n in names} |
| heap = [n for n in names if indeg[n] == 0] |
| heapq.heapify(heap) |
| out = [] |
| while heap: |
| n = heapq.heappop(heap) |
| out.append(n) |
| for m in users[n]: |
| indeg[m] -= 1 |
| if indeg[m] == 0: |
| heapq.heappush(heap, m) |
| prompt = ( |
| "A build tool installs packages one at a time. A package may only be installed after all " |
| "of its dependencies. Whenever several packages are ready, it installs the alphabetically " |
| "first one.\n" + "\n".join(lines) + |
| "\nGive the full install order as a comma-separated list of package names." |
| ) |
| return Problem(prompt, ", ".join(out), kind="list") |
|
|
|
|
| def _ver_key(v: str) -> tuple[int, ...]: |
| return tuple(int(p) for p in v.split(".")) |
|
|
|
|
| def se_semver(rng: random.Random) -> Problem: |
| vs = set() |
| while len(vs) < rng.randint(8, 12): |
| vs.add(f"{rng.randint(1, 3)}.{rng.randint(0, 6)}.{rng.randint(0, 12)}") |
| versions = sorted(vs, key=_ver_key) |
| base = rng.choice(versions) |
| X, Y, Z = _ver_key(base) |
| op = rng.choice(["^", "~", "range"]) |
| if op == "^": |
| cons, lo, hi = f"^{base}", (X, Y, Z), (X + 1, 0, 0) |
| elif op == "~": |
| cons, lo, hi = f"~{base}", (X, Y, Z), (X, Y + 1, 0) |
| else: |
| hi_v = (X, Y + rng.randint(1, 3), 0) |
| cons, lo, hi = f">={base} <{'.'.join(map(str, hi_v))}", (X, Y, Z), hi_v |
| ok = [v for v in versions if lo <= _ver_key(v) < hi] |
| shown = versions[:] |
| rng.shuffle(shown) |
| prompt = ( |
| f"A registry has these versions of a library: {', '.join(shown)}.\n" |
| f"Using npm semantic-versioning rules, which is the highest version that satisfies " |
| f"the constraint `{cons}`? Answer with the version string only." |
| ) |
| return Problem(prompt, max(ok, key=_ver_key), kind="text") |
|
|
|
|
| def se_rle(rng: random.Random) -> Problem: |
| alphabet = rng.choice(["ab", "abc", "xyz", "ABab"]) |
| runs = [] |
| for _ in range(rng.randint(5, 9)): |
| c = rng.choice(alphabet) |
| if runs and runs[-1][0] == c: |
| continue |
| runs.append((c, rng.randint(1, 12))) |
| s = "".join(c * k for c, k in runs) |
| enc = "".join(f"{k}{c}" for c, k in runs) |
| if rng.random() < 0.5: |
| prompt = ( |
| "Run-length encode the string below: replace each maximal run of a repeated character " |
| "with its length followed by the character (length is always written, even when 1). " |
| f"Characters are case-sensitive.\nString: {s}\nAnswer with the encoded string only." |
| ) |
| return Problem(prompt, enc, kind="text_cs") |
| prompt = ( |
| "The string below is run-length encoded: each group is a decimal count followed by one " |
| f"character. Decode it and report how many characters the decoded string has, and how " |
| f"many of them are '{runs[0][0]}'. Answer as two integers separated by a comma " |
| f"(total, count).\nEncoded: {enc}" |
| ) |
| total = sum(k for _, k in runs) |
| cnt = sum(k for c, k in runs if c == runs[0][0]) |
| return Problem(prompt, f"{total}, {cnt}", kind="list") |
|
|
|
|
| def se_json_query(rng: random.Random) -> Problem: |
| statuses = ["shipped", "pending", "cancelled", "delivered"] |
| orders = [] |
| for i in range(rng.randint(5, 8)): |
| items = [ |
| {"sku": f"SKU-{rng.randint(100, 999)}", "qty": rng.randint(1, 5), |
| "price": round(rng.uniform(2, 80), 2)} |
| for _ in range(rng.randint(1, 4)) |
| ] |
| orders.append({"id": 1000 + i, "status": rng.choice(statuses), "items": items}) |
| want = rng.choice(statuses[:2] + [statuses[3]]) |
| min_qty = rng.randint(1, 3) |
| total = sum(it["qty"] * it["price"] for o in orders if o["status"] == want |
| for it in o["items"] if it["qty"] >= min_qty) |
| prompt = ( |
| "Here is an API response:\n" + json.dumps({"orders": orders}, separators=(",", ":")) + |
| f"\nCompute the sum of qty*price over all line items with qty >= {min_qty} that belong to " |
| f"orders whose status is \"{want}\". Answer with a number rounded to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(total), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def se_regex_count(rng: random.Random) -> Problem: |
| patterns = [ |
| (r"^[a-z]+_[a-z]+$", "snake_case identifiers made of two lowercase words"), |
| (r"^v\d+\.\d+\.\d+$", "version tags like v1.2.3"), |
| (r"^[A-Z][a-zA-Z]*Error$", "class names ending in Error"), |
| (r"^\d{4}-\d{2}-\d{2}$", "ISO dates"), |
| ] |
| pat, _ = rng.choice(patterns) |
| pool = ["user_id", "UserId", "v1.2.3", "v10.0.12", "1.2.3", "v1.2", "ValueError", "valueError", |
| "KeyError", "Error", "2024-01-05", "2024-1-05", "20240105", "max_len", "max__len", |
| "_private", "TypeErrors", "v0.0.0", "IOError", "1999-12-31", "a_b", "snake_case_x"] |
| items = rng.sample(pool, rng.randint(9, 14)) |
| n = sum(1 for x in items if re.search(pat, x)) |
| prompt = ( |
| f"How many of the following strings fully match the Python regular expression " |
| f"`{pat}` (using re.search)?\n" + "\n".join(items) + "\nAnswer with an integer." |
| ) |
| return Problem(prompt, str(n), kind="int") |
|
|
|
|
| |
| |
| |
|
|
| def ind_oee(rng: random.Random) -> Problem: |
| planned = rng.choice([420, 450, 480]) |
| down = rng.randint(20, 90) |
| ict = rng.choice([0.5, 0.75, 1.0, 1.2, 1.5]) |
| run = planned - down |
| total = int(run / ict * rng.uniform(0.7, 0.97)) |
| defects = rng.randint(0, total // 10) |
| a, p, q = run / planned, ict * total / run, (total - defects) / total |
| prompt = ( |
| f"A machine has {planned} min of planned production time in a shift and {down} min of " |
| f"unplanned downtime. Ideal cycle time is {ict} min/unit. It produced {total} units, of " |
| f"which {defects} were defective. Compute OEE (availability x performance x quality) as a " |
| f"percentage rounded to 1 decimal." |
| ) |
| return Problem(prompt, _fmt(100 * a * p * q, 1), abs_tol=0.1, rel_tol=0) |
|
|
|
|
| def ind_tank(rng: random.Random) -> Problem: |
| cap = rng.choice([2000, 5000, 8000, 12000]) |
| level = rng.randint(5, 60) / 100 |
| qin = rng.randint(40, 200) |
| qout = rng.randint(10, qin - 10) |
| t = cap * (1 - level) / (qin - qout) |
| prompt = ( |
| f"A {cap} L tank is {int(level * 100)}% full. Water enters at {qin} L/min and is drawn off " |
| f"at {qout} L/min at the same time. How many minutes until the tank is full? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(t), abs_tol=0.01) |
|
|
|
|
| def ind_circuit(rng: random.Random) -> Problem: |
| v = rng.choice([5, 9, 12, 24, 48]) |
| r1, r2, r3 = (rng.choice([10, 22, 47, 68, 100, 150, 220, 330, 470]) for _ in range(3)) |
| rp = r2 * r3 / (r2 + r3) |
| i = v / (r1 + rp) |
| i3 = i * rp / r3 |
| prompt = ( |
| f"A {v} V ideal source drives R1 = {r1} ohm in series with the parallel pair " |
| f"R2 = {r2} ohm and R3 = {r3} ohm. What current flows through R3, in milliamps? " |
| f"Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(i3 * 1000), abs_tol=0.01) |
|
|
|
|
| def ind_johnson(rng: random.Random) -> Problem: |
| n = rng.randint(4, 6) |
| jobs = {chr(65 + k): (rng.randint(1, 12), rng.randint(1, 12)) for k in range(n)} |
|
|
| def makespan(seq): |
| t1 = t2 = 0 |
| for j in seq: |
| a, b = jobs[j] |
| t1 += a |
| t2 = max(t2, t1) + b |
| return t2 |
|
|
| best = min(makespan(p) for p in itertools.permutations(jobs)) |
| rows = "\n".join(f"- job {j}: {a} h on M1, then {b} h on M2" for j, (a, b) in jobs.items()) |
| prompt = ( |
| "Each job must be processed on machine M1 and then on machine M2; each machine handles one " |
| "job at a time and jobs pass through both machines in the same order.\n" + rows + |
| "\nWhat is the minimum possible makespan in hours? Answer with an integer." |
| ) |
| return Problem(prompt, str(best), kind="int") |
|
|
|
|
| def ind_eoq(rng: random.Random) -> Problem: |
| d = rng.choice([1200, 2400, 5000, 9600, 15000]) |
| s = rng.choice([25, 40, 75, 120]) |
| h = rng.choice([0.8, 1.5, 2.0, 3.5, 6.0]) |
| q = math.sqrt(2 * d * s / h) |
| prompt = ( |
| f"Annual demand is {d} units, each order costs ${s} to place, and holding one unit for a " |
| f"year costs ${h}. What is the economic order quantity? Round to the nearest whole unit." |
| ) |
| return Problem(prompt, str(round(q)), abs_tol=1.0, rel_tol=0) |
|
|
|
|
| def ind_bottleneck(rng: random.Random) -> Problem: |
| st = [(f"S{k+1}", rng.choice([30, 45, 60, 75, 90, 120]), rng.randint(1, 3)) for k in range(rng.randint(3, 5))] |
| rate = min(m * 3600 / ct for _, ct, m in st) |
| rows = "\n".join(f"- {n}: cycle time {ct} s per unit, {m} identical machine(s) in parallel" for n, ct, m in st) |
| prompt = ( |
| "A serial production line has these stations (every unit visits each station once):\n" + rows + |
| "\nWhat is the maximum steady-state throughput of the line in units per hour? Round to 1 decimal." |
| ) |
| return Problem(prompt, _fmt(rate, 1), abs_tol=0.1) |
|
|
|
|
| |
| |
| |
|
|
| def sci_halflife(rng: random.Random) -> Problem: |
| iso, th, unit = rng.choice([("I-131", 8.02, "days"), ("Co-60", 5.27, "years"), |
| ("C-14", 5730, "years"), ("Tc-99m", 6.01, "hours")]) |
| m0 = rng.choice([10, 25, 50, 80, 200]) |
| t = round(th * rng.uniform(0.3, 4.5), 1) |
| m = m0 * 0.5 ** (t / th) |
| prompt = ( |
| f"{iso} has a half-life of {th} {unit}. A sample starts with {m0} mg. How many mg remain " |
| f"after {t} {unit}? Round to 3 significant figures." |
| ) |
| return Problem(prompt, f"{m:.6g}", rel_tol=0.005) |
|
|
|
|
| def sci_projectile(rng: random.Random) -> Problem: |
| v = rng.randint(10, 60) |
| ang = rng.choice([15, 20, 30, 37, 45, 53, 60, 70]) |
| g = 9.81 |
| if rng.random() < 0.5: |
| r = v * v * math.sin(math.radians(2 * ang)) / g |
| q = "horizontal range in metres" |
| else: |
| r = (v * math.sin(math.radians(ang))) ** 2 / (2 * g) |
| q = "maximum height in metres" |
| prompt = ( |
| f"A projectile is launched from level ground at {v} m/s, {ang} degrees above horizontal. " |
| f"Ignore air resistance and use g = 9.81 m/s^2. What is its {q}? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(r), abs_tol=0.01, rel_tol=0.002) |
|
|
|
|
| def sci_gas(rng: random.Random) -> Problem: |
| n = round(rng.uniform(0.2, 5), 2) |
| t_c = rng.randint(-20, 150) |
| v = round(rng.uniform(2, 50), 1) |
| p = n * 8.314 * (t_c + 273.15) / (v / 1000) / 1000 |
| prompt = ( |
| f"{n} mol of an ideal gas occupies {v} L at {t_c} degrees C. Using R = 8.314 J/(mol K) and " |
| f"T(K) = T(C) + 273.15, what is its pressure in kPa? Round to 1 decimal." |
| ) |
| return Problem(prompt, _fmt(p, 1), abs_tol=0.1, rel_tol=0.001) |
|
|
|
|
| _RXNS = [ |
| ("2 H2 + O2 -> 2 H2O", ("H2", 2, 2.016), ("O2", 1, 31.998), ("H2O", 2, 18.015)), |
| ("N2 + 3 H2 -> 2 NH3", ("N2", 1, 28.014), ("H2", 3, 2.016), ("NH3", 2, 17.031)), |
| ("CH4 + 2 O2 -> CO2 + 2 H2O", ("CH4", 1, 16.043), ("O2", 2, 31.998), ("CO2", 1, 44.009)), |
| ("2 Al + 3 Cl2 -> 2 AlCl3", ("Al", 2, 26.982), ("Cl2", 3, 70.906), ("AlCl3", 2, 133.341)), |
| ("4 Fe + 3 O2 -> 2 Fe2O3", ("Fe", 4, 55.845), ("O2", 3, 31.998), ("Fe2O3", 2, 159.687)), |
| ] |
|
|
|
|
| def sci_stoich(rng: random.Random) -> Problem: |
| eq, (a, ca, ma), (b, cb, mb), (p, cp, mp) = rng.choice(_RXNS) |
| ga = round(rng.uniform(5, 120), 1) |
| gb = round(rng.uniform(5, 120), 1) |
| ext = min(ga / ma / ca, gb / mb / cb) |
| gp = ext * cp * mp |
| prompt = ( |
| f"Reaction: {eq}. Molar masses (g/mol): {a} {ma}, {b} {mb}, {p} {mp}. You react {ga} g of " |
| f"{a} with {gb} g of {b}. What is the theoretical yield of {p} in grams? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(gp), abs_tol=0.01, rel_tol=0.002) |
|
|
|
|
| def sci_genetics(rng: random.Random) -> Problem: |
| genes = ["A", "B", "C"][: rng.randint(2, 3)] |
|
|
| def geno(): |
| return "".join(rng.choice([g + g, g + g.lower(), g.lower() + g.lower()]) for g in genes) |
|
|
| p1, p2 = geno(), geno() |
| target = {g: rng.choice(["dominant", "recessive"]) for g in genes} |
| prob = Fraction(1) |
| for k, g in enumerate(genes): |
| a1, a2 = p1[2 * k: 2 * k + 2], p2[2 * k: 2 * k + 2] |
| rec = Fraction(sum(1 for x in a1 for y in a2 if x.islower() and y.islower()), 4) |
| prob *= rec if target[g] == "recessive" else 1 - rec |
| desc = ", ".join(f"{target[g]} for trait {g}" for g in genes) |
| prompt = ( |
| f"Genes {', '.join(genes)} assort independently with complete dominance (uppercase allele " |
| f"dominant). Cross {p1} x {p2}. What is the probability that an offspring shows the " |
| f"phenotype: {desc}? Answer as a reduced fraction like 3/16 (or 0)." |
| ) |
| return Problem(prompt, str(float(prob)), rel_tol=1e-6, abs_tol=1e-9) |
|
|
|
|
| def sci_dilution(rng: random.Random) -> Problem: |
| c1 = rng.choice([1.0, 2.0, 5.0, 6.0, 10.0, 12.0]) |
| c2 = round(c1 * rng.uniform(0.02, 0.6), 3) |
| v2 = rng.choice([100, 250, 500, 1000]) |
| v1 = c2 * v2 / c1 |
| prompt = ( |
| f"How many mL of a {c1} M stock solution are needed to make {v2} mL of a {c2} M solution? " |
| f"Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(v1), abs_tol=0.01) |
|
|
|
|
| |
| |
| |
|
|
| def off_business_days(rng: random.Random) -> Problem: |
| start = dt.date(2025, 1, 1) + dt.timedelta(days=rng.randint(0, 600)) |
| end = start + dt.timedelta(days=rng.randint(10, 75)) |
| span = [start + dt.timedelta(days=k) for k in range((end - start).days + 1)] |
| weekdays = [d for d in span if d.weekday() < 5] |
| hols = sorted(rng.sample(span, rng.randint(1, 3))) |
| n = sum(1 for d in weekdays if d not in hols) |
| prompt = ( |
| f"Count the business days from {start.isoformat()} to {end.isoformat()}, both inclusive. " |
| f"Business days are Monday-Friday, excluding these company holidays: " |
| f"{', '.join(h.isoformat() for h in hols)}. Answer with an integer." |
| ) |
| return Problem(prompt, str(n), kind="int") |
|
|
|
|
| def _hm(m: int) -> str: |
| return f"{m // 60:02d}:{m % 60:02d}" |
|
|
|
|
| def off_meeting(rng: random.Random) -> Problem: |
| for attempt in range(200): |
| people = {} |
| for name in rng.sample(["Ana", "Ben", "Chen", "Dara", "Eli", "Fatima"], 3): |
| busy = [] |
| for _ in range(rng.randint(2, 4)): |
| s = rng.randrange(9 * 60, 17 * 60 - 30, 15) |
| busy.append((s, min(17 * 60, s + rng.choice([30, 45, 60, 90])))) |
| people[name] = sorted(busy) |
| dur = rng.choice([30, 45, 60]) |
| free = None |
| for s in range(9 * 60, 17 * 60 - dur + 1, 15): |
| if all(not (s < e and b < s + dur) for bl in people.values() for b, e in bl): |
| free = s |
| break |
| if free is not None and (free > 9 * 60 or attempt > 100): |
| break |
| rows = "\n".join(f"- {p}: " + ", ".join(f"{_hm(b)}-{_hm(e)}" for b, e in bl) for p, bl in people.items()) |
| prompt = ( |
| "Working hours are 09:00-17:00. Busy times (start inclusive, end exclusive):\n" + rows + |
| f"\nMeetings may only start on a quarter hour. What is the earliest start time for a " |
| f"{dur}-minute meeting with all three people? Answer as HH:MM." |
| ) |
| return Problem(prompt, _hm(free), kind="text") |
|
|
|
|
| def off_pivot(rng: random.Random) -> Problem: |
| regions = ["North", "South", "East", "West"] |
| months = ["Jan", "Feb", "Mar"] |
| rows = [] |
| for _ in range(rng.randint(10, 16)): |
| rows.append((rng.choice(regions), rng.choice(months), rng.choice(["Kim", "Lee", "Ola", "Raj"]), |
| rng.randint(1, 40), round(rng.uniform(5, 150), 2))) |
| r, m = rows[0][0], rows[0][1] |
| total = sum(u * p for rr, mm, _, u, p in rows if rr == r and mm == m) |
| csv = "region,month,rep,units,unit_price\n" + "\n".join(",".join(map(str, x)) for x in rows) |
| prompt = ( |
| f"{csv}\nFrom this CSV, what is the total revenue (units x unit_price) for region {r} in " |
| f"{m}? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(total), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def off_expenses(rng: random.Random) -> Problem: |
| meal_cap = rng.choice([40, 50, 60]) |
| hotel_cap = rng.choice([150, 180, 220]) |
| cats = ["meal", "hotel", "taxi", "alcohol", "meal", "taxi"] |
| items = [(rng.choice(cats), round(rng.uniform(8, 300), 2)) for _ in range(rng.randint(5, 9))] |
| total = 0.0 |
| for c, a in items: |
| if c == "meal": |
| total += min(a, meal_cap) |
| elif c == "hotel": |
| total += min(a, hotel_cap) |
| elif c == "taxi": |
| total += a |
| rows = "\n".join(f"- {c}: ${a:.2f}" for c, a in items) |
| prompt = ( |
| f"Travel policy: each meal is reimbursed up to ${meal_cap}; each hotel night up to " |
| f"${hotel_cap}; taxis in full; alcohol is not reimbursable. Receipts:\n{rows}\n" |
| f"What is the total reimbursable amount? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(total), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def off_dedupe(rng: random.Random) -> Problem: |
| first = ["anna", "bo", "carla", "dev", "emil", "femi", "gus", "hana"] |
| domains = ["acme.com", "globex.io", "initech.org"] |
| base = [f"{rng.choice(first)}.{rng.choice(first)}@{rng.choice(domains)}" for _ in range(rng.randint(5, 8))] |
| uniq = len(set(base)) |
| out = [] |
| for e in base: |
| for _ in range(rng.randint(1, 3)): |
| v = e |
| if rng.random() < 0.5: |
| v = v.upper() if rng.random() < 0.3 else v.capitalize() |
| if rng.random() < 0.4: |
| v = " " + v + " " |
| out.append(v) |
| rng.shuffle(out) |
| prompt = ( |
| "A mailing list export contains these addresses (one per line, quotes show exact text):\n" + |
| "\n".join(f'"{x}"' for x in out) + |
| "\nEmail addresses are case-insensitive and surrounding whitespace is noise. How many " |
| "distinct addresses are there? Answer with an integer." |
| ) |
| return Problem(prompt, str(uniq), kind="int") |
|
|
|
|
| |
| |
| |
|
|
| def fin_loan(rng: random.Random) -> Problem: |
| p = rng.choice([15000, 25000, 180000, 250000, 400000]) |
| r = rng.choice([3.5, 4.25, 5.0, 6.75, 7.9]) |
| n = rng.choice([3, 5, 15, 30]) |
| i = r / 100 / 12 |
| pay = p * i / (1 - (1 + i) ** (-12 * n)) |
| prompt = ( |
| f"A ${p:,} loan has a {r}% annual interest rate compounded monthly and is repaid in equal " |
| f"monthly payments over {n} years. What is the monthly payment? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(pay), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def fin_npv(rng: random.Random) -> Problem: |
| c0 = -rng.choice([1000, 5000, 20000, 50000]) |
| flows = [c0] + [round(-c0 * rng.uniform(0.15, 0.45)) for _ in range(rng.randint(3, 6))] |
| r = rng.choice([4, 6, 8, 10, 12]) |
| npv = sum(c / (1 + r / 100) ** t for t, c in enumerate(flows)) |
| prompt = ( |
| f"A project has cash flows {flows} at the end of years 0, 1, 2, ... (year 0 is today). " |
| f"At a {r}% annual discount rate, what is its NPV? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(npv), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def fin_fv(rng: random.Random) -> Problem: |
| p = rng.choice([0, 1000, 5000, 10000]) |
| pmt = rng.choice([100, 200, 250, 500]) |
| r = rng.choice([3, 5, 6, 7, 8]) |
| n = rng.choice([5, 10, 20, 25]) |
| i, m = r / 100 / 12, 12 * n |
| fv = p * (1 + i) ** m + pmt * ((1 + i) ** m - 1) / i |
| prompt = ( |
| f"You deposit ${p} now and ${pmt} at the end of every month for {n} years into an account " |
| f"paying {r}% annual interest compounded monthly. What is the balance at the end? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(fv), abs_tol=0.011, rel_tol=1e-6) |
|
|
|
|
| def fin_bond(rng: random.Random) -> Problem: |
| face = 1000 |
| c = rng.choice([2, 3, 4.5, 5, 6, 8]) |
| y = rng.choice([2.5, 3.5, 4, 5.5, 7, 9]) |
| n = rng.choice([2, 5, 10, 20]) |
| freq = rng.choice([1, 2]) |
| i, k, cpn = y / 100 / freq, n * freq, face * c / 100 / freq |
| price = sum(cpn / (1 + i) ** t for t in range(1, k + 1)) + face / (1 + i) ** k |
| prompt = ( |
| f"A ${face} face-value bond pays a {c}% annual coupon {'semi-annually' if freq == 2 else 'annually'} " |
| f"and matures in {n} years. If the yield to maturity is {y}% (same compounding), what is its " |
| f"price? Round to 2 decimals." |
| ) |
| return Problem(prompt, _fmt(price), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def fin_equilibrium(rng: random.Random) -> Problem: |
| b, d = rng.randint(1, 6), rng.randint(1, 6) |
| p_star = rng.randint(5, 60) + rng.choice([0, 0.25, 0.5]) |
| c = rng.randint(0, 50) |
| a = c + (b + d) * p_star |
| tax = rng.choice([0, 0, 2, 3]) |
| if tax: |
| |
| p = (a - c + d * tax) / (b + d) |
| q = f"After a per-unit tax of {tax} on sellers (so Qs = {c} + {d}(P - {tax})), what is the new equilibrium price buyers pay?" |
| else: |
| p = p_star |
| q = "What is the equilibrium price?" |
| prompt = f"Demand is Qd = {a} - {b}P and supply is Qs = {c} + {d}P. {q} Round to 2 decimals." |
| return Problem(prompt, _fmt(p), abs_tol=0.011, rel_tol=0) |
|
|
|
|
| def fin_breakeven(rng: random.Random) -> Problem: |
| fixed = rng.choice([12000, 50000, 85000, 240000]) |
| price = rng.randint(20, 200) |
| var = rng.randint(5, price - 5) |
| units = math.ceil(fixed / (price - var)) |
| prompt = ( |
| f"A product sells for ${price} per unit with variable cost ${var} per unit and fixed costs of " |
| f"${fixed}. What is the smallest whole number of units that must be sold to break even " |
| f"(profit >= 0)? Answer with an integer." |
| ) |
| return Problem(prompt, str(units), kind="int") |
|
|
|
|
| |
| |
| |
|
|
| def math_modpow(rng: random.Random) -> Problem: |
| a, b, m = rng.randint(2, 999), rng.randint(10**5, 10**12), rng.choice([97, 1009, 10007, 65537, 10**9 + 7]) |
| return Problem(f"Compute {a}^{b} mod {m}. Answer with an integer.", str(pow(a, b, m)), kind="int") |
|
|
|
|
| def math_lattice(rng: random.Random) -> Problem: |
| w, h = rng.randint(4, 7), rng.randint(4, 7) |
| blocked = set() |
| while len(blocked) < rng.randint(2, 5): |
| c = (rng.randint(0, w), rng.randint(0, h)) |
| if c not in ((0, 0), (w, h)): |
| blocked.add(c) |
| dp = [[0] * (h + 1) for _ in range(w + 1)] |
| for x in range(w + 1): |
| for y in range(h + 1): |
| if (x, y) in blocked: |
| continue |
| if x == y == 0: |
| dp[x][y] = 1 |
| else: |
| dp[x][y] = (dp[x - 1][y] if x else 0) + (dp[x][y - 1] if y else 0) |
| prompt = ( |
| f"On the integer grid, count the paths from (0,0) to ({w},{h}) that use only unit steps " |
| f"+x or +y and never visit these blocked points: {sorted(blocked)}. Answer with an integer." |
| ) |
| return Problem(prompt, str(dp[w][h]), kind="int") |
|
|
|
|
| def math_incl_excl(rng: random.Random) -> Problem: |
| n = rng.randint(1000, 100000) |
| a, b = rng.sample([2, 3, 5, 7, 11, 13], 2) |
| c = rng.choice([4, 6, 9, 10, 15, 21]) |
| cnt = sum(1 for k in range(1, n + 1) if (k % a == 0 or k % b == 0) and k % c != 0) |
| prompt = ( |
| f"How many integers k with 1 <= k <= {n} are divisible by {a} or by {b}, but not divisible " |
| f"by {c}? Answer with an integer." |
| ) |
| return Problem(prompt, str(cnt), kind="int") |
|
|
|
|
| def math_sat_count(rng: random.Random) -> Problem: |
| nv = rng.randint(4, 6) |
| clauses = [] |
| for _ in range(rng.randint(4, 9)): |
| vs = rng.sample(range(1, nv + 1), 3) |
| clauses.append([v if rng.random() < 0.5 else -v for v in vs]) |
| cnt = 0 |
| for bits in itertools.product([False, True], repeat=nv): |
| if all(any(bits[abs(l) - 1] == (l > 0) for l in cl) for cl in clauses): |
| cnt += 1 |
| fmt = " AND ".join("(" + " OR ".join(("x" if l > 0 else "NOT x") + str(abs(l)) for l in cl) + ")" for cl in clauses) |
| prompt = ( |
| f"Over boolean variables x1..x{nv}, how many of the 2^{nv} assignments satisfy\n{fmt}\n" |
| f"Answer with an integer." |
| ) |
| return Problem(prompt, str(cnt), kind="int") |
|
|
|
|
| def math_linsys(rng: random.Random) -> Problem: |
| while True: |
| m = [[rng.randint(-6, 6) for _ in range(3)] for _ in range(3)] |
| det = (m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) |
| - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) |
| + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0])) |
| if det != 0: |
| break |
| sol = [rng.randint(-9, 9) for _ in range(3)] |
| rhs = [sum(m[r][k] * sol[k] for k in range(3)) for r in range(3)] |
|
|
| def term(c, v, first): |
| if c == 0: |
| return "" |
| s = ("-" if c < 0 else ("" if first else "+")) + (str(abs(c)) if abs(c) != 1 else "") + v |
| return s if first else " " + s[0] + " " + s[1:] |
|
|
| eqs = [] |
| for r in range(3): |
| parts, first = [], True |
| for c, v in zip(m[r], "xyz"): |
| t = term(c, v, first) |
| if t: |
| parts.append(t) |
| first = False |
| eqs.append("".join(parts) + f" = {rhs[r]}") |
| prompt = "Solve the system:\n" + "\n".join(eqs) + "\nAnswer as x, y, z (comma-separated integers)." |
| return Problem(prompt, ", ".join(map(str, sol)), kind="list") |
|
|
|
|
| def math_trailing_zeros(rng: random.Random) -> Problem: |
| n = rng.randint(50, 10**7) |
| base = rng.choice([10, 10, 2, 5]) |
| p = 5 if base in (10, 5) else 2 |
| z, q = 0, p |
| while q <= n: |
| z += n // q |
| q *= p |
| what = "trailing zeros does n! have in base 10" if base == 10 else f"times does {p} divide n! (the exponent of {p} in n!)" |
| return Problem(f"Let n = {n}. How many {what}? Answer with an integer.", str(z), kind="int") |
|
|
|
|
| |
| |
| |
|
|
| def cyber_cidr(rng: random.Random) -> Problem: |
| prefix = rng.randint(18, 29) |
| ip = ipaddress.IPv4Address(rng.choice([10 << 24, (172 << 24) | (16 << 16), (192 << 24) | (168 << 16)]) + rng.randint(0, 65535)) |
| net = ipaddress.IPv4Network(f"{ip}/{prefix}", strict=False) |
| q = rng.choice(["network", "broadcast", "hosts", "last"]) |
| if q == "network": |
| return Problem(f"What is the network address of {ip}/{prefix}? Answer with a dotted-quad IPv4 address.", str(net.network_address), kind="text") |
| if q == "broadcast": |
| return Problem(f"What is the broadcast address of {ip}/{prefix}? Answer with a dotted-quad IPv4 address.", str(net.broadcast_address), kind="text") |
| if q == "last": |
| return Problem(f"What is the last usable host address in the subnet containing {ip}/{prefix}? Answer with a dotted-quad IPv4 address.", str(net.broadcast_address - 1), kind="text") |
| return Problem(f"How many usable host addresses are in the subnet containing {ip}/{prefix}? Answer with an integer.", str(net.num_addresses - 2), kind="int") |
|
|
|
|
| def cyber_authlog(rng: random.Random) -> Problem: |
| ips = [f"{rng.randint(11, 223)}.{rng.randint(0, 255)}.{rng.randint(0, 255)}.{rng.randint(1, 254)}" for _ in range(rng.randint(3, 5))] |
| users = ["root", "admin", "deploy", "ubuntu", "git"] |
| weights = [rng.randint(1, 9) for _ in ips] |
| lines, fails = [], {i: 0 for i in ips} |
| t = dt.datetime(2025, 3, 14, 2, 0, 0) |
| for _ in range(rng.randint(12, 20)): |
| t += dt.timedelta(seconds=rng.randint(1, 90)) |
| ip = rng.choices(ips, weights)[0] |
| u = rng.choice(users) |
| pid = rng.randint(1000, 9999) |
| if rng.random() < 0.75: |
| fails[ip] += 1 |
| inv = "invalid user " if rng.random() < 0.3 else "" |
| lines.append(f"{t:%b %d %H:%M:%S} srv sshd[{pid}]: Failed password for {inv}{u} from {ip} port {rng.randint(30000, 65000)} ssh2") |
| else: |
| lines.append(f"{t:%b %d %H:%M:%S} srv sshd[{pid}]: Accepted publickey for {u} from {ip} port {rng.randint(30000, 65000)} ssh2") |
| best = max(fails.values()) |
| top = [i for i in ips if fails[i] == best] |
| if len(top) != 1 or best == 0: |
| return cyber_authlog(rng) |
| prompt = ( |
| "auth.log excerpt:\n" + "\n".join(lines) + |
| "\nWhich source IP has the most failed password attempts? Answer with the IP address only." |
| ) |
| return Problem(prompt, top[0], kind="text") |
|
|
|
|
| def cyber_decode(rng: random.Random) -> Problem: |
| words = ["alpha", "bravo", "cipher", "delta", "echo", "falcon", "ghost", "harbor", "ion", "jade"] |
| secret = "FLAG{" + "_".join(rng.sample(words, 3)) + f"_{rng.randint(10, 99)}" + "}" |
| mode = rng.choice(["xor", "b64rot", "b64rev"]) |
| if mode == "xor": |
| key = rng.randint(1, 255) |
| blob = bytes(c ^ key for c in secret.encode()).hex() |
| prompt = f"This hex string is ASCII text XORed with the single-byte key 0x{key:02x}:\n{blob}\nRecover the plaintext." |
| elif mode == "b64rot": |
| blob = base64.b64encode(codecs.encode(secret, "rot13").encode()).decode() |
| prompt = f"This value is base64 of a ROT13-encoded string:\n{blob}\nRecover the original plaintext." |
| else: |
| blob = base64.b64encode(secret[::-1].encode()).decode() |
| prompt = f"This value is base64 of a string that was reversed before encoding:\n{blob}\nRecover the original plaintext." |
| return Problem(prompt + " Answer with the exact plaintext.", secret, kind="text_cs") |
|
|
|
|
| def cyber_firewall(rng: random.Random) -> Problem: |
| nets = ["10.0.0.0/8", "10.1.0.0/16", "192.168.1.0/24", "0.0.0.0/0", "172.16.5.0/24", "10.1.2.0/24"] |
| rules = [] |
| for _ in range(rng.randint(4, 6)): |
| lo = rng.choice([22, 80, 443, 1000, 3306, 8000]) |
| hi = lo + rng.choice([0, 0, 100, 1000]) |
| rules.append((rng.choice(["ALLOW", "DENY"]), rng.choice(nets), rng.choice(["tcp", "udp", "any"]), lo, hi)) |
| default = rng.choice(["ALLOW", "DENY"]) |
| src = ipaddress.IPv4Address(rng.choice([(10 << 24) | (1 << 16) | (2 << 8), (192 << 24) | (168 << 16) | (1 << 8), (172 << 24) | (16 << 16) | (5 << 8), (8 << 24)]) + rng.randint(1, 254)) |
| port = rng.choice([22, 80, 443, 1050, 3306, 8080, 53]) |
| proto = rng.choice(["tcp", "udp"]) |
| verdict = default |
| for act, net, pr, lo, hi in rules: |
| if src in ipaddress.IPv4Network(net) and pr in ("any", proto) and lo <= port <= hi: |
| verdict = act |
| break |
| rows = "\n".join(f"{k+1}. {a} src={n} proto={p} dport={lo}" + (f"-{hi}" if hi != lo else "") for k, (a, n, p, lo, hi) in enumerate(rules)) |
| prompt = ( |
| f"Firewall rules are evaluated top to bottom; the first match decides, otherwise the default " |
| f"policy {default} applies.\n{rows}\nA {proto} packet arrives from {src} to destination port " |
| f"{port}. Answer ALLOW or DENY." |
| ) |
| return Problem(prompt, verdict, kind="text") |
|
|
|
|
| def cyber_password_policy(rng: random.Random) -> Problem: |
| min_len = rng.choice([8, 10, 12]) |
| pool = string.ascii_letters + string.digits + "!@#$%^&*" |
| pws = [] |
| for _ in range(rng.randint(6, 10)): |
| n = rng.randint(min_len - 3, min_len + 5) |
| pws.append("".join(rng.choice(pool) for _ in range(n))) |
|
|
| def ok(p): |
| return (len(p) >= min_len and any(c.isupper() for c in p) and any(c.islower() for c in p) |
| and any(c.isdigit() for c in p) and any(c in "!@#$%^&*" for c in p)) |
|
|
| prompt = ( |
| f"Password policy: at least {min_len} characters and at least one uppercase letter, one " |
| f"lowercase letter, one digit and one symbol from !@#$%^&*. How many of these passwords " |
| f"comply?\n" + "\n".join(pws) + "\nAnswer with an integer." |
| ) |
| return Problem(prompt, str(sum(map(ok, pws))), kind="int") |
|
|
|
|
| def cyber_hash(rng: random.Random) -> Problem: |
| s = "".join(rng.choice(string.ascii_lowercase + string.digits) for _ in range(rng.randint(6, 14))) |
| algo = rng.choice(["sha256", "md5", "sha1"]) |
| digest = hashlib.new(algo, s.encode()).hexdigest()[:12] |
| prompt = ( |
| f"An integrity manifest lists the first 12 hex characters of the {algo.upper()} digest of the " |
| f"UTF-8 string \"{s}\" (no newline). What are they? Answer with 12 lowercase hex characters." |
| ) |
| return Problem(prompt, digest, kind="text") |
|
|
|
|
| |
| |
| |
|
|
| def _tc(frames: int, fps: int) -> str: |
| f = frames % fps |
| s = frames // fps |
| return f"{s // 3600:02d}:{s // 60 % 60:02d}:{s % 60:02d}:{f:02d}" |
|
|
|
|
| def media_timecode(rng: random.Random) -> Problem: |
| fps = rng.choice([24, 25, 30]) |
| clips = [rng.randint(fps * 3, fps * 400) for _ in range(rng.randint(3, 6))] |
| prompt = ( |
| f"An editor assembles clips of these durations (HH:MM:SS:FF timecode at {fps} fps, " |
| f"non-drop-frame): {', '.join(_tc(c, fps) for c in clips)}. What is the total running time? " |
| f"Answer in HH:MM:SS:FF." |
| ) |
| return Problem(prompt, _tc(sum(clips), fps), kind="text") |
|
|
|
|
| def media_filesize(rng: random.Random) -> Problem: |
| vk = rng.choice([2500, 5000, 8000, 12000, 20000]) |
| ak = rng.choice([128, 192, 256, 320]) |
| secs = rng.randint(30, 5400) |
| mb = (vk + ak) * 1000 * secs / 8 / 1e6 |
| prompt = ( |
| f"A video is encoded at a constant {vk} kbps for video plus {ak} kbps for audio " |
| f"(1 kbps = 1000 bit/s) and runs {secs // 60} min {secs % 60} s. Ignoring container " |
| f"overhead, what is the file size in megabytes (1 MB = 10^6 bytes)? Round to 1 decimal." |
| ) |
| return Problem(prompt, _fmt(mb, 1), abs_tol=0.1) |
|
|
|
|
| def media_scale(rng: random.Random) -> Problem: |
| w0, h0 = rng.choice([(1920, 1080), (1280, 720), (3840, 2160), (1080, 1920), (1440, 1080), (2560, 1080), (720, 576)]) |
| w1 = rng.choice([426, 640, 854, 1000, 1080, 1366, 1600]) |
| h = w1 * h0 / w0 |
| h_even = int(2 * round(h / 2)) |
| prompt = ( |
| f"Scale a {w0}x{h0} video to width {w1}, preserving aspect ratio. The encoder needs an even " |
| f"height, so round the exact height to the nearest even integer. What height do you use?" |
| ) |
| return Problem(prompt, str(h_even), kind="int") |
|
|
|
|
| def media_srt_shift(rng: random.Random) -> Problem: |
| ms = rng.randint(5_000, 5_400_000) |
| shift = rng.choice([-1, 1]) * rng.randint(250, 90_000) |
| if ms + shift < 0: |
| shift = -shift |
|
|
| def fmt(t): |
| return f"{t // 3_600_000:02d}:{t // 60_000 % 60:02d}:{t // 1000 % 60:02d},{t % 1000:03d}" |
|
|
| prompt = ( |
| f"A subtitle cue starts at {fmt(ms)} (SRT format HH:MM:SS,mmm). The audio is out of sync, so " |
| f"every cue must be shifted by {shift:+d} ms. What is the cue's new start time? Answer in " |
| f"HH:MM:SS,mmm." |
| ) |
| return Problem(prompt, fmt(ms + shift), kind="text") |
|
|
|
|
| _SMALL = {"a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "by", "of", "in"} |
| _WORDS = ["night", "of", "the", "living", "code", "and", "a", "river", "in", "winter", "to", "city", |
| "for", "the", "lost", "by", "an", "empire", "on", "fire", "but", "nor", "music", "at", "dawn"] |
|
|
|
|
| def media_title_case(rng: random.Random) -> Problem: |
| words = [rng.choice(_WORDS) for _ in range(rng.randint(5, 9))] |
| if rng.random() < 0.5: |
| words = [w.upper() if rng.random() < 0.3 else w for w in words] |
| out = [] |
| for k, w in enumerate(words): |
| lw = w.lower() |
| out.append(lw if lw in _SMALL and 0 < k < len(words) - 1 else lw.capitalize()) |
| prompt = ( |
| "House style for headlines: capitalize the first letter of every word and lowercase the rest, " |
| "except these small words, which are all lowercase unless they are the first or last word: " |
| f"{', '.join(sorted(_SMALL))}.\nApply it to: {' '.join(words)}\nAnswer with the styled headline." |
| ) |
| return Problem(prompt, " ".join(out), kind="text_cs") |
|
|
|
|
| def media_word_stats(rng: random.Random) -> Problem: |
| vocab = ["story", "camera", "light", "frame", "audience", "editor", "sound", "colour", "narrative", |
| "scene", "cut", "pace", "rhythm", "shot", "director", "moment", "visual", "music", "tone"] |
| words = [rng.choice(vocab) for _ in range(rng.randint(30, 60))] |
| text = " ".join(words).capitalize() + "." |
| k = rng.choice([5, 6, 7]) |
| n = sum(1 for w in words if len(w) >= k) |
| prompt = ( |
| f"Copy for a caption:\n{text}\nHow many words in it have at least {k} letters? " |
| f"Answer with an integer." |
| ) |
| return Problem(prompt, str(n), kind="int") |
|
|
|
|
| |
| |
| |
|
|
| FAMILIES: dict[str, list[Callable[[random.Random], Problem]]] = { |
| "software_engineering": [se_topo_order, se_semver, se_rle, se_json_query, se_regex_count], |
| "industrial_systems": [ind_oee, ind_tank, ind_circuit, ind_johnson, ind_eoq, ind_bottleneck], |
| "natural_science": [sci_halflife, sci_projectile, sci_gas, sci_stoich, sci_genetics, sci_dilution], |
| "office_work": [off_business_days, off_meeting, off_pivot, off_expenses, off_dedupe], |
| "finance_economics": [fin_loan, fin_npv, fin_fv, fin_bond, fin_equilibrium, fin_breakeven], |
| "math_reasoning": [math_modpow, math_lattice, math_incl_excl, math_sat_count, math_linsys, math_trailing_zeros], |
| "cybersecurity": [cyber_cidr, cyber_authlog, cyber_decode, cyber_firewall, cyber_password_policy, cyber_hash], |
| "media_production": [media_timecode, media_filesize, media_scale, media_srt_shift, media_title_case, media_word_stats], |
| } |
|
|
| TASK_IDS = list(FAMILIES) + ["mixed"] |
|
|
|
|
| def generate(task_id: str, rng: random.Random) -> tuple[str, Problem]: |
| family = task_id if task_id in FAMILIES else rng.choice(list(FAMILIES)) |
| gen = rng.choice(FAMILIES[family]) |
| return f"{family}/{gen.__name__}", gen(rng) |
|
|
