openai / EXACT API MODEL

GPT-6.1 Sol

OpenAI direct API, Standard global

gpt-6.1-sol

Coding

Insufficient evidence

Two adjacent completed weeks need comparable cohorts. Missing weeks and changed contracts cannot establish a trend.

tested-best-bank-v2-reviewed

Separate measurement contract · 1 measured cohort · 07a1f808bc18

Each dot is one measured cohort. Bars summarize task/repeat variation; they do not estimate week-to-week noise from one cohort. No interpolation across missing weeks.

coding measurements and service behavior
Measured UTC	Pass rate	95% band	Attempts	Responses	Provider failures	Median latency	Capped / refusal flags	Receipts
2026-10-05 05:54	100.0%	100.0%–100.0%	36 / 36	36 / 36	0	3.02 s	0 / 0	Original JSON

Measurement contract and limitations

Task-bank SHA-256: fce29b4d66cfddeab39632d451935271a37df595374b40eacd300201e3726291
Protocol SHA-256: 90b114dd8a70ecbf3aecc35f58cea1ba85c786554aee9835a38a1c518293da05
Grader contract: 62980813a06357fd89c914858db26855ffe2bd65a7e18f326d827fb6610e7e23
Model configuration: 04e4af3ce275b597cf00f2c7dc53d1c4bd14f4df1016870506fb403d1da26a0e

One point is one cohort, not a week of daily tests.

Exact returned model identity was validated by the source runner; the public projection exposes the admitted ID and response hash.

Hidden fixtures and private transport responses remain with the source owner.

Inspect 36 retained attempts

coding-reconcile · repeat 2 · Pass

checked · responded · 2026-10-05T05:49:02.158863+00:00 UTC

Request: req_57a38056553f4c288af96afbf2cc4850. Estimated cost: US$0.001834. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts with dictionary iteration keys sorted lexicographically by id, including negative overpayments. IDs are strings. Empty lists are valid. Amounts in cents are integers.

Retained output

def solve(data):
    balances = {}
    for invoice in data["invoices"]:
        key = invoice["id"]
        balances[key] = balances.get(key, 0) + invoice["cents"]
    for payment in data["payments"]:
        key = payment["id"]
        balances[key] = balances.get(key, 0) - payment["cents"]
    return {key: balances[key] for key in sorted(balances) if balances[key] != 0}

Response SHA-256: 2afdb4be0b93334307023e0a767f2fabf3d490ac3b9e13fcde7d523e52195ec9

coding-rate · repeat 3 · Pass

checked · responded · 2026-10-05T05:53:24.422196+00:00 UTC

Request: req_29a8e148edb74242bb21fcb0320077d5. Estimated cost: US$0.002098. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans. User IDs are strings.

Retained output

from collections import deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    accepted = {}
    result = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]

        if user not in accepted:
            accepted[user] = deque()
        times = accepted[user]

        cutoff = time - window
        while times and times[0] <= cutoff:
            times.popleft()

        allowed = len(times) < limit
        result.append(allowed)
        if allowed:
            times.append(time)

    return result

Response SHA-256: 792a6affd665dd677a7f424d70ef3806b3f30bca301ca4ab85ce1ac64b570768

coding-fifo · repeat 2 · Pass

checked · responded · 2026-10-05T05:49:34.375916+00:00 UTC

Request: req_d94adde21e7d4346b5fe3616631b4a57. Estimated cost: US$0.001982. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory. Quantities and unit prices are integers.

Retained output

def solve(data):
    unfilled = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        consumed = min(quantity, unfilled)
        unfilled -= consumed
        remaining = quantity - consumed
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": unfilled
    }

Response SHA-256: b9356686672cca8243fccd15e9b10b9106444327d2a163211ef1916727055742

coding-redact · repeat 3 · Pass

checked · responded · 2026-10-05T05:54:23.793169+00:00 UTC

Request: req_3c7ac93e940e407cb6e16938d7b31dd0. Estimated cost: US$0.001464. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    if isinstance(data, dict):
        return {
            key: solve(value)
            for key, value in data.items()
            if key.lower() not in ("password", "token", "secret")
        }
    if isinstance(data, list):
        return [solve(value) for value in data]
    return data

Response SHA-256: 200a8ae0a531f9170d4945d617a4399d4fd89e39ca24e42fa566a971da3baf07

coding-intervals · repeat 1 · Pass

checked · responded · 2026-10-05T05:45:22.666761+00:00 UTC

Request: req_9017598c4d1c456b9f4ab2e9b604a273. Estimated cost: US$0.001596. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Response SHA-256: d6f04ba6da56f709e2c643707cdec4c2aecff9257f7ab351e3c62a65d61ad677

coding-csv · repeat 2 · Pass

checked · responded · 2026-10-05T05:49:14.818536+00:00 UTC

Request: req_3d94177f7dfa48419867fa612095398b. Estimated cost: US$0.002182. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is CSV text with header customer,cents, including quoted fields. Treat a customer containing only whitespace as blank. Trim surrounding whitespace from cents, then accept only an optional ASCII + or - followed by one or more ASCII digits 0-9. Ignore blank customers and invalid cents. Sum by customer and return a dictionary, including zero totals. Preserve customer spelling. CSV quoting is valid and the header is exactly customer,cents. Ignore rows missing either field or containing extra fields. Ignore empty lines. Whitespace means Python str.strip() whitespace. No dictionary key order is required.

Retained output

import csv
import io
import re

def solve(data):
    totals = {}
    pattern = re.compile(r"[+-]?[0-9]+")
    rows = csv.reader(io.StringIO(data))
    next(rows, None)
    for row in rows:
        if len(row) != 2:
            continue
        customer, cents = row
        if not customer.strip():
            continue
        cents = cents.strip()
        if pattern.fullmatch(cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)
    return totals

Response SHA-256: f47afffd99657df19718468f4646d9bc8e1d530ea8afdbcc7217911afcab3a81

coding-rolling · repeat 1 · Pass

checked · responded · 2026-10-05T05:45:33.123620+00:00 UTC

Request: req_96c7101eef014ad0ae6bf96bad7326ba. Estimated cost: US$0.002236. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved. Days, query days and counts are integers.

Retained output

def solve(data):
    events = sorted(data["events"])
    prefix = [0]
    days = []
    for day, count in events:
        days.append(day)
        prefix.append(prefix[-1] + count)

    def upper_bound(value):
        lo, hi = 0, len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] <= value:
                lo = mid + 1
            else:
                hi = mid
        return lo

    return [
        prefix[upper_bound(q)] - prefix[upper_bound(q - 7)]
        for q in data["query_days"]
    ]

Response SHA-256: 01016485ff53eab19a63a9d40f267e9e84f859fafbbe06a8d139deaa863cf210

coding-allocate · repeat 1 · Pass

checked · responded · 2026-10-05T05:45:00.627293+00:00 UTC

Request: req_6692f225837b41e192234da30f2dc4ff. Estimated cost: US$0.002124. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    total = data["total"]
    weights = data["weights"]
    weight_sum = sum(weights)
    if not weights:
        return []
    if weight_sum == 0:
        return [0 for _ in weights]

    shares = [divmod(total * weight, weight_sum) for weight in weights]
    result = [share[0] for share in shares]
    leftover = total - sum(result)
    order = sorted(range(len(weights)), key=lambda i: (-shares[i][1], i))
    for i in order[:leftover]:
        result[i] += 1
    return result

Response SHA-256: be3e896df607641e60689053c1847b3bf85bba16e6ba768c5a9b36929fbbd28a

coding-reconcile · repeat 1 · Pass

checked · responded · 2026-10-05T05:44:15.029141+00:00 UTC

Request: req_181c17b5162f498c94a135bddaef5864. Estimated cost: US$0.001924. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts with dictionary iteration keys sorted lexicographically by id, including negative overpayments. IDs are strings. Empty lists are valid. Amounts in cents are integers.

Retained output

def solve(data):
    balances = {}
    for invoice in data["invoices"]:
        identifier = invoice["id"]
        balances[identifier] = balances.get(identifier, 0) + invoice["cents"]
    for payment in data["payments"]:
        identifier = payment["id"]
        balances[identifier] = balances.get(identifier, 0) - payment["cents"]
    return {
        identifier: balances[identifier]
        for identifier in sorted(balances)
        if balances[identifier] != 0
    }

Response SHA-256: 6419b5d654102cbe5bf69ea7fbb655e13d8f82d6b519658bbc50ab8bde0c03f1

coding-slug · repeat 2 · Pass

checked · responded · 2026-10-05T05:47:39.276883+00:00 UTC

Request: req_8c3f1a7b618e4e16a706a66a694dad19. Estimated cost: US$0.001484. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import unicodedata
import re

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    text = "".join(char for char in normalized if not unicodedata.combining(char)).lower()
    return re.sub("[^a-z0-9]+", "-", text).strip("-")

Response SHA-256: e7a06e9ecab4745318aeb619f856d521ac06e43745b59200be55c2311d954eaf

coding-allocate · repeat 3 · Pass

checked · responded · 2026-10-05T05:54:02.190178+00:00 UTC

Request: req_56846c3985a84e1e813a4c71043b785a. Estimated cost: US$0.002064. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    total = data["total"]
    weights = data["weights"]
    weight_sum = sum(weights)
    if not weights or weight_sum == 0:
        return [0 for _ in weights]

    shares = [divmod(total * weight, weight_sum) for weight in weights]
    result = [share[0] for share in shares]
    remaining = total - sum(result)
    order = sorted(range(len(weights)), key=lambda i: (-shares[i][1], i))
    for i in order[:remaining]:
        result[i] += 1
    return result

Response SHA-256: b4cc91d5a79ca293613d5967b69c04625b54ed49499716dbc3b2787fad388aad

coding-intervals · repeat 2 · Pass

checked · responded · 2026-10-05T05:48:52.930979+00:00 UTC

Request: req_333c2fa527d94444a73fd077eb8b81fa. Estimated cost: US$0.001586. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    result = []
    for start, end in intervals:
        if result and start <= result[-1][1]:
            result[-1][1] = max(result[-1][1], end)
        else:
            result.append([start, end])
    return result

Response SHA-256: 6c68abdd2604589beb9238056c4f8b5b04f5b49f9d43d6ed6ec3502d3db67f64

coding-percentile · repeat 3 · Pass

checked · responded · 2026-10-05T05:52:32.612721+00:00 UTC

Request: req_024853f3428a49788b697fd7a0ca055c. Estimated cost: US$0.001358. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = sorted(data["values"])
    if not values:
        return None
    rank = max(1, math.ceil(data["p"] / 100 * len(values)))
    return values[rank - 1]

Response SHA-256: aa116347541fdec01e96a87fd1976c728134e10f8241611c0bee1a2084f0467b

coding-fifo · repeat 1 · Pass

checked · responded · 2026-10-05T05:45:46.329348+00:00 UTC

Request: req_468a41a0b4df41c3ba85b9f4382f64ae. Estimated cost: US$0.002072. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory. Quantities and unit prices are integers.

Retained output

def solve(data):
    to_sell = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        sold_from_lot = min(quantity, to_sell)
        to_sell -= sold_from_lot
        remaining = quantity - sold_from_lot
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": to_sell
    }

Response SHA-256: 02880cbcbdd4eab11d64698e36b70d423f2c66477fe1b56780ec22a009b23321

coding-percentile · repeat 1 · Pass

checked · responded · 2026-10-05T05:41:31.663853+00:00 UTC

Request: req_3e90e714967942d18d98e75b8750771f. Estimated cost: US$0.001358. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = sorted(data["values"])
    if not values:
        return None
    rank = max(1, math.ceil(data["p"] / 100 * len(values)))
    return values[rank - 1]

Response SHA-256: c0bd5d646de5e2c827911d6431554311db98cbe98221224fc7d384d85bdc18fd

coding-percentile · repeat 2 · Pass

checked · responded · 2026-10-05T05:48:15.748177+00:00 UTC

Request: req_f1a1db7191c14c06947f119c240215aa. Estimated cost: US$0.001418. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = data["values"]
    if not values:
        return None
    ordered = sorted(values)
    rank = max(1, math.ceil(data["p"] / 100 * len(ordered)))
    return ordered[rank - 1]

Response SHA-256: 31e621043751744ec8ad1454775cac68a273b861e92e0296dc5d2a545c0b60b5

coding-rolling · repeat 3 · Pass

checked · responded · 2026-10-05T05:50:52.785459+00:00 UTC

Request: req_0bcc89c139be4f95acc21dd3ae99778f. Estimated cost: US$0.002246. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved. Days, query days and counts are integers.

Retained output

def solve(data):
    events = sorted(data["events"])
    queries = sorted(enumerate(data["query_days"]), key=lambda item: item[1])
    results = [0] * len(queries)
    left = 0
    right = 0
    total = 0

    for index, day in queries:
        while right < len(events) and events[right][0] <= day:
            total += events[right][1]
            right += 1
        while left < right and events[left][0] < day - 6:
            total -= events[left][1]
            left += 1
        results[index] = total

    return results

Response SHA-256: 457c573b372e2e0e63c74937da686fe1e469234b7c1be4af23243138c702bf3f

coding-redact · repeat 1 · Pass

checked · responded · 2026-10-05T05:42:46.456076+00:00 UTC

Request: req_c7a1a9aa3c904c93b7cd5073f192156b. Estimated cost: US$0.001464. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    if isinstance(data, dict):
        return {
            key: solve(value)
            for key, value in data.items()
            if key.lower() not in ("password", "token", "secret")
        }
    if isinstance(data, list):
        return [solve(value) for value in data]
    return data

Response SHA-256: fe87bc2b308c0a0d8287734ad223124d1b1f8ab6cc3c90a1591ffdb7be77259a

coding-intervals · repeat 3 · Pass

checked · responded · 2026-10-05T05:50:36.943395+00:00 UTC

Request: req_7c29796587d04c9b9a3f2ea78112698d. Estimated cost: US$0.001596. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Response SHA-256: 47f79bd834a178a604e0fae90bf59f5af850a34891c9fb77b1ab9d9ff7513daa

coding-csv · repeat 1 · Pass

checked · responded · 2026-10-05T05:42:31.741334+00:00 UTC

Request: req_5caed2c2b73845b2a8c52080d3911c0d. Estimated cost: US$0.002732. Billed cost: unreconciled.

Exact prompt

Retained output

import csv
import io
import re

def solve(data):
    rows = csv.reader(io.StringIO(data))
    next(rows, None)
    totals = {}
    for row in rows:
        if len(row) != 2:
            continue
        customer, cents = row
        if not customer.strip():
            continue
        cents = cents.strip()
        if re.fullmatch(r"[+-]?[0-9]+", cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)
    return totals

Response SHA-256: e3284f1d9a0d4c70ce283a063cf59ebc10e24dc9ad889a4c7aef30b06e5c4c05

coding-dedup · repeat 3 · Pass

checked · responded · 2026-10-05T05:53:07.263934+00:00 UTC

Request: req_f234aa376dd646ae884dd5f40d46063b. Estimated cost: US$0.001458. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input. IDs are strings, versions are integers, and values are arbitrary JSON.

Retained output

def solve(data):
    retained = {}
    for item in data:
        identifier = item["id"]
        if identifier not in retained or item["version"] >= retained[identifier]["version"]:
            retained[identifier] = item
    return [retained[identifier] for identifier in sorted(retained)]

Response SHA-256: cfcdbab66f0ba11ffc7c5f14f769a27b854419d952c3f6f4a97d047015f9ff0b

coding-rolling · repeat 2 · Pass

checked · responded · 2026-10-05T05:47:02.009936+00:00 UTC

Request: req_c2cd70fb93664c10a7ad8179b37232cc. Estimated cost: US$0.004096. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved. Days, query days and counts are integers.

Retained output

def solve(data):
    events = sorted(data["events"])
    queries = sorted((day, i) for i, day in enumerate(data["query_days"]))
    result = [0] * len(queries)
    left = 0
    right = 0
    total = 0
    n = len(events)

    for day, index in queries:
        while right < n and events[right][0] <= day:
            total += events[right][1]
            right += 1

        start = day - 6
        while left < right and events[left][0] < start:
            total -= events[left][1]
            left += 1

        result[index] = total

    return result

Response SHA-256: 48b5f3d6fbe97b7e589422774cc3a88c9ce19e6792a10c1e07ddea457d429019

coding-redact · repeat 2 · Pass

checked · responded · 2026-10-05T05:48:24.276306+00:00 UTC

Request: req_0f5fe8b664f54a8ea63b94b0e45a7582. Estimated cost: US$0.001464. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    if isinstance(data, dict):
        return {
            key: solve(value)
            for key, value in data.items()
            if key.lower() not in ("password", "token", "secret")
        }
    if isinstance(data, list):
        return [solve(value) for value in data]
    return data

Response SHA-256: 78188a2a1b2719f69e84693d0e6c018ce1c1999a73c85ca9bf960937216a984e

coding-rate · repeat 2 · Pass

checked · responded · 2026-10-05T05:47:29.268419+00:00 UTC

Request: req_33afdc58321c4f40b296836d57dc0ab6. Estimated cost: US$0.002098. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans. User IDs are strings.

Retained output

from collections import deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    accepted = {}
    results = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        if user not in accepted:
            accepted[user] = deque()
        queue = accepted[user]
        cutoff = time - window

        while queue and queue[0] <= cutoff:
            queue.popleft()

        allowed = len(queue) < limit
        results.append(allowed)
        if allowed:
            queue.append(time)

    return results

Response SHA-256: 8b205b29730d5649cb4214efbd3ac010d06eca51502f88b892cef53c7f40a599

coding-dependencies · repeat 1 · Pass

checked · responded · 2026-10-05T05:44:24.231407+00:00 UTC

Request: req_c58041fcf31f4231943640c6aaf78bd7. Estimated cost: US$0.003022. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle. Job and prerequisite names are strings; prerequisites are lists. Repeated names in a prerequisite list denote the same dependency. Referenced-only names have no prerequisites. A self-dependency is a cycle. Return Python None for a cycle.

Retained output

import heapq

def solve(data):
    names = set(data)
    for prerequisites in data.values():
        names.update(prerequisites)

    dependents = {name: [] for name in names}
    indegree = {name: 0 for name in names}

    for job, prerequisites in data.items():
        unique_prerequisites = set(prerequisites)
        indegree[job] = len(unique_prerequisites)
        for prerequisite in unique_prerequisites:
            dependents[prerequisite].append(job)

    ready = [name for name in names if indegree[name] == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        job = heapq.heappop(ready)
        order.append(job)
        for dependent in dependents[job]:
            indegree[dependent] -= 1
            if indegree[dependent] == 0:
                heapq.heappush(ready, dependent)

    return order if len(order) == len(names) else None

Response SHA-256: fec7c8d3cf0e4ffa48ea66ced5385d480f50c8b265e297cade2bf8ab9ef80d13

coding-slug · repeat 3 · Pass

checked · responded · 2026-10-05T05:53:37.115699+00:00 UTC

Request: req_55bb1d53ac394459bfa7e83737a65af6. Estimated cost: US$0.001484. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import unicodedata
import re

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    text = "".join(c for c in normalized if not unicodedata.combining(c)).lower()
    return re.sub("[^a-z0-9]+", "-", text).strip("-")

Response SHA-256: 87120cf5b0988920eb336c9727145da93f47c62cccde24c827478b02cea226db

coding-allocate · repeat 2 · Pass

checked · responded · 2026-10-05T05:47:13.524790+00:00 UTC

Request: req_8db017448b31437abf8a3cd7f369a608. Estimated cost: US$0.002124. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    total = data["total"]
    weights = data["weights"]
    weight_sum = sum(weights)
    if not weights:
        return []
    if weight_sum == 0:
        return [0 for _ in weights]

    shares = [divmod(total * weight, weight_sum) for weight in weights]
    result = [share[0] for share in shares]
    leftover = total - sum(result)
    order = sorted(range(len(weights)), key=lambda i: (-shares[i][1], i))
    for i in order[:leftover]:
        result[i] += 1
    return result

Response SHA-256: f2908fa162552691fffb846c5fe7f6347138fe70b50932d528c45d4efe996156

coding-rate · repeat 1 · Pass

checked · responded · 2026-10-05T05:42:54.917963+00:00 UTC

Request: req_ac71ec3141f54d2aa7ed6172b99493b6. Estimated cost: US$0.002098. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans. User IDs are strings.

Retained output

from collections import deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    accepted = {}
    result = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        if user not in accepted:
            accepted[user] = deque()
        times = accepted[user]
        cutoff = time - window

        while times and times[0] <= cutoff:
            times.popleft()

        allowed = len(times) < limit
        result.append(allowed)
        if allowed:
            times.append(time)

    return result

Response SHA-256: 1563a9556559b9b0708a333c67f0c9a925b8cfd72301ea10070277d686c19cc7

coding-dedup · repeat 1 · Pass

checked · responded · 2026-10-05T05:42:03.851012+00:00 UTC

Request: req_38039d45a22d4f2eb4a3db6312d7f9f2. Estimated cost: US$0.001438. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input. IDs are strings, versions are integers, and values are arbitrary JSON.

Retained output

def solve(data):
    retained = {}
    for item in data:
        key = item["id"]
        if key not in retained or item["version"] >= retained[key]["version"]:
            retained[key] = item
    return [dict(retained[key]) for key in sorted(retained)]

Response SHA-256: 7f7cc9754f691c776533b7dcb9f8f89a73ff900bb5dffcade44fef3fae45c429

coding-dedup · repeat 2 · Pass

checked · responded · 2026-10-05T05:50:07.358701+00:00 UTC

Request: req_c884eef38a0440f5a94b301c5beb1e8a. Estimated cost: US$0.001488. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input. IDs are strings, versions are integers, and values are arbitrary JSON.

Retained output

def solve(data):
    retained = {}
    for item in data:
        item_id = item["id"]
        if item_id not in retained or item["version"] >= retained[item_id]["version"]:
            retained[item_id] = item
    return [retained[item_id] for item_id in sorted(retained)]

Response SHA-256: c751b49aa77250cde34cab7b0e5b08dd9ac32d53767267aa5a3303badf9ebe6d

coding-fifo · repeat 3 · Pass

checked · responded · 2026-10-05T05:50:28.242460+00:00 UTC

Request: req_4f23a6827d7b4f29a8ee4916d5c5d16d. Estimated cost: US$0.002152. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory. Quantities and unit prices are integers.

Retained output

def solve(data):
    unsold_demand = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        sold_from_lot = min(quantity, unsold_demand)
        unsold_demand -= sold_from_lot
        remaining = quantity - sold_from_lot
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": unsold_demand
    }

Response SHA-256: bb3e4bb46b40f68820164cebed5551c1e28aff767157a503d7729f6f8dcc9c70

coding-csv · repeat 3 · Pass

checked · responded · 2026-10-05T05:52:21.807149+00:00 UTC

Request: req_ae8c2346d43a45008be6e19917432e1d. Estimated cost: US$0.002182. Billed cost: unreconciled.

Exact prompt

Retained output

import csv
import io
import re

def solve(data):
    totals = {}
    pattern = re.compile(r"[+-]?[0-9]+")
    rows = csv.reader(io.StringIO(data))
    next(rows, None)
    for row in rows:
        if len(row) != 2:
            continue
        customer, cents = row
        if not customer.strip():
            continue
        cents = cents.strip()
        if pattern.fullmatch(cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)
    return totals

Response SHA-256: aefa984e1874321eff6f3709eaa0ae1924f1c615466331b89d30f6e9a0bb6b3f

coding-dependencies · repeat 2 · Pass

checked · responded · 2026-10-05T05:48:44.253053+00:00 UTC

Request: req_f180145e5f9f4a08b1987b37984bc50f. Estimated cost: US$0.002922. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle. Job and prerequisite names are strings; prerequisites are lists. Repeated names in a prerequisite list denote the same dependency. Referenced-only names have no prerequisites. A self-dependency is a cycle. Return Python None for a cycle.

Retained output

import heapq

def solve(data):
    names = set(data)
    for prerequisites in data.values():
        names.update(prerequisites)

    indegree = {name: 0 for name in names}
    dependents = {name: [] for name in names}

    for job, prerequisites in data.items():
        unique = set(prerequisites)
        indegree[job] = len(unique)
        for prerequisite in unique:
            dependents[prerequisite].append(job)

    ready = [name for name in names if indegree[name] == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        name = heapq.heappop(ready)
        order.append(name)
        for job in dependents[name]:
            indegree[job] -= 1
            if indegree[job] == 0:
                heapq.heappush(ready, job)

    return order if len(order) == len(names) else None

Response SHA-256: 3dba27ae86ac9c6c1307dbea1694955bf117f33a210f8e27b53e43e23b9ffcdd

coding-reconcile · repeat 3 · Pass

checked · responded · 2026-10-05T05:52:02.914231+00:00 UTC

Request: req_5d01eefc435a49bd8c72917dce0ff33d. Estimated cost: US$0.001834. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts with dictionary iteration keys sorted lexicographically by id, including negative overpayments. IDs are strings. Empty lists are valid. Amounts in cents are integers.

Retained output

def solve(data):
    balances = {}
    for invoice in data["invoices"]:
        key = invoice["id"]
        balances[key] = balances.get(key, 0) + invoice["cents"]
    for payment in data["payments"]:
        key = payment["id"]
        balances[key] = balances.get(key, 0) - payment["cents"]
    return {key: balances[key] for key in sorted(balances) if balances[key] != 0}

Response SHA-256: b61ebebad9f9365d6ae5e9421d00b29fc4bdff06042aa43950954082bb34c23a

coding-slug · repeat 1 · Pass

checked · responded · 2026-10-05T05:45:11.909845+00:00 UTC

Request: req_f90682d62dfb415391159c3705367374. Estimated cost: US$0.001484. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import unicodedata
import re

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    text = "".join(c for c in normalized if not unicodedata.combining(c)).lower()
    return re.sub("[^a-z0-9]+", "-", text).strip("-")

Response SHA-256: 9c166126cda1f0fef1ece6256d2ebffa2a6a854cf3843e7546b39127a7922350

coding-dependencies · repeat 3 · Pass

checked · responded · 2026-10-05T05:53:50.974018+00:00 UTC

Request: req_db46e496eafd422db1a5b4c86b622898. Estimated cost: US$0.002922. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports are restricted module facades: math (public members); json (loads, dumps); csv (reader, DictReader); io (StringIO); re (compile, match, search, fullmatch, findall, finditer, split, sub, escape, IGNORECASE, MULTILINE, DOTALL, ASCII); collections (deque, defaultdict, Counter); heapq (heappush, heappop, heapify); unicodedata (normalize, combining, category). Other module members are unavailable. Use functions and only these safe built-ins: abs, all, any, bool, bytes, dict, divmod, enumerate, filter, float, frozenset, int, isinstance, len, list, map, max, min, next, ord, chr, pow, range, reversed, round, set, sorted, str, sum, tuple, zip, Exception, ValueError, TypeError, KeyError, IndexError, StopIteration. Import listed modules before referencing them. No custom classes, private/dunder attributes, globals/nonlocals, with statements, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Do not mutate any input, including nested containers. Return JSON-serializable values; Python None represents JSON null. Numeric strings and booleans are not accepted as numeric answers. Integer results are compared exactly; floating results use absolute tolerance 0.000001 or relative tolerance 0.00000001. Inputs follow the declared schema; no unspecified input validation is required. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle. Job and prerequisite names are strings; prerequisites are lists. Repeated names in a prerequisite list denote the same dependency. Referenced-only names have no prerequisites. A self-dependency is a cycle. Return Python None for a cycle.

Retained output

import heapq

def solve(data):
    names = set(data)
    for prerequisites in data.values():
        names.update(prerequisites)

    indegree = {name: 0 for name in names}
    dependents = {name: [] for name in names}

    for job, prerequisites in data.items():
        unique = set(prerequisites)
        indegree[job] = len(unique)
        for prerequisite in unique:
            dependents[prerequisite].append(job)

    ready = [name for name in names if indegree[name] == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        name = heapq.heappop(ready)
        order.append(name)
        for job in dependents[name]:
            indegree[job] -= 1
            if indegree[job] == 0:
                heapq.heappush(ready, job)

    return order if len(order) == len(names) else None

Response SHA-256: 4f409ec9b683aacc8b5d2f8799fd0a4a231b2f0ea4fb34c1c50ea1ad60ac87e3

tested-best-bank-v1

Separate measurement contract · 1 measured cohort · cec849a95203

Each dot is one measured cohort. Bars summarize task/repeat variation; they do not estimate week-to-week noise from one cohort. No interpolation across missing weeks.

coding measurements and service behavior
Measured UTC	Pass rate	95% band	Attempts	Responses	Provider failures	Median latency	Capped / refusal flags	Receipts
2026-10-04 17:01	94.4%	80.6%–100.0%	36 / 36	36 / 36	0	4.01 s	0 / 0	Original JSON Correction

Measurement contract and limitations

Task-bank SHA-256: 8ad4dea4fe0b53a67184c305f645a228a1a0d48425a7787bae5990c7e7fd023e
Protocol SHA-256: 06e5a0f38a9ad3b58d5afad4822ef747debe2a458340a5e752ea6d016aaa7f52
Grader contract: 62980813a06357fd89c914858db26855ffe2bd65a7e18f326d827fb6610e7e23
Model configuration: 04e4af3ce275b597cf00f2c7dc53d1c4bd14f4df1016870506fb403d1da26a0e

One point is one cohort, not a week of daily tests.

Exact returned model identity was validated by the source runner; the public projection exposes the admitted ID and response hash.

Hidden fixtures and private transport responses remain with the source owner.

v1 uses the disclosed offline correction. Original grades remain in each affected receipt.

Inspect 36 retained attempts

coding-rate · repeat 3 · Pass

checked · responded · 2026-10-04T16:59:52.780383+00:00 UTC

Request: req_2b508b7f145b4c04a344f1a96d153ee5. Estimated cost: US$0.001514. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans.

Retained output

from collections import deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    accepted_by_user = {}
    result = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        queue = accepted_by_user.setdefault(user, deque())
        cutoff = time - window

        while queue and queue[0] <= cutoff:
            queue.popleft()

        accepted = len(queue) < limit
        result.append(accepted)
        if accepted:
            queue.append(time)

    return result

Response SHA-256: b1165d91e4fbb9bc8e58b2db79998eddf5b9f8169d0da8122d9da03832c4d1d6

coding-allocate · repeat 2 · Pass

checked · responded · 2026-10-04T16:46:44.980479+00:00 UTC

Request: req_bbfc4072e61847db8e3b81421aca6dce. Estimated cost: US$0.002400. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    weights = data["weights"]
    total = data["total"]
    weight_sum = sum(weights)

    if not weights:
        return []
    if weight_sum == 0:
        return [0] * len(weights)

    allocations = []
    remainders = []
    for weight in weights:
        allocation, remainder = divmod(total * weight, weight_sum)
        allocations.append(allocation)
        remainders.append(remainder)

    leftover = total - sum(allocations)
    order = sorted(
        range(len(weights)),
        key=lambda i: (-remainders[i], i)
    )
    for i in order[:leftover]:
        allocations[i] += 1

    return allocations

Response SHA-256: 58d23d6842169bd960e52f264074a97b1289340be52de7c2e2b6021f2dc99d80

coding-dependencies · repeat 1 · Pass

checked · responded · 2026-10-04T16:43:56.890870+00:00 UTC

Request: req_44d4b0230a60440bb0851f98f6783deb. Estimated cost: US$0.004386. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle.

Retained output

def solve(data):
    import heapq

    graph = {}
    indegree = {}

    for job, prerequisites in data.items():
        graph.setdefault(job, set())
        indegree.setdefault(job, 0)

        for prerequisite in set(prerequisites):
            graph.setdefault(prerequisite, set()).add(job)
            indegree.setdefault(prerequisite, 0)
            indegree[job] += 1

    ready = [name for name, count in indegree.items() if count == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        name = heapq.heappop(ready)
        order.append(name)

        for dependent in graph[name]:
            indegree[dependent] -= 1
            if indegree[dependent] == 0:
                heapq.heappush(ready, dependent)

    return order if len(order) == len(indegree) else None

Response SHA-256: d015f103071114b10b1090aa9e0a24ef170f44dd66c33267215cf343a85141fe

coding-fifo · repeat 1 · Pass

checked · responded · 2026-10-04T16:45:20.962872+00:00 UTC

Request: req_6c05b94a88d04c198a380b167f788d8b. Estimated cost: US$0.001552. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory.

Retained output

def solve(data):
    to_sell = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        sold_from_lot = min(quantity, to_sell)
        to_sell -= sold_from_lot
        remaining = quantity - sold_from_lot
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": to_sell,
    }

Response SHA-256: b1ad555dd07f277c09d65ea15e0705a9ff34a262fd1f870708ce054014b7c928

coding-allocate · repeat 3 · Pass

checked · responded · 2026-10-04T17:00:42.869875+00:00 UTC

Request: req_6ba6fcc297ca417fb03c3f46264ebea0. Estimated cost: US$0.001520. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    total = data["total"]
    weights = data["weights"]
    weight_sum = sum(weights)
    if not weight_sum:
        return [0] * len(weights)

    shares = [divmod(total * weight, weight_sum) for weight in weights]
    result = [share[0] for share in shares]
    leftover = total - sum(result)
    order = sorted(range(len(weights)), key=lambda i: (-shares[i][1], i))
    for i in order[:leftover]:
        result[i] += 1
    return result

Response SHA-256: 9e34c4f10a742ae1970424859b539f148b90a4564bb310ca7457ff7aa3df31da

coding-redact · repeat 2 · Pass

checked · responded · 2026-10-04T16:48:07.554821+00:00 UTC

Request: req_d0c3358d570c49c1a8abc260defc66a4. Estimated cost: US$0.002210. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    if isinstance(data, dict):
        return {
            key: solve(value)
            for key, value in data.items()
            if key.lower() not in ("password", "token", "secret")
        }
    if isinstance(data, list):
        return [solve(value) for value in data]
    return data

Response SHA-256: a60ccf7e9d7e2374d7163331c07cf64984f5ad338ca58ccab1a8d76f4741b6d0

coding-percentile · repeat 3 · Pass

checked · responded · 2026-10-04T16:59:00.272142+00:00 UTC

Request: req_b939e818886b415fb41a9672a42b2a40. Estimated cost: US$0.001654. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = sorted(data["values"])
    if not values:
        return None
    rank = max(1, math.ceil(data["p"] / 100 * len(values)))
    return values[rank - 1]

Response SHA-256: b85fdc55b939d60b04370555acbea80835f343d8e54319bc9477713c1e407ae2

coding-fifo · repeat 2 · Pass

checked · responded · 2026-10-04T16:55:44.723219+00:00 UTC

Request: req_b1ee0c151ec64588a60f8b70bc58ea0a. Estimated cost: US$0.001552. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory.

Retained output

def solve(data):
    unfilled = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        sold_from_lot = min(quantity, unfilled)
        unfilled -= sold_from_lot
        remaining = quantity - sold_from_lot
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": unfilled,
    }

Response SHA-256: dbedf4c8d19bb0d7450963b25313684c022cd82f033c8192ff9e664ff951952c

coding-redact · repeat 1 · Pass

checked · responded · 2026-10-04T16:42:17.337737+00:00 UTC

Request: req_21b4c90db85a46ebb34784e4daf5a81e. Estimated cost: US$0.002290. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    def clean(value):
        if isinstance(value, dict):
            return {
                key: clean(item)
                for key, item in value.items()
                if key.lower() not in ("password", "token", "secret")
            }
        if isinstance(value, list):
            return [clean(item) for item in value]
        return value

    return clean(data)

Response SHA-256: 6b8e618317182d43a26c1e744d00201c9d3f5b82f2e818f55c1f1225bf6afbe8

coding-rate · repeat 2 · Pass

checked · responded · 2026-10-04T16:47:02.473474+00:00 UTC

Request: req_6d4e865493f84f809957015e7eaa9ad0. Estimated cost: US$0.001474. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans.

Retained output

from collections import deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    histories = {}
    results = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        history = histories.setdefault(user, deque())
        cutoff = time - window

        while history and history[0] <= cutoff:
            history.popleft()

        accepted = len(history) < limit
        results.append(accepted)
        if accepted:
            history.append(time)

    return results

Response SHA-256: 997ee89036b09d07c424ffd61d5028a35535f7853c2cbf45eb093988f70cfd04

coding-slug · repeat 2 · Pass

checked · responded · 2026-10-04T16:47:12.892804+00:00 UTC

Request: req_8b32d9c3594b4d41a8e371986e3dad8a. Estimated cost: US$0.000980. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import re
import unicodedata

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    normalized = "".join(c for c in normalized if not unicodedata.combining(c))
    return re.sub(r"[^a-z0-9]+", "-", normalized.lower()).strip("-")

Response SHA-256: bf4c1d0afc7326a36cdecf73d51c3d25d4ff58f0a82548595c5dcd7877430bef

coding-intervals · repeat 1 · Pass

checked · responded · 2026-10-04T16:44:53.866655+00:00 UTC

Request: req_26e84f9d703646f48ce6b1a734494df9. Estimated cost: US$0.001092. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Response SHA-256: 29f08d0091266c697176599202f1f5396fdc9e34d590136ba2f306df187f5f53

coding-allocate · repeat 1 · Pass

checked · responded · 2026-10-04T16:44:33.396574+00:00 UTC

Request: req_701ae5a81ac34e9a8a42bdaed6c9a45e. Estimated cost: US$0.001670. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {total:nonnegative integer,weights:[nonnegative integer,...]}. Allocate proportionally using largest remainders: floor each share, then give leftover cents to largest fractional remainders, ties to lower index. If weights empty return []; if all zero return zeros.

Retained output

def solve(data):
    total = data["total"]
    weights = data["weights"]
    weight_sum = sum(weights)

    if weight_sum == 0:
        return [0] * len(weights)

    shares = []
    remainders = []
    for weight in weights:
        share, remainder = divmod(total * weight, weight_sum)
        shares.append(share)
        remainders.append(remainder)

    leftover = total - sum(shares)
    order = sorted(range(len(weights)), key=lambda i: (-remainders[i], i))
    for i in order[:leftover]:
        shares[i] += 1

    return shares

Response SHA-256: 51e2a94d0ae913673032e04ba0cb05cc28ae9c383df34fd6439ca53dd138c784

coding-reconcile · repeat 3 · Pass

checked · responded · 2026-10-04T16:58:15.377482+00:00 UTC

Request: req_c406d868aadb477c80825079d2bcbfc1. Estimated cost: US$0.001392. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts sorted by id, including negative overpayments. IDs are strings. Empty lists are valid.

Retained output

def solve(data):
    totals = {}
    for invoice in data["invoices"]:
        identifier = invoice["id"]
        totals[identifier] = totals.get(identifier, 0) + invoice["cents"]
    for payment in data["payments"]:
        identifier = payment["id"]
        totals[identifier] = totals.get(identifier, 0) - payment["cents"]
    return {
        identifier: totals[identifier]
        for identifier in sorted(totals)
        if totals[identifier] != 0
    }

Response SHA-256: 3cdefc216dd77e925f619860dabb3ed53fdf5a20c8211c0a12aea8bd62145ae5

coding-redact · repeat 3 · Pass

checked · responded · 2026-10-04T17:01:09.035687+00:00 UTC

Request: req_a1af76bf069d43058a8a8bfd30cd8297. Estimated cost: US$0.002440. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is arbitrary JSON. Recursively remove dictionary keys whose lowercase spelling equals password, token or secret. Preserve other values and list order; never mutate the original.

Retained output

def solve(data):
    if isinstance(data, dict):
        return {
            key: solve(value)
            for key, value in data.items()
            if key.lower() not in ("password", "token", "secret")
        }
    if isinstance(data, list):
        return [solve(value) for value in data]
    return data

Response SHA-256: 6deb10f0a8f2313f43793d20f2d689dfcef200d777cfc4d2b679ecfe4cda8f8a

coding-dedup · repeat 3 · Pass

checked · responded · 2026-10-04T16:59:34.792299+00:00 UTC

Request: req_9835fefb61d947389daafcb86665fb8b. Estimated cost: US$0.000956. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input.

Retained output

def solve(data):
    retained = {}
    for item in data:
        item_id = item["id"]
        if item_id not in retained or item["version"] >= retained[item_id]["version"]:
            retained[item_id] = item
    return [retained[item_id] for item_id in sorted(retained)]

Response SHA-256: aa181936a790f9b65a77c8d81c63143ac7ef9463b41f81850f74e1a975ff1bfc

coding-reconcile · repeat 2 · Pass

checked · responded · 2026-10-04T16:48:50.567130+00:00 UTC

Request: req_c6b078ddbd6a4261afbe9645fe9b6886. Estimated cost: US$0.001392. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts sorted by id, including negative overpayments. IDs are strings. Empty lists are valid.

Retained output

def solve(data):
    totals = {}
    for invoice in data["invoices"]:
        identifier = invoice["id"]
        totals[identifier] = totals.get(identifier, 0) + invoice["cents"]
    for payment in data["payments"]:
        identifier = payment["id"]
        totals[identifier] = totals.get(identifier, 0) - payment["cents"]
    return {
        identifier: totals[identifier]
        for identifier in sorted(totals)
        if totals[identifier] != 0
    }

Response SHA-256: a6c0ad8e9e37301356d106b3750c7de13f4d1a49edf8c2f94a37f015fc953a6d

coding-percentile · repeat 2 · Pass

checked · responded · 2026-10-04T16:47:53.692543+00:00 UTC

Request: req_a7fd660ae4e14231b8b156e7efe92f29. Estimated cost: US$0.001524. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = sorted(data["values"])
    if not values:
        return None
    rank = max(1, math.ceil(data["p"] / 100 * len(values)))
    return values[rank - 1]

Response SHA-256: 722b332daa45e7a7de0b93e99fd4b41f33cda53e03c127a4d5414e5cf074f3cd

coding-rolling · repeat 1 · Pass

checked · responded · 2026-10-04T16:45:07.807163+00:00 UTC

Request: req_c2ccfe5405ec466baf2204de40794814. Estimated cost: US$0.003494. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved.

Retained output

def solve(data):
    events = sorted(data["events"], key=lambda event: event[0])
    queries = sorted(enumerate(data["query_days"]), key=lambda item: item[1])
    results = [0] * len(queries)

    left = 0
    right = 0
    total = 0

    for index, day in queries:
        while right < len(events) and events[right][0] <= day:
            total += events[right][1]
            right += 1

        while left < right and events[left][0] < day - 6:
            total -= events[left][1]
            left += 1

        results[index] = total

    return results

Response SHA-256: 7abf8e20ba52bc710eafc66e9b203d96ed416953f75e2a9493dc1cd3aeefa583

coding-csv · repeat 1 · Pass

checked · responded · 2026-10-04T16:41:48.034658+00:00 UTC

Request: req_3fc5ab2df85940cca7fe659d2c4def73. Estimated cost: US$0.003092. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is CSV text with header customer,cents, including quoted fields. Ignore rows with a blank customer or cents that is not a signed base-10 integer. Sum by customer and return a dictionary, including zero totals. Preserve customer spelling.

Retained output

def solve(data):
    import csv
    import io
    import re

    totals = {}
    for row in csv.DictReader(io.StringIO(data)):
        customer = row.get("customer")
        cents = row.get("cents")

        if customer is None or not customer.strip() or cents is None:
            continue

        cents = cents.strip()
        if re.fullmatch(r"[+-]?[0-9]+", cents) is None:
            continue

        totals[customer] = totals.get(customer, 0) + int(cents)

    return totals

Response SHA-256: fb2f5773082064ca30e59319a1d8b5d69add9dc06c407d5348cef50d6e7ae5eb

coding-dependencies · repeat 3 · Pass

checked · responded · 2026-10-04T17:00:27.389737+00:00 UTC

Request: req_f66292c4499c44dc8e7da8643c504c2e. Estimated cost: US$0.003286. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle.

Retained output

def solve(data):
    import heapq

    names = set(data)
    for prerequisites in data.values():
        names.update(prerequisites)

    dependents = {name: [] for name in names}
    indegree = {name: 0 for name in names}

    for job, prerequisites in data.items():
        for prerequisite in set(prerequisites):
            dependents[prerequisite].append(job)
            indegree[job] += 1

    ready = [name for name in names if indegree[name] == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        name = heapq.heappop(ready)
        order.append(name)
        for job in dependents[name]:
            indegree[job] -= 1
            if indegree[job] == 0:
                heapq.heappush(ready, job)

    return order if len(order) == len(names) else None

Response SHA-256: ec2cc3fc9c2ad0d1a2a9cc779bddf10fbd84691d4c5eefa61c6de57ece651900

coding-rolling · repeat 3 · Pass

checked · responded · 2026-10-04T16:57:12.350487+00:00 UTC

Request: req_e27901ffd6a04f34acd7b0da62095961. Estimated cost: US$0.003194. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved.

Retained output

def solve(data):
    events = sorted(data["events"])
    queries = sorted(enumerate(data["query_days"]), key=lambda item: item[1])
    totals = [0] * len(queries)
    left = right = 0
    running_total = 0

    for index, day in queries:
        while right < len(events) and events[right][0] <= day:
            running_total += events[right][1]
            right += 1

        start = day - 6
        while left < right and events[left][0] < start:
            running_total -= events[left][1]
            left += 1

        totals[index] = running_total

    return totals

Response SHA-256: 567a5d6a4cf3827872f181161c7a3ee9ed96b67d742283d10f60e8bc75a65420

coding-reconcile · repeat 1 · Pass

checked · responded · 2026-10-04T16:43:41.208432+00:00 UTC

Request: req_ffaeda10c52b4f43992f24eb124ca312. Estimated cost: US$0.001302. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input has invoices and payments lists of {id, cents}. Sum amounts by id; payments subtract from invoices. Return a dict of nonzero outstanding amounts sorted by id, including negative overpayments. IDs are strings. Empty lists are valid.

Retained output

def solve(data):
    totals = {}
    for invoice in data["invoices"]:
        key = invoice["id"]
        totals[key] = totals.get(key, 0) + invoice["cents"]
    for payment in data["payments"]:
        key = payment["id"]
        totals[key] = totals.get(key, 0) - payment["cents"]
    return {key: totals[key] for key in sorted(totals) if totals[key] != 0}

Response SHA-256: ccc0d2f010f811c47b6e71f4743df6b961b303965db83cadffce27ace005d8db

coding-csv · repeat 3 · Fail

checked · responded · 2026-10-04T16:58:49.338556+00:00 UTC

Request: req_43821460b7b14a1e89a5c4bb5f5f13b5. Estimated cost: US$0.004312. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is CSV text with header customer,cents, including quoted fields. Ignore rows with a blank customer or cents that is not a signed base-10 integer. Sum by customer and return a dictionary, including zero totals. Preserve customer spelling.

Retained output

def solve(data):
    import csv
    import io
    import re

    totals = {}
    for row in csv.DictReader(io.StringIO(data)):
        customer = row.get("customer")
        cents = row.get("cents")
        if customer is None or not customer.strip():
            continue
        if cents is None or re.fullmatch(r"[+-]?[0-9]+", cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents, 10)

    return totals

Response SHA-256: 7035b6f1236061da37cd97bf2e91491ee1ad663b13e911baebcd0c36a7149622

coding-percentile · repeat 1 · Pass

checked · responded · 2026-10-04T16:40:42.578598+00:00 UTC

Request: req_b8cf1f38a76349eebf04b08d83ad762b. Estimated cost: US$0.001374. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {values:[finite numbers,...],p:number in [0,100]}. Return nearest-rank percentile: sorted values at 1-based rank max(1,ceil(p/100*n)). Return null for no values. Do not interpolate or mutate input.

Retained output

import math

def solve(data):
    values = sorted(data["values"])
    if not values:
        return None
    rank = max(1, math.ceil(data["p"] / 100 * len(values)))
    return values[rank - 1]

Response SHA-256: 758b1aa9011e6117897de25169583fbbe04e447d30233a5f17442cb82ccf65f8

coding-fifo · repeat 3 · Pass

checked · responded · 2026-10-04T16:56:41.043158+00:00 UTC

Request: req_42fa6774d99c42c2a9352febba3730ca. Estimated cost: US$0.001632. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {lots:[[quantity,unit_cents],...], sold:nonnegative integer}. Sell in lot order. Return {remaining_units,remaining_value_cents,unfilled_units}. All quantities/prices nonnegative; unfilled is sales beyond available inventory.

Retained output

def solve(data):
    unsold_demand = data["sold"]
    remaining_units = 0
    remaining_value_cents = 0

    for quantity, unit_cents in data["lots"]:
        sold_from_lot = min(quantity, unsold_demand)
        unsold_demand -= sold_from_lot
        remaining = quantity - sold_from_lot
        remaining_units += remaining
        remaining_value_cents += remaining * unit_cents

    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": unsold_demand,
    }

Response SHA-256: 5e982caf41f0faa83e14db72d645d455ccea5fc3504ed2c2d5a174f269996b63

coding-intervals · repeat 2 · Pass

checked · responded · 2026-10-04T16:48:39.890054+00:00 UTC

Request: req_a5e4faa7dd074bfdb7263c45288255ca. Estimated cost: US$0.001092. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Response SHA-256: 5ed1e4c6bac5c678c03c9778a86a81af538b960a1befed3e23392848910cf460

coding-intervals · repeat 3 · Pass

checked · responded · 2026-10-04T16:56:51.573105+00:00 UTC

Request: req_35806b21ae8d472eb10a64b846920b7d. Estimated cost: US$0.001112. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of [start,end] integer half-open intervals, with start<=end. Drop empty intervals; merge overlapping or touching intervals. Return sorted merged intervals without mutating input.

Retained output

def solve(data):
    intervals = sorted((start, end) for start, end in data if start < end)
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            if end > merged[-1][1]:
                merged[-1][1] = end
        else:
            merged.append([start, end])
    return merged

Response SHA-256: 6cdbcdeee73a2379963bb5acb31de5b05374c401ffdae5bdad69831aceeb326d

coding-slug · repeat 1 · Pass

checked · responded · 2026-10-04T16:44:44.078219+00:00 UTC

Request: req_fee4f4a33b3244ac94c2bc394a41bee7. Estimated cost: US$0.000980. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import unicodedata
import re

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    text = "".join(char for char in normalized if not unicodedata.combining(char))
    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")

Response SHA-256: b9628af685e5fa5987e1cced64f06f3fa286433708797e16f22e4f2a1202e568

coding-rolling · repeat 2 · Pass

checked · responded · 2026-10-04T16:46:29.269583+00:00 UTC

Request: req_4ac75992a87548289b0fe29170055b4e. Estimated cost: US$0.003474. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {events:[[day,count],...], query_days:[integer,...]}. Return totals for each query day covering inclusive days q-6 through q. Events can be unsorted, repeated or negative-day; count is nonnegative. Query order must be preserved.

Retained output

def solve(data):
    events = sorted(data["events"], key=lambda event: event[0])
    queries = sorted(enumerate(data["query_days"]), key=lambda item: item[1])
    totals = [0] * len(queries)

    left = 0
    right = 0
    total = 0
    n = len(events)

    for index, day in queries:
        while right < n and events[right][0] <= day:
            total += events[right][1]
            right += 1

        start = day - 6
        while left < right and events[left][0] < start:
            total -= events[left][1]
            left += 1

        totals[index] = total

    return totals

Response SHA-256: 99ebaba816b882d12ec263b179d1e92982a2b0930dce2acfd401f94ba46db87f

coding-rate · repeat 1 · Pass

checked · responded · 2026-10-04T16:42:29.026462+00:00 UTC

Request: req_fc8a846b0756468bba40626205233ebd. Estimated cost: US$0.001594. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is {limit:positive integer,window:positive integer,events:[{user,time},...]}. Times are nondecreasing integer seconds. Process in input order. Accept only when fewer than limit previously accepted events for that user have times strictly greater than time-window. Rejections do not consume allowance. Return a list of booleans.

Retained output

def solve(data):
    from collections import deque

    limit = data["limit"]
    window = data["window"]
    accepted = {}
    result = []

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        cutoff = time - window

        if user not in accepted:
            accepted[user] = deque()
        times = accepted[user]

        while times and times[0] <= cutoff:
            times.popleft()

        allowed = len(times) < limit
        result.append(allowed)
        if allowed:
            times.append(time)

    return result

Response SHA-256: c50105ee1ee6b12f3a9ce460d9ea5c5a55059e63dda298e7344ffde063282a08

coding-slug · repeat 3 · Pass

checked · responded · 2026-10-04T17:00:09.455152+00:00 UTC

Request: req_9b3b31ad3aca4113a61871c7a2264040. Estimated cost: US$0.001630. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a string. Apply Unicode NFKD normalization, drop combining marks, lowercase, retain only ASCII a-z and digits, replace each run of other characters with one hyphen, strip edge hyphens. Return the slug.

Retained output

import unicodedata

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    normalized = "".join(
        char for char in normalized if not unicodedata.combining(char)
    ).lower()

    result = []
    pending_hyphen = False
    for char in normalized:
        if "a" <= char <= "z" or "0" <= char <= "9":
            if pending_hyphen and result:
                result.append("-")
            result.append(char)
            pending_hyphen = False
        else:
            pending_hyphen = True

    return "".join(result)

Response SHA-256: 0aabeb4b65394906ecd0bb0d4a4d92ac6eda5a04a74a37538ac25a4851f06dfe

coding-csv · repeat 2 · Fail

checked · responded · 2026-10-04T16:55:23.761531+00:00 UTC

Request: req_94f6fbd776e542e482126055557009f1. Estimated cost: US$0.003822. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is CSV text with header customer,cents, including quoted fields. Ignore rows with a blank customer or cents that is not a signed base-10 integer. Sum by customer and return a dictionary, including zero totals. Preserve customer spelling.

Retained output

import csv
import io
import re


def solve(data):
    totals = {}
    for row in csv.DictReader(io.StringIO(data)):
        customer = row.get("customer")
        cents = row.get("cents")
        if customer is None or not customer.strip():
            continue
        if cents is None or re.fullmatch(r"[+-]?[0-9]+", cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents, 10)
    return totals

Response SHA-256: a4e62ba67117ffac6063dcb810d600d1de87597f3033fa781a9dcc7458e4e6c0

coding-dependencies · repeat 2 · Pass

checked · responded · 2026-10-04T16:48:29.986269+00:00 UTC

Request: req_60c3ca1cf66348df8d7973da825ef2f8. Estimated cost: US$0.002276. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a dict mapping each named job to prerequisite names. Include names referenced only as prerequisites. Return the lexicographically smallest valid topological order, choosing the smallest ready name at every step. Return null for any cycle.

Retained output

import heapq


def solve(data):
    nodes = set(data)
    for prerequisites in data.values():
        nodes.update(prerequisites)

    indegree = {name: 0 for name in nodes}
    dependents = {name: [] for name in nodes}

    for job, prerequisites in data.items():
        for prerequisite in set(prerequisites):
            dependents[prerequisite].append(job)
            indegree[job] += 1

    ready = [name for name in nodes if indegree[name] == 0]
    heapq.heapify(ready)
    order = []

    while ready:
        name = heapq.heappop(ready)
        order.append(name)
        for job in dependents[name]:
            indegree[job] -= 1
            if indegree[job] == 0:
                heapq.heappush(ready, job)

    return order if len(order) == len(nodes) else None

Response SHA-256: fe0bcb4cecd5db3f563c68e212d7696bf90e425bc6d7a08cb1fc7ac03cebe62e

coding-dedup · repeat 2 · Pass

checked · responded · 2026-10-04T16:56:20.166833+00:00 UTC

Request: req_9e9806c8b7e3485a954ac5672d1d251f. Estimated cost: US$0.001676. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input.

Retained output

def solve(data):
    latest = {}
    for item in data:
        identifier = item["id"]
        if identifier not in latest or item["version"] >= latest[identifier]["version"]:
            latest[identifier] = item
    return [latest[identifier] for identifier in sorted(latest)]

Response SHA-256: a0d2956635c3da194e5107245a99a0f9d353353fb6395fdb0fd02db4c790fa74

coding-dedup · repeat 1 · Pass

checked · responded · 2026-10-04T16:41:16.842593+00:00 UTC

Request: req_d88020519f884ab1bf439db892fa2098. Estimated cost: US$0.000956. Billed cost: unreconciled.

Exact prompt

Implement solve(data) in Python 3.9. Allowed imports: math, json, csv, io, re, collections, heapq, unicodedata. Use functions and built-in types; no custom classes, private/dunder attributes, globals/nonlocals, or async. Return only Python code, with no Markdown. Do not read files, use the network, run processes or access system state. Input is a list of {id, version, value}. Keep the highest version for each id; on equal version keep the last occurrence. Return the retained objects sorted lexicographically by id. Do not mutate the input.

Retained output

def solve(data):
    retained = {}
    for item in data:
        item_id = item["id"]
        if item_id not in retained or item["version"] >= retained[item_id]["version"]:
            retained[item_id] = item
    return [retained[item_id] for item_id in sorted(retained)]

Response SHA-256: 1d14614ef9629a22b6f26b709779ca01f8f2b1e26503f51888d767b1100f76db

Math

Insufficient evidence

Two adjacent completed weeks need comparable cohorts. Missing weeks and changed contracts cannot establish a trend.

tested-best-bank-v2-reviewed

Separate measurement contract · 1 measured cohort · ec56633cf32c

Each dot is one measured cohort. Bars summarize task/repeat variation; they do not estimate week-to-week noise from one cohort. No interpolation across missing weeks.

math measurements and service behavior
Measured UTC	Pass rate	95% band	Attempts	Responses	Provider failures	Median latency	Capped / refusal flags	Receipts
2026-10-05 05:54	100.0%	100.0%–100.0%	36 / 36	36 / 36	0	2.80 s	0 / 0	Original JSON

Measurement contract and limitations

Task-bank SHA-256: fce29b4d66cfddeab39632d451935271a37df595374b40eacd300201e3726291
Protocol SHA-256: 90b114dd8a70ecbf3aecc35f58cea1ba85c786554aee9835a38a1c518293da05
Grader contract: 62980813a06357fd89c914858db26855ffe2bd65a7e18f326d827fb6610e7e23
Model configuration: 04e4af3ce275b597cf00f2c7dc53d1c4bd14f4df1016870506fb403d1da26a0e

One point is one cohort, not a week of daily tests.

Exact returned model identity was validated by the source runner; the public projection exposes the admitted ID and response hash.

Hidden fixtures and private transport responses remain with the source owner.

Inspect 36 retained attempts

math-margin · repeat 3 · Pass

correct · responded · 2026-10-05T05:52:42.322275+00:00 UTC

Request: req_6a4ca5e37d09439594b7a1c1d43e5a27. Estimated cost: US$0.001452. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: margin_percent, profit, revenue. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"margin_percent":26.23076923076923,"profit":1841.4,"revenue":7020}

Response SHA-256: 364f397b68908cb7b776d8294f640934631279f3870d458d9e7a3f2192e758b7

math-discount · repeat 3 · Pass

correct · responded · 2026-10-05T05:50:42.677992+00:00 UTC

Request: req_64e1fea55e4646cfb8d94dc1daaf24f1. Estimated cost: US$0.000720. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: discount_percent, final_price. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"discount_percent":32,"final_price":183.6}

Response SHA-256: 485f159aa1f411c2e85a1f0b5affeed346b9b848c5b9cf656b51170973d44de3

math-npv · repeat 2 · Pass

correct · responded · 2026-10-05T05:46:05.406321+00:00 UTC

Request: req_6e42714db6e84eaeb1c534c5c32fc35f. Estimated cost: US$0.001558. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: npv. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"npv":-5.259203606311045}

Response SHA-256: e8b312103347023f721b2df377f2ab5d916c93a31578e854a12fc8b8e40169e4

math-capacity · repeat 1 · Pass

correct · responded · 2026-10-05T05:43:35.204871+00:00 UTC

Request: req_d57649bd78874249b04d115229a3f162. Estimated cost: US$0.001452. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a, b. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a, b, contribution. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: e7b675d04649ae62e19df5f57f2111628e641af0e550f8b19ee86355d8187b52

math-weighted · repeat 3 · Pass

correct · responded · 2026-10-05T05:51:52.441284+00:00 UTC

Request: req_85f00e40c1d94191b7e71810c4df6e1c. Estimated cost: US$0.000920. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: change_points, week1_percent, week2_percent. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"change_points":10.5,"week1_percent":6.5,"week2_percent":17}

Response SHA-256: db5228df51bb687975e4df259af57228fe3fa8136d55e85eae88d35861ca6d98

math-mix · repeat 3 · Pass

correct · responded · 2026-10-05T05:54:31.090730+00:00 UTC

Request: req_a24a78a4a5d74f8fb4aed0a74fcb4e90. Estimated cost: US$0.000904. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: litres_20, litres_60. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: b23b65f6536c4ac3d153a052c80f2757b42884784b3faae6246fc9f57bf2d62c

math-bayes · repeat 1 · Pass

correct · responded · 2026-10-05T05:41:46.001387+00:00 UTC

Request: req_4af4975e97ee442e92d26858d4e43946. Estimated cost: US$0.000834. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: b5a9ac93fedbd02c914e64709bc5dae5508a14ce2a1f0ec5efdc5c97308a2877

math-npv · repeat 3 · Pass

correct · responded · 2026-10-05T05:52:53.817915+00:00 UTC

Request: req_0a2eb006801447d4848e2ebbfb773682. Estimated cost: US$0.001798. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: npv. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"npv":-5.259203606311045}

Response SHA-256: d2d22912f330acee0b5df171bbd05972336033cffc19caf72e1b2103a9ebcc3e

math-bayes · repeat 3 · Pass

correct · responded · 2026-10-05T05:51:03.250951+00:00 UTC

Request: req_93da05ba2bbc44d7959927b1693a8556. Estimated cost: US$0.000824. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: 459c9104fd37e105f83047448bc7d48c0890122256fde81098de3d096fac9c5f

math-variance · repeat 3 · Pass

correct · responded · 2026-10-05T05:50:18.726083+00:00 UTC

Request: req_aa5a0513a9c649819533a336d20f9414. Estimated cost: US$0.001154. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: c5d71a2913491502108b188d1b7d19c128408d3c2dda3fc5740472d7b5b4828b

math-bayes · repeat 2 · Pass

correct · responded · 2026-10-05T05:49:51.264061+00:00 UTC

Request: req_13c2e3d2e4924a568944f69c6b848f51. Estimated cost: US$0.000924. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: 99d9e2974aac1b4df09e83be534070946677aa909515196418b8c4e9189b3f27

math-margin · repeat 2 · Pass

correct · responded · 2026-10-05T05:49:24.817678+00:00 UTC

Request: req_875ad2dd41fc4bb98a56be4be840db33. Estimated cost: US$0.001822. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: margin_percent, profit, revenue. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"margin_percent":26.23076923076923,"profit":1841.4,"revenue":7020}

Response SHA-256: 67500d0e84fa51511c0a12d4d62cb4a491921514b5b9b77a7de7f4d44cd74b7c

math-allocation · repeat 3 · Pass

correct · responded · 2026-10-05T05:54:37.294614+00:00 UTC

Request: req_8e2adb6d5f4142aba57322c2e7562a83. Estimated cost: US$0.000838. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a_cents, b_cents, c_cents. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: 442d0fdf4b0f415878e9d70d03998b48e1a60f56f84f901a821491dcd72bace6

math-variance · repeat 1 · Pass

correct · responded · 2026-10-05T05:44:35.737777+00:00 UTC

Request: req_273f9fb3f6b7417982a85756d1a93e39. Estimated cost: US$0.001144. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: dabb4a8b000b3f746aa5bcc4e5207da9924aebcdffa73ddb37529c485c56b79b

math-variance · repeat 2 · Pass

correct · responded · 2026-10-05T05:49:58.176834+00:00 UTC

Request: req_333386e535524a7aa62a8e1c7437b498. Estimated cost: US$0.001004. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: 411c0978cff9cce0077b1c5cee661eb08743c76532aa4f829669bfeb7c133ce1

math-loan · repeat 2 · Pass

correct · responded · 2026-10-05T05:46:45.609994+00:00 UTC

Request: req_b7837355f52d4ccc96dec46d1b98f099. Estimated cost: US$0.004248. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: interest, payment. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"interest":1557.160000300236,"payment":564.8816666791765}

Response SHA-256: 5c4864aed0f9f056f75492ca7845d0d4f702013e270f01f80fe43f8e367f48d3

math-queue · repeat 3 · Pass

correct · responded · 2026-10-05T05:54:12.836912+00:00 UTC

Request: req_cf0e6d8878d94867b3926c9226050e0e. Estimated cost: US$0.001256. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: expected_attempts, success_probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"expected_attempts":1.058808,"success_probability":0.996541619136}

Response SHA-256: 628b929a8115faf4e7cbea25ee2ef1f68c8e0d83dba07742c6e3f762e4491140

math-mix · repeat 1 · Pass

correct · responded · 2026-10-05T05:41:57.448746+00:00 UTC

Request: req_c21f462d9d264b4fa5a5d81e18c0ecb3. Estimated cost: US$0.000634. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: litres_20, litres_60. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: e3f3fec296c2ef3259010a3f081eff9255a570c399e635f709b23e76dd5a999f

math-queue · repeat 1 · Pass

correct · responded · 2026-10-05T05:44:43.404196+00:00 UTC

Request: req_1d1a3fe19cfd4491806cbdc5675e2707. Estimated cost: US$0.001276. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: expected_attempts, success_probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"expected_attempts":1.058808,"success_probability":0.996541619136}

Response SHA-256: e04c90fde6e57632df835f21b9ff2e72a0394ec2de93c97a05720734af8490dd

math-loan · repeat 3 · Pass

correct · responded · 2026-10-05T05:51:34.479528+00:00 UTC

Request: req_92e5db5b81414f73ace27d70c6cd628e. Estimated cost: US$0.005058. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: interest, payment. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"interest":1557.1600003002552,"payment":564.8816666791773}

Response SHA-256: 284f2906657a37c4284365a36d635a094e81e4d85b6da97e32d84d38f1c85ed4

math-mix · repeat 2 · Pass

correct · responded · 2026-10-05T05:47:19.564576+00:00 UTC

Request: req_6d64020a982346a18336085d931dad6c. Estimated cost: US$0.000674. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: litres_20, litres_60. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: ce0344cb85d6d09077c202ea5ec3114b1b6e012ba188ca2c405598bc63930265

math-discount · repeat 2 · Pass

correct · responded · 2026-10-05T05:49:40.030629+00:00 UTC

Request: req_3f5f3e05b890469f8db44def2c3b4e19. Estimated cost: US$0.000750. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: discount_percent, final_price. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"discount_percent":32,"final_price":183.6}

Response SHA-256: 6a31f3b62f932b8e02e9cc5056eb4f78d3b73ac8d660dc888947810649bbe7f0

math-weighted · repeat 2 · Pass

correct · responded · 2026-10-05T05:50:13.584656+00:00 UTC

Request: req_65aad06c4162490faf3b210d91505215. Estimated cost: US$0.000910. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: change_points, week1_percent, week2_percent. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"change_points":10.5,"week1_percent":6.5,"week2_percent":17}

Response SHA-256: d86cb69d516ab5a5797dab9532f7016faf7fc899a77411c46f07c823c7a09603

math-break-even · repeat 1 · Pass

correct · responded · 2026-10-05T05:44:53.215384+00:00 UTC

Request: req_af31558a76ef4219a0c9a6d108648cc5. Estimated cost: US$0.000840. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): units. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: profit, units. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"profit":0,"units":100}

Response SHA-256: 8248de191fdfc81cb14c18763f1f97bd802d27deb84d00fde04a10015c1f4c38

math-break-even · repeat 3 · Pass

correct · responded · 2026-10-05T05:53:13.248786+00:00 UTC

Request: req_d421f584eff24f6c93a090cb7719f29b. Estimated cost: US$0.000790. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): units. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: profit, units. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"profit":0,"units":100}

Response SHA-256: 4011d19015e3b4fec1575d5d8effc97f6817707a1be68266720a93938eecddb8

math-capacity · repeat 3 · Pass

correct · responded · 2026-10-05T05:51:13.013474+00:00 UTC

Request: req_6e1ef4cfe5e046afa716bc8c914218ea. Estimated cost: US$0.001542. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a, b. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a, b, contribution. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: 7aa435d0921752f6650b60a831b5e086fa5761681e684d0dd42f4cd821d4162a

math-loan · repeat 1 · Pass

correct · responded · 2026-10-05T05:43:13.393366+00:00 UTC

Request: req_9910ae1300264b2088b34dfb2e92e734. Estimated cost: US$0.004958. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: interest, payment. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"interest":1557.160000300248,"payment":564.881666679177}

Response SHA-256: f83af5e795011de8722f884fb857a9cfb742cc8432ba8ec4e04b758f61375525

math-queue · repeat 2 · Pass

correct · responded · 2026-10-05T05:48:07.080907+00:00 UTC

Request: req_45bdbf84515f443ea987a59df4bfeb7b. Estimated cost: US$0.001296. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: expected_attempts, success_probability. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"expected_attempts":1.058808,"success_probability":0.996541619136}

Response SHA-256: 41279bc54bf5896903ef039f31ac2179af614fc5c23a5dc05b6b0376de41b7a5

math-margin · repeat 1 · Pass

correct · responded · 2026-10-05T05:44:05.424312+00:00 UTC

Request: req_688fbd36207e4b19a42f093676368a43. Estimated cost: US$0.001442. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: margin_percent, profit, revenue. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"margin_percent":26.23076923076923,"profit":1841.4,"revenue":7020}

Response SHA-256: 1948105292d5762be71e7ba87f44755fe24f4f22f39d028d9a83b085db5b0522

math-allocation · repeat 2 · Pass

correct · responded · 2026-10-05T05:48:31.538572+00:00 UTC

Request: req_043151a2d850473ea5998f3e273e2e71. Estimated cost: US$0.000838. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a_cents, b_cents, c_cents. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: cb341e42282f73623243d822a4fca04e70b7cc88b4074aa08b8e6df28e21fbad

math-discount · repeat 1 · Pass

correct · responded · 2026-10-05T05:42:17.156927+00:00 UTC

Request: req_8a7cc2d882b14eab9d3f3c1ecdf15b2c. Estimated cost: US$0.000770. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: discount_percent, final_price. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"discount_percent":32,"final_price":183.6}

Response SHA-256: 51ebefaa0e31714511feb3c08cd22ad49f665a9d83217944cc4d2c128d4b5b43

math-allocation · repeat 1 · Pass

correct · responded · 2026-10-05T05:43:43.041515+00:00 UTC

Request: req_860160dfb4bc44429dd02cb4954587c8. Estimated cost: US$0.000868. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a_cents, b_cents, c_cents. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: 46dbe1249e9fd2e4f51d0c33720e818689e1e3390a14058b2731c17b1ffb0687

math-weighted · repeat 1 · Pass

correct · responded · 2026-10-05T05:42:22.775252+00:00 UTC

Request: req_2decc10814054f8f8b167e0b431262b4. Estimated cost: US$0.000910. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: change_points, week1_percent, week2_percent. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"change_points":10.5,"week1_percent":6.5,"week2_percent":17}

Response SHA-256: 5c3d97b204631cca58c6b9d54d47b4b38b57844d6fc511360d3274057d75cc5f

math-npv · repeat 1 · Pass

correct · responded · 2026-10-05T05:43:53.333291+00:00 UTC

Request: req_cc42731b02cd44eaac6a6d8f65fcb2ba. Estimated cost: US$0.001768. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: npv. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"npv":-5.259203606311044}

Response SHA-256: 67d1f640293f38fce23533dbb2472486ba6e9fe7a11d3e7b899d2ac82b80b1ef

math-break-even · repeat 2 · Pass

correct · responded · 2026-10-05T05:47:54.013437+00:00 UTC

Request: req_87fb7c0b5f654f4cab89d0118da62bf0. Estimated cost: US$0.000790. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): units. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: profit, units. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"profit":0,"units":100}

Response SHA-256: 1d438189dbcf55edd681caf9f9c130e3eecef81a9e16faf53719d93d3f9d1d8e

math-capacity · repeat 2 · Pass

correct · responded · 2026-10-05T05:47:48.557956+00:00 UTC

Request: req_b94b78d3a6804b6e9b9a7372d990d1af. Estimated cost: US$0.001002. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return exact values when representable as terminating decimals. For nonterminating values, provide at least 10 significant digits; do not round intermediate values or final answers to cents or two decimal places. These fields require exact integer-valued numbers (1 and 1.0 are equivalent): a, b. All other numeric fields use absolute tolerance 0.000001 or relative tolerance 0.00000001. Return exactly one JSON object with these keys: a, b, contribution. Numeric fields must be finite numbers. Use each requested key once, no extra keys, no numeric strings, booleans, Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: 0a412b430836c3247c18b37e0299c422529f78ab3e4fc296756371196dbca241

tested-best-bank-v1

Separate measurement contract · 1 measured cohort · db00b0c82d7a

Each dot is one measured cohort. Bars summarize task/repeat variation; they do not estimate week-to-week noise from one cohort. No interpolation across missing weeks.

math measurements and service behavior
Measured UTC	Pass rate	95% band	Attempts	Responses	Provider failures	Median latency	Capped / refusal flags	Receipts
2026-10-04 17:01	83.3%	58.3%–100.0%	36 / 36	36 / 36	0	2.96 s	0 / 0	Original JSON Correction

Measurement contract and limitations

Task-bank SHA-256: 8ad4dea4fe0b53a67184c305f645a228a1a0d48425a7787bae5990c7e7fd023e
Protocol SHA-256: 06e5a0f38a9ad3b58d5afad4822ef747debe2a458340a5e752ea6d016aaa7f52
Grader contract: 62980813a06357fd89c914858db26855ffe2bd65a7e18f326d827fb6610e7e23
Model configuration: 04e4af3ce275b597cf00f2c7dc53d1c4bd14f4df1016870506fb403d1da26a0e

One point is one cohort, not a week of daily tests.

Exact returned model identity was validated by the source runner; the public projection exposes the admitted ID and response hash.

Hidden fixtures and private transport responses remain with the source owner.

v1 uses the disclosed offline correction. Original grades remain in each affected receipt.

Inspect 36 retained attempts

math-queue · repeat 1 · Pass

correct · responded · 2026-10-04T16:44:18.088382+00:00 UTC

Request: req_5e267d6afbaa4426ab510aa69530c112. Estimated cost: US$0.001198. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return only a JSON object with these keys: success_probability, expected_attempts. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"success_probability":0.996541619136,"expected_attempts":1.058808}

Response SHA-256: 961ca0a46db7da80a34d7f017adf668d25fe1525cb866799d320a049198d49fa

math-margin · repeat 2 · Fail

answer_mismatch · responded · 2026-10-04T16:55:34.460045+00:00 UTC

Request: req_87ddbe7ca93042418c35469678a628e9. Estimated cost: US$0.001524. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return only a JSON object with these keys: revenue, profit, margin_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"revenue":7020,"profit":1841.4,"margin_percent":26.23}

Response SHA-256: 30e15d5795c88cb63ea4af0fd9eb233861e9120e1cb4af094d88ae75ba5e8eff

math-loan · repeat 3 · Fail

answer_mismatch · responded · 2026-10-04T16:57:54.312542+00:00 UTC

Request: req_0ab05fafedc3497cafd03ea4b1b27ae2. Estimated cost: US$0.002050. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return only a JSON object with these keys: payment, interest. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"payment":564.88,"interest":1557.16}

Response SHA-256: 7090a049f2e2a0f48c6f3f2c07b4642d83c0b1001bf4252c2e5a7124182ba1b7

math-variance · repeat 3 · Pass

correct · responded · 2026-10-04T16:56:31.391664+00:00 UTC

Request: req_0b8bd2fdfb734e0eb0eb76b68b04281e. Estimated cost: US$0.000896. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return only a JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: 74128b1c32ff90ef7ceb8f6874e3906d895ec074af018c4b6b393b51b800f304

math-discount · repeat 3 · Pass

correct · responded · 2026-10-04T16:56:57.589294+00:00 UTC

Request: req_9d716d9d4fdf465e8fdb2b191be97ff5. Estimated cost: US$0.000622. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return only a JSON object with these keys: final_price, discount_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"final_price":183.6,"discount_percent":32}

Response SHA-256: 710c7db03d2fb5881f0cbff8ef3eac8d938f8aa04d3dcc46ca03ffa6e3f35e27

math-variance · repeat 1 · Pass

correct · responded · 2026-10-04T16:44:09.918934+00:00 UTC

Request: req_093ce91d0b3c430b8c716a867f9e1856. Estimated cost: US$0.000856. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return only a JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: e4ba5470480ad20f939de0a4b1d63f1909fb68ca454dc0fd43b17981c42dfa97

math-break-even · repeat 3 · Pass

correct · responded · 2026-10-04T16:59:41.161172+00:00 UTC

Request: req_18c5424b15e3448aa2a991612a10c48b. Estimated cost: US$0.000692. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return only a JSON object with these keys: units, profit. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"units":100,"profit":0}

Response SHA-256: 2e812d4a65312ab078b11ed760f4b4ff79752ea6e42827428a34f0fe67f6a57a

math-npv · repeat 3 · Pass

correct · responded · 2026-10-04T16:59:21.288022+00:00 UTC

Request: req_e916687448a04f9e9d95d1358f3c0826. Estimated cost: US$0.001680. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return only a JSON object with these keys: npv. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"npv":-5.259203606311044}

Response SHA-256: 3d9ff74982171ddaf6a096e1760e706d50653682c26bf4fe5f96e31e2f8e58be

math-bayes · repeat 3 · Pass

correct · responded · 2026-10-04T16:57:22.988604+00:00 UTC

Request: req_a6e876bbacfa40ccb7e820bcdb0f7526. Estimated cost: US$0.000626. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return only a JSON object with these keys: probability. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: 9adc39a09719f741057d027d41cc78076fac2c8fe286b57df645e92f0bc43753

math-capacity · repeat 3 · Pass

correct · responded · 2026-10-04T16:57:32.903129+00:00 UTC

Request: req_71515d14f5a9422189c3aa26d6918745. Estimated cost: US$0.001130. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return only a JSON object with these keys: a, b, contribution. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: cb172488dd8f250e39b81295b725729904389454169ec2a5b33f80ad49d83f0f

math-npv · repeat 2 · Pass

correct · responded · 2026-10-04T16:45:42.126106+00:00 UTC

Request: req_dc4232480b874f46bf30556a6d898a2d. Estimated cost: US$0.002670. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return only a JSON object with these keys: npv. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"npv":-5.259203606311044}

Response SHA-256: 6611bf5c22ec2f130dc9a5f89620b9b7c7e962d675ffbd5f40eb52b874218225

math-loan · repeat 2 · Fail

answer_mismatch · responded · 2026-10-04T16:46:13.453895+00:00 UTC

Request: req_e3587de7417c47ce9a94fbe94320e3c8. Estimated cost: US$0.004150. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return only a JSON object with these keys: payment, interest. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"payment":564.88,"interest":1557.16}

Response SHA-256: 33c07cbe634631b602fdca9153daf03b0e0914bcecf6594ace26342a406cafc7

math-mix · repeat 1 · Pass

correct · responded · 2026-10-04T16:41:09.779920+00:00 UTC

Request: req_c27af42bb7cd43bebc246f50b7052f3e. Estimated cost: US$0.000556. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return only a JSON object with these keys: litres_20, litres_60. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: 37af6899f4f33c780c25495135019429faa61af7545e856d3b8489da41daf7cc

math-variance · repeat 2 · Pass

correct · responded · 2026-10-04T16:56:07.399309+00:00 UTC

Request: req_711abb2229db4c538fab69d9e7b19ec5. Estimated cost: US$0.000876. Billed cost: unreconciled.

Exact prompt

For observations 4, 7, 7, 10, 12 calculate the arithmetic mean, unbiased sample variance (denominator n-1), and standard error of the mean. Return only a JSON object with these keys: mean, sample_variance, standard_error. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"mean":8,"sample_variance":9.5,"standard_error":1.378404875209022}

Response SHA-256: a6801766959782b58bcf153577d614bb6f277759def7b953bd4f259a31d35dac

math-queue · repeat 3 · Pass

correct · responded · 2026-10-04T17:00:51.636377+00:00 UTC

Request: req_86e0c740118f46e9a0e4c39f29c4792a. Estimated cost: US$0.000978. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return only a JSON object with these keys: success_probability, expected_attempts. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"success_probability":0.996541619136,"expected_attempts":1.058808}

Response SHA-256: 0ccb74f54ec44e3726a1ff99efd047778f5a25b8dbb16edaf1ec533c5c3cfe0f

math-mix · repeat 2 · Pass

correct · responded · 2026-10-04T16:46:51.316642+00:00 UTC

Request: req_d85e3deae1d74361913ffe35c07dcc8b. Estimated cost: US$0.000676. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return only a JSON object with these keys: litres_20, litres_60. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: ccda05ec0b9d0f37acf0bfb2611ea1025dd565aa72c3049958311384bc0c445b

math-capacity · repeat 2 · Pass

correct · responded · 2026-10-04T16:47:23.374581+00:00 UTC

Request: req_cf62b3fd4c374b6c8923a08355c212b1. Estimated cost: US$0.001140. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return only a JSON object with these keys: a, b, contribution. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: d9f83378aa5ccbebbc1fd966672f15e45f8d421ba78454a8d297b98bd3160dc7

math-margin · repeat 1 · Fail

answer_mismatch · responded · 2026-10-04T16:43:32.493199+00:00 UTC

Request: req_753585bdbcc94cc5826d6911f693a867. Estimated cost: US$0.001394. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return only a JSON object with these keys: revenue, profit, margin_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"revenue":7020,"profit":1841.4,"margin_percent":26.23}

Response SHA-256: 4adfe7577cd2429fe72f574f1841b26534472ba235b44f64a87190b172014a24

math-allocation · repeat 2 · Pass

correct · responded · 2026-10-04T16:48:12.592072+00:00 UTC

Request: req_cdaa69beb42f422c812e6f2e6c9be679. Estimated cost: US$0.000650. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return only a JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: a180d96842c43373a9c23a8de2d450abf1f44bc99903dede5b837414d67dda2e

math-break-even · repeat 2 · Pass

correct · responded · 2026-10-04T16:47:30.293149+00:00 UTC

Request: req_a0d54159b2dc4175b0517f31b7b8627b. Estimated cost: US$0.000952. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return only a JSON object with these keys: units, profit. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"units":100,"profit":0}

Response SHA-256: d7b33d8a9756eff28c02c4155cefc077bda74cb745bc72192ac63ddc6f8db955

math-allocation · repeat 3 · Pass

correct · responded · 2026-10-04T17:01:23.391395+00:00 UTC

Request: req_fef2ed4a49be497089deed6b8a36d7f6. Estimated cost: US$0.000620. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return only a JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: 6ad065345d558f3869e64460ac7a9c68fdc26064d347156b0069c339d72a22d5

math-discount · repeat 1 · Pass

correct · responded · 2026-10-04T16:41:30.061917+00:00 UTC

Request: req_e9dee38b8a024012bbc5290c9e9fc228. Estimated cost: US$0.000602. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return only a JSON object with these keys: final_price, discount_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"final_price":183.6,"discount_percent":32}

Response SHA-256: c2b82a2cc73d2f5af02bba3c344914bc2cce32a5fb4b6914623102857a833e8f

math-loan · repeat 1 · Fail

answer_mismatch · responded · 2026-10-04T16:42:43.708593+00:00 UTC

Request: req_dfcc8af68d804461938ecd8d7d0d942f. Estimated cost: US$0.001930. Billed cost: unreconciled.

Exact prompt

A $12000 loan charges a nominal annual rate of 12%, compounded monthly, repaid with 24 equal end-of-month payments. Calculate the monthly payment and total interest, without intermediate rounding. Return only a JSON object with these keys: payment, interest. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"payment":564.88,"interest":1557.16}

Response SHA-256: 790e4cbe91c6fbf4f6631676eb45b29abba1599e16f1e86719c2778ac7ff4701

math-weighted · repeat 3 · Pass

correct · responded · 2026-10-04T16:58:05.325158+00:00 UTC

Request: req_dd4320e32c5a4066a7eed7c9edb5e064. Estimated cost: US$0.000752. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return only a JSON object with these keys: week1_percent, week2_percent, change_points. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"week1_percent":6.5,"week2_percent":17,"change_points":10.5}

Response SHA-256: 87037be70ff9453eb0ddf17dec2a4b563a6d17127cb0ea832106610e8bf5c381

math-weighted · repeat 2 · Pass

correct · responded · 2026-10-04T16:56:26.488010+00:00 UTC

Request: req_0d03369c9e324f1bb2fada49dc52a843. Estimated cost: US$0.000772. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return only a JSON object with these keys: week1_percent, week2_percent, change_points. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"week1_percent":6.5,"week2_percent":17,"change_points":10.5}

Response SHA-256: 704ab029a8b684f0bdb139be01275bfb1a87606615d4c47f592803d728f8680e

math-margin · repeat 3 · Fail

answer_mismatch · responded · 2026-10-04T16:59:11.490636+00:00 UTC

Request: req_4db7de56290c44b9aec531c1d811acf3. Estimated cost: US$0.001094. Billed cost: unreconciled.

Exact prompt

A shop buys 240 items at $18 each. It sells 210 at $30 and 30 at $24. Platform fees are 3% of revenue plus $0.20 per sold item. Shipping costs $2.50 per sold item. Calculate revenue, profit after these costs, and profit margin as a percentage of revenue. Return only a JSON object with these keys: revenue, profit, margin_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"revenue":7020,"profit":1841.4,"margin_percent":26.23}

Response SHA-256: 584e49c8c97a82a6880b98df031e8d20544b9cfcd68fcdbe9f870687577e3988

math-break-even · repeat 1 · Pass

correct · responded · 2026-10-04T16:44:25.798561+00:00 UTC

Request: req_54bb95c9616241b6805ae0800140fa11. Estimated cost: US$0.000682. Billed cost: unreconciled.

Exact prompt

A product sells for $40. Variable costs are $17 production, $3 shipping, and a payment fee of 2.5% of sale price plus $0.30. Fixed monthly costs are $1870. Return the minimum whole units needed to break even and profit at that unit count. Return only a JSON object with these keys: units, profit. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"units":100,"profit":0}

Response SHA-256: 605c6c1a91a87851ad07d39679343bb6f02390d185164e79a51aad44e9733d80

math-discount · repeat 2 · Pass

correct · responded · 2026-10-04T16:55:51.963134+00:00 UTC

Request: req_ead78ba49469465b98c9eda5d6fc4ace. Estimated cost: US$0.000612. Billed cost: unreconciled.

Exact prompt

An item is $250 before discounts and tax. Apply 20% off, then a further 15% off the discounted price, then 8% tax. Return the final price and effective pretax discount percentage. Return only a JSON object with these keys: final_price, discount_percent. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"final_price":183.6,"discount_percent":32}

Response SHA-256: 186f03aba7ddebc9d508583c04d10ae0c3b37758fecc5580be51e7b1d646b410

math-npv · repeat 1 · Pass

correct · responded · 2026-10-04T16:43:22.469136+00:00 UTC

Request: req_06c62a60e6504d39b832682fc301b124. Estimated cost: US$0.001600. Billed cost: unreconciled.

Exact prompt

Pay $1000 now, then receive $400 at each year end for three years. Use a 10% annual discount rate. Return net present value without rounding intermediate values. Return only a JSON object with these keys: npv. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"npv":-5.259203606311044}

Response SHA-256: 32c9c9f820cd3852df226dbe54d00cc04cb520b417c831b93544cd1c2188f55c

math-queue · repeat 2 · Pass

correct · responded · 2026-10-04T16:47:39.914529+00:00 UTC

Request: req_780b11f42c994bf1ad3d427f9df73145. Estimated cost: US$0.001058. Billed cost: unreconciled.

Exact prompt

Each of three independent services succeeds with probability 0.98. A workflow requires all three. It retries the complete workflow once if the first attempt fails; attempts are independent. Calculate eventual success probability and expected number of complete attempts. Return only a JSON object with these keys: success_probability, expected_attempts. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"success_probability":0.996541619136,"expected_attempts":1.058808}

Response SHA-256: afe9ac57bbdfae8d7e082c383bdb603aa83e54e785da537ab88dc6ea31ae300e

math-capacity · repeat 1 · Pass

correct · responded · 2026-10-04T16:43:05.787688+00:00 UTC

Request: req_908a5c08201f44e6b07d0d4eae3e8d34. Estimated cost: US$0.001160. Billed cost: unreconciled.

Exact prompt

Product A uses 3 labour hours and 2 machine hours and earns $40 contribution. B uses 2 labour and 4 machine hours and earns $50. Weekly limits are 120 labour and 160 machine hours. Products must be whole units. Maximize contribution; if tied choose more A. Return A, B and contribution. Return only a JSON object with these keys: a, b, contribution. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a":20,"b":30,"contribution":2300}

Response SHA-256: 5faa320fd97d9f38bbe53d314a6c2ed01efb378c4ac254e7cee6c91c59c72053

math-mix · repeat 3 · Pass

correct · responded · 2026-10-04T17:01:15.680028+00:00 UTC

Request: req_fbc6edd2bc0e47bbbc734f51c8b16ba9. Estimated cost: US$0.000606. Billed cost: unreconciled.

Exact prompt

Make exactly 80 litres of a 35% concentrate from 20% and 60% stocks, with additive volumes. How many litres of each stock are needed? Return only a JSON object with these keys: litres_20, litres_60. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"litres_20":50,"litres_60":30}

Response SHA-256: 6097ea90431223917b5e918b600ae63ebb1c925caa3bd107dde171196a91c89d

math-bayes · repeat 1 · Pass

correct · responded · 2026-10-04T16:41:02.584256+00:00 UTC

Request: req_e98962372d844bcabad19f7938d997db. Estimated cost: US$0.000706. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return only a JSON object with these keys: probability. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: de9534198ed2c72fdee4af51d278b002bd3a0c3b39cf1c9a000cdfd96a98c0d8

math-weighted · repeat 1 · Pass

correct · responded · 2026-10-04T16:41:35.787529+00:00 UTC

Request: req_d44986c660b145eb838c29d4baa46ea3. Estimated cost: US$0.000772. Billed cost: unreconciled.

Exact prompt

Campaign A has 900 visits and 45 purchases. Campaign B has 100 visits and 20 purchases. Next week A has 100 visits and 8 purchases; B has 900 visits and 162 purchases. Return each week’s total conversion percentage and next-minus-first percentage-point change. Return only a JSON object with these keys: week1_percent, week2_percent, change_points. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"week1_percent":6.5,"week2_percent":17,"change_points":10.5}

Response SHA-256: bcd44a92cdedb854f83b311c1e8a7afbd82294883785c52bb08da1cccf57bccd

math-allocation · repeat 1 · Pass

correct · responded · 2026-10-04T16:43:14.020734+00:00 UTC

Request: req_efe2300b96354e55afc2e23258876600. Estimated cost: US$0.000410. Billed cost: unreconciled.

Exact prompt

Allocate exactly $10.00 to three departments with weights 1, 1, 1. Work in cents: floor shares, then allocate remaining cents by descending fractional remainder, ties to lower index. Return integer cents for departments A, B and C. Return only a JSON object with these keys: a_cents, b_cents, c_cents. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"a_cents":334,"b_cents":333,"c_cents":333}

Response SHA-256: 7a97fbb26e70a44f44d3135742ce5739ce0b65bca1751189eeac32eb62300c63

math-bayes · repeat 2 · Pass

correct · responded · 2026-10-04T16:55:59.122078+00:00 UTC

Request: req_838198306cb74e2d9e1445e97fad8aae. Estimated cost: US$0.000696. Billed cost: unreconciled.

Exact prompt

A defect affects 2% of units. A detector flags 95% of defective units and 4% of nondefective units. Given a flag, calculate the probability the unit is defective, as a decimal from 0 to 1. Return only a JSON object with these keys: probability. Numeric fields must be numbers. No Markdown or explanation.

Retained output

{"probability":0.32646048109965636}

Response SHA-256: 3ee39f2ab8fba53b8cf100462d82e7c51445a768c5793cde665459c6e8fe240e