google / EXACT API MODEL

Gemini 3.8 Flash

Gemini Developer API, paid Standard

gemini-3.8-flash

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	97.2%	88.9%–100.0%	36 / 36	36 / 36	0	4.96 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-csv · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.010111. 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
from collections import defaultdict

def solve(data):
    f = io.StringIO(data)
    reader = csv.reader(f)
    cents_pattern = re.compile(r'^[+-]?[0-9]+$')
    totals = defaultdict(int)
    header_seen = False
    for row in reader:
        if not row:
            continue
        if not header_seen:
            if row == ['customer', 'cents']:
                header_seen = True
            continue
        if len(row) != 2:
            continue
        cust, cents_raw = row
        if not cust.strip():
            continue
        cents_str = cents_raw.strip()
        if not cents_pattern.fullmatch(cents_str):
            continue
        totals[cust] += int(cents_str)
    return dict(totals)

Response SHA-256: 504712a08b713af913ab1e67ee42c0fb9179751a3d94031487346d9c04715d28

coding-rolling · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004995. 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

from collections import defaultdict

def solve(data):
    events = data.get("events", [])
    query_days = data.get("query_days", [])
    day_counts = defaultdict(int)
    for day, count in events:
        day_counts[day] += count
    return [
        sum(day_counts.get(d, 0) for d in range(q - 6, q + 1))
        for q in query_days
    ]

Response SHA-256: bc333f279200949deb87ca75561c60d744b9ec2f293e0d92c93eff465186ae57

coding-csv · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.013437. Billed cost: unreconciled.

Exact prompt

Retained output

import csv
import io
import re

def solve(data):
    pattern = re.compile(r'[+-]?[0-9]+')
    totals = {}
    header_seen = False

    for row in csv.reader(io.StringIO(data)):
        if not header_seen:
            if row == ['customer', 'cents']:
                header_seen = True
            continue
        if len(row) != 2:
            continue
        customer, cents = row
        if not customer.strip():
            continue
        cents_trimmed = cents.strip()
        if not pattern.fullmatch(cents_trimmed):
            continue
        val = int(cents_trimmed)
        totals[customer] = totals.get(customer, 0) + val

    return totals

Response SHA-256: 4e83124db288aa5be60a0cf11343edf8a58f833fd1a274f9e1fbbf8e5161d624

coding-intervals · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005256. 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):
    valid = sorted([[iv[0], iv[1]] for iv in data if iv[0] < iv[1]])
    if not valid:
        return []
    merged = []
    for iv in valid:
        if not merged:
            merged.append([iv[0], iv[1]])
        elif iv[0] <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], iv[1])
        else:
            merged.append([iv[0], iv[1]])
    return merged

Response SHA-256: 0bf511b37a23bd169f96d417ac80af2072ad4779f01d5c6469cab1330183c9b0

coding-slug · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004968. 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 re
import unicodedata

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

Response SHA-256: 0bca434544395548eddfc85ca41adc092b65f2f0c994166067974fd0e3ef72c8

coding-intervals · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004274. 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):
    filtered = sorted([[iv[0], iv[1]] for iv in data if iv[0] < iv[1]])
    if not filtered:
        return []
    merged = [filtered[0]]
    for iv in filtered[1:]:
        if iv[0] <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], iv[1])
        else:
            merged.append(iv)
    return merged

Response SHA-256: b2f39b81ef4b5e5844b0fa8144e058279d7e6ac8a10febd65cb1e11e230b1185

coding-rate · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004656. 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, defaultdict

def solve(data):
    limit = data['limit']
    window = data['window']
    events = data['events']
    
    user_history = defaultdict(deque)
    results = []
    
    for ev in events:
        user = ev['user']
        t = ev['time']
        dq = user_history[user]
        
        cutoff = t - window
        while dq and dq[0] <= cutoff:
            dq.popleft()
            
        if len(dq) < limit:
            dq.append(t)
            results.append(True)
        else:
            results.append(False)
            
    return results

Response SHA-256: 9fd957a22f505c8d8e2febc38338f852d29c8ece13053b598cadb01ea217b450

coding-rate · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005451. 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 defaultdict, deque

def solve(data):
    limit = data['limit']
    window = data['window']
    events = data['events']

    user_history = defaultdict(deque)
    result = []

    for ev in events:
        u = ev['user']
        t = ev['time']
        q = user_history[u]
        cutoff = t - window
        while q and q[0] <= cutoff:
            q.popleft()
        if len(q) < limit:
            q.append(t)
            result.append(True)
        else:
            result.append(False)

    return result

Response SHA-256: d3ec2c313821c9bf1258d7ad291c5cc72f282cf05d4eba36c087a78c960a9173

coding-allocate · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005601. 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):
    weights = data["weights"]
    total = data["total"]
    if not weights:
        return []
    sum_w = sum(weights)
    if sum_w == 0:
        return [0] * len(weights)

    shares = [0] * len(weights)
    rems = [0] * len(weights)
    for i, w in enumerate(weights):
        q, r = divmod(total * w, sum_w)
        shares[i] = q
        rems[i] = r

    leftover = total - sum(shares)
    sorted_indices = sorted(range(len(weights)), key=lambda i: (-rems[i], i))

    for idx in sorted_indices[:leftover]:
        shares[idx] += 1

    return shares

Response SHA-256: 80912bd390390f95fafe1adb0c55930ff2135e30a8640b448f1e5bbfe5043c23

coding-slug · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003018. 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)
    without_combining = ''.join(c for c in normalized if not unicodedata.combining(c))
    lowered = without_combining.lower()
    hyphenated = re.sub(r'[^a-z0-9]+', '-', lowered)
    return hyphenated.strip('-')

Response SHA-256: 6d74246d013fc7d2e2237b68b9cec7b03bc76c1932366cc254c0346124b37042

coding-percentile · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.007392. 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
    p = data['p']
    n = len(values)
    rank = max(1, math.ceil(p / 100 * n))
    return sorted(values)[rank - 1]

Response SHA-256: f86abc3802b856115f14771f68a20dc3c105edd5112c1ec72533fff5ea429c2d

coding-dedup · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.005049. 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):
    best = {}
    for item in data:
        item_id = item['id']
        item_ver = item['version']
        if item_id not in best or item_ver >= best[item_id][0]:
            best[item_id] = (item_ver, item)
    return [best[k][1] for k in sorted(best.keys())]

Response SHA-256: 81b7db0d8ff3625c6f7fc843a990ddad84b670ca227e870daef7b535069311b3

coding-fifo · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004063. 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):
    lots = data["lots"]
    current_sold = data["sold"]

    rem_units = 0
    rem_value = 0

    for lot in lots:
        qty = lot[0]
        price = lot[1]
        take = min(current_sold, qty)
        current_sold -= take
        remaining = qty - take
        rem_units += remaining
        rem_value += remaining * price

    return {
        "remaining_units": rem_units,
        "remaining_value_cents": rem_value,
        "unfilled_units": current_sold,
    }

Response SHA-256: 9552a1bbc728b9d3888743fca46a718abff3c85bdead8f8521a29517e778c156

coding-percentile · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004650. 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
    n = len(values)
    p = data["p"]
    rank = max(1, math.ceil(p / 100 * n))
    return values[rank - 1]

Response SHA-256: 24c22ce48c161aed0e129c59843fc760f5dd65fbb4450532ac8c7b0c74561cea

coding-redact · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003582. 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 {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in ('password', 'token', 'secret'))
        }
    if isinstance(data, list):
        return [solve(item) for item in data]
    return data

Response SHA-256: 457cd856e850db57cc759c69d60bd2c7759015d567cb619ca03a81619d5d7e96

coding-allocate · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005619. 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"]
    if not weights:
        return []
    w_sum = sum(weights)
    if w_sum == 0:
        return [0] * len(weights)
    
    shares = [(total * w) // w_sum for w in weights]
    rems = [(total * w) % w_sum for w in weights]
    leftover = total - sum(shares)
    
    order = sorted(range(len(weights)), key=lambda i: (-rems[i], i))
    for i in range(leftover):
        shares[order[i]] += 1
        
    return shares

Response SHA-256: 40eaebf0d548484b82c94346022db5558e866dfd04f63170a7eb96a4b8df6c19

coding-allocate · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.006043. 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']
    if not weights:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * len(weights)

    bases = [total * w // s for w in weights]
    rems = [total * w % s for w in weights]
    leftover = total - sum(bases)

    order = sorted(range(len(weights)), key=lambda i: (-rems[i], i))

    res = list(bases)
    for i in range(leftover):
        res[order[i]] += 1

    return res

Response SHA-256: 613202f62c4ce0a26f1f6b9677a2aa24e4ccaa7ba99eb9c3a2dc7f6939d709c1

coding-fifo · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004108. 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):
    lots = data["lots"]
    to_sell = data["sold"]

    rem_units = 0
    rem_value = 0

    for lot in lots:
        qty = lot[0]
        price = lot[1]
        if to_sell > 0:
            take = min(qty, to_sell)
            left = qty - take
            to_sell -= take
        else:
            left = qty
        rem_units += left
        rem_value += left * price

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

Response SHA-256: a9284be695742c01928ccd1f66bb9e5670be94f2c00ee6a81e2ca23279fb4673

coding-csv · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.007344. Billed cost: unreconciled.

Exact prompt

Retained output

import csv
import io
import re

def solve(data):
    cents_pattern = re.compile(r'^[+-]?[0-9]+$')
    f = io.StringIO(data)
    reader = csv.reader(f)
    header_found = False
    totals = {}
    for row in reader:
        if not row:
            continue
        if not header_found:
            if row == ['customer', 'cents']:
                header_found = True
            continue
        if len(row) != 2:
            continue
        customer, cents = row
        if not customer.strip():
            continue
        cents_trimmed = cents.strip()
        if not cents_pattern.fullmatch(cents_trimmed):
            continue
        val = int(cents_trimmed)
        totals[customer] = totals.get(customer, 0) + val
    return totals

Response SHA-256: 708ec57d7f969723ddd3a249b4d49b06b323817a046af7d61578d7666958c6fb

coding-dedup · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004074. 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):
    best = {}
    for item in data:
        item_id = item['id']
        version = item['version']
        if item_id not in best or version >= best[item_id]['version']:
            best[item_id] = item
    return [dict(best[k]) for k in sorted(best.keys())]

Response SHA-256: 494da414924a085e0ff62efbac5ed678fe4cefe30262bfb0b66826c89a8650ed

coding-redact · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003612. 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 {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in ("password", "token", "secret"))
        }
    if isinstance(data, list):
        return [solve(item) for item in data]
    return data

Response SHA-256: 6d9d230fd318f1f961b85edabbc2c592b65a64101e0bf129c4e64a41ad8351c3

coding-reconcile · repeat 2 · Fail

execution_rejected · responded · 2026-10-05T05:48:58.361474+00:00 UTC

Request: Not exposed. Estimated cost: US$0.003715. 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

from collections import defaultdict

def solve(data):
    balances = defaultdict(int)
    for inv in data.get('invoices', []):
        balances[inv['id']] += inv['cents']
    for pmt in data.get('payments', []):
        balances[pmmt_id := pmt['id']] -= pmt['cents']
    
    result = {}
    for k in sorted(balances):
        val = balances[k]
        if val != 0:
            result[k] = val
    return result

Response SHA-256: b640cc01457c8b61878798d8ad15af1e09484e4c367c1ea65cb8eb26da8f945a

coding-dedup · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.008754. 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):
    best = {}
    for item in data:
        item_id = item['id']
        ver = item['version']
        if item_id not in best or ver >= best[item_id]['version']:
            best[item_id] = item
    return [best[k] for k in sorted(best)]

Response SHA-256: 453f95eb457ac4502c451278534d9b9d84e57c55feeaa8d6d480302dafcc6cc8

coding-intervals · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004045. 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):
    non_empty = [list(interval) for interval in data if interval[0] < interval[1]]
    non_empty.sort(key=lambda x: (x[0], x[1]))
    merged = []
    for interval in non_empty:
        if not merged:
            merged.append(interval)
        else:
            if interval[0] <= merged[-1][1]:
                merged[-1][1] = max(merged[-1][1], interval[1])
            else:
                merged.append(interval)
    return merged

Response SHA-256: 71e9bcccd4e62e57967c96a3b0d8bafa54c6ccfeda63f82713b264b2723c8e4f

coding-rolling · repeat 2 · Pass

checked · responded · 2026-10-05T05:46:52.762328+00:00 UTC

Request: Not exposed. Estimated cost: US$0.002700. 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

from collections import defaultdict

def solve(data):
    events = data.get("events", [])
    query_days = data.get("query_days", [])
    
    day_counts = defaultdict(int)
    for day, count in events:
        day_counts[day] += count
        
    result = []
    for q in query_days:
        total = sum(day_counts[d] for d in range(q - 6, q + 1))
        result.append(total)
        
    return result

Response SHA-256: c14a523cfae66df8cb800c4593f14c07a10a8a5367e288055455a70a304ba1c5

coding-slug · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003555. 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 re
import unicodedata

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

Response SHA-256: 7b7ac7c1628b600ec4f3f003968a1cec5cda662348f2d3b72336c3822d2207c3

coding-dependencies · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.007697. 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):
    all_nodes = set(data.keys())
    for prereqs in data.values():
        all_nodes.update(prereqs)

    adj = {node: [] for node in all_nodes}
    in_degree = {}

    for job in all_nodes:
        prereqs = set(data.get(job, []))
        in_degree[job] = len(prereqs)
        for p in prereqs:
            adj[p].append(job)

    heap = [node for node, deg in in_degree.items() if deg == 0]
    heapq.heapify(heap)

    result = []
    while heap:
        curr = heapq.heappop(heap)
        result.append(curr)
        for nxt in adj[curr]:
            in_degree[nxt] -= 1
            if in_degree[nxt] == 0:
                heapq.heappush(heap, nxt)

    if len(result) == len(all_nodes):
        return result
    return None

Response SHA-256: d484ff523a117011a89dcb8705fa13ae3c2b8a280ee057cb093e6c1e7d8e25c9

coding-reconcile · repeat 3 · Pass

checked · responded · 2026-10-05T05:51:58.222229+00:00 UTC

Request: Not exposed. Estimated cost: US$0.003231. 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

from collections import defaultdict

def solve(data):
    balances = defaultdict(int)
    for inv in data["invoices"]:
        balances[inv["id"]] += inv["cents"]
    for pmt in data["payments"]:
        balances[pmt["id"]] -= pmt["cents"]
    result = {}
    for k in sorted(balances):
        val = balances[k]
        if val != 0:
            result[k] = val
    return result

Response SHA-256: 11832f66e632b38b0b49913e83184dfd8d8e5f13578cb420f8bba5005c1dd6ae

coding-dependencies · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.006039. 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

from collections import defaultdict
from heapq import heappop, heappush, heapify

def solve(data):
    all_nodes = set(data.keys())
    for prereqs in data.values():
        all_nodes.update(prereqs)
    
    in_degree = {node: 0 for node in all_nodes}
    adj = defaultdict(list)
    
    for node, prereqs in data.items():
        unique_prereqs = set(prereqs)
        in_degree[node] = len(unique_prereqs)
        for p in unique_prereqs:
            adj[p].append(node)
            
    heap = [node for node, deg in in_degree.items() if deg == 0]
    heapify(heap)
    
    result = []
    while heap:
        curr = heappop(heap)
        result.append(curr)
        for neighbor in adj[curr]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                heappush(heap, neighbor)
                
    if len(result) == len(all_nodes):
        return result
    return None

Response SHA-256: 3aba05f4a1f11ee059e012b3507fb4f8c018fa1483cb24f77b72ec1aac112465

coding-fifo · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003448. 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 lot in data["lots"]:
        qty = lot[0]
        price = lot[1]
        take = min(to_sell, qty)
        rem = qty - take
        to_sell -= take
        remaining_units += rem
        remaining_value_cents += rem * price
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": to_sell,
    }

Response SHA-256: d4c758253c0efaa777d0ea31d02d6ed1a55fef43680bc97680e2a9143cef58fe

coding-reconcile · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002939. 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

from collections import defaultdict

def solve(data):
    totals = defaultdict(int)
    for inv in data.get('invoices', []):
        totals[inv['id']] += inv['cents']
    for pay in data.get('payments', []):
        totals[pay['id']] -= pay['cents']
    
    result = {}
    for k in sorted(totals.keys()):
        if totals[k] != 0:
            result[k] = totals[k]
    return result

Response SHA-256: fdf827ee0a3e1b4aa7eea79c55f8fc6b5330e4cf47fe1160125708387c445f43

coding-rolling · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.007533. 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

from collections import defaultdict

def solve(data):
    events = data.get("events", [])
    query_days = data.get("query_days", [])

    day_counts = defaultdict(int)
    for day, count in events:
        day_counts[day] += count

    sorted_days = sorted(day_counts.keys())
    prefix = [0]
    for d in sorted_days:
        prefix.append(prefix[-1] + day_counts[d])

    def b_left(a, x):
        lo = 0
        hi = len(a)
        while lo < hi:
            mid = (lo + hi) // 2
            if a[mid] < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def b_right(a, x):
        lo = 0
        hi = len(a)
        while lo < hi:
            mid = (lo + hi) // 2
            if x < a[mid]:
                hi = mid
            else:
                lo = mid + 1
        return lo

    ans = []
    for q in query_days:
        l = b_left(sorted_days, q - 6)
        r = b_right(sorted_days, q)
        ans.append(prefix[r] - prefix[l])

    return ans

Response SHA-256: 52fcb137061e28d2b1426e6bbe5596a424850698e7ca2ae326538e1515cdfd02

coding-percentile · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005944. 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
    n = len(values)
    p = data['p']
    rank = max(1, math.ceil(p / 100 * n))
    return sorted(values)[rank - 1]

Response SHA-256: 17e60c30c5e797e985449fdadb2be86b305a14e82f359369fb94cc761901aba2

coding-dependencies · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004382. 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
from collections import defaultdict

def solve(data):
    all_nodes = set(data.keys())
    for prereqs in data.values():
        all_nodes.update(prereqs)
    
    in_degree = {node: 0 for node in all_nodes}
    adj = defaultdict(list)
    
    for job, prereqs in data.items():
        unique_prereqs = set(prereqs)
        in_degree[job] = len(unique_prereqs)
        for p in unique_prereqs:
            adj[p].append(job)
            
    heap = [node for node, deg in in_degree.items() if deg == 0]
    heapq.heapify(heap)
    
    order = []
    while heap:
        u = heapq.heappop(heap)
        order.append(u)
        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                heapq.heappush(heap, v)
                
    if len(order) == len(all_nodes):
        return order
    return None

Response SHA-256: a3c9b0bb975a3c0b969bf532a79ddcf164d8d3e1caf1c9737c203946f1263a83

coding-redact · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004194. 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 {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in ('password', 'token', 'secret'))
        }
    if isinstance(data, list):
        return [solve(v) for v in data]
    return data

Response SHA-256: 6c1670f237a23f65453915cc1cf3d1ae46fff7d74c844b29c6c61825907c1ddd

coding-rate · repeat 1 · Pass

checked · responded · 2026-10-05T05:43:02.527296+00:00 UTC

Request: Not exposed. Estimated cost: US$0.005125. 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 defaultdict, deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data["events"]

    user_history = defaultdict(deque)
    res = []

    for event in events:
        user = event["user"]
        t = event["time"]
        cutoff = t - window
        dq = user_history[user]
        while dq and dq[0] <= cutoff:
            dq.popleft()
        if len(dq) < limit:
            dq.append(t)
            res.append(True)
        else:
            res.append(False)

    return res

Response SHA-256: 13abfdcd45d31ace7ace19090503ddf123e18b40643147fcd36b12a30c56f4fe

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	88.9%	69.4%–100.0%	36 / 36	36 / 36	0	6.39 s	1 / 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-percentile · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.006042. 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 = data.get("values")
    if not values:
        return None
    p = data.get("p", 0)
    n = len(values)
    rank = max(1, math.ceil(p / 100 * n))
    return sorted(values)[rank - 1]

Response SHA-256: 4dc1bfe597cc6f9f9389cb326a9a30853ffc7c8d03cc3877b4533801e29084ff

coding-dependencies · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005564. 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 collections
import heapq

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

    adj = collections.defaultdict(list)
    in_degree = {node: 0 for node in nodes}

    for job, prereqs in data.items():
        unique_prereqs = set(prereqs)
        in_degree[job] += len(unique_prereqs)
        for p in unique_prereqs:
            adj[p].append(job)

    heap = [node for node, deg in in_degree.items() if deg == 0]
    heapq.heapify(heap)

    result = []
    while heap:
        curr = heapq.heappop(heap)
        result.append(curr)
        for neighbor in adj[curr]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                heapq.heappush(heap, neighbor)

    if len(result) < len(nodes):
        return None

    return result

Response SHA-256: 8ba917df9471b650222805e821976f1e652fbba1fe09e4ca7f334d23e5431590

coding-allocate · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.008369. 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"]
    if not weights:
        return []
    total_weight = sum(weights)
    if total_weight == 0:
        return [0] * len(weights)

    n = len(weights)
    floors = [(total * w) // total_weight for w in weights]
    leftover = total - sum(floors)

    sorted_indices = sorted(
        range(n),
        key=lambda i: (-((total * weights[i]) % total_weight), i)
    )

    result = list(floors)
    for i in range(leftover):
        result[sorted_indices[i]] += 1

    return result

Response SHA-256: 1115c2d21b0c8ea21939bfbc9b0627c01670ab26413b82f2d297b3339e41bd5b

coding-dependencies · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.007304. 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.keys())
    for prereqs in data.values():
        nodes.update(prereqs)

    adj = {node: [] for node in nodes}
    in_degree = {node: 0 for node in nodes}

    for job, prereqs in data.items():
        for p in set(prereqs):
            adj[p].append(job)
            in_degree[job] += 1

    heap = [node for node in nodes if in_degree[node] == 0]
    heapq.heapify(heap)

    order = []
    while heap:
        u = heapq.heappop(heap)
        order.append(u)
        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                heapq.heappush(heap, v)

    if len(order) < len(nodes):
        return None
    return order

Response SHA-256: d958b766bf0959c1b13916666c7a8d7744db8fe3241e257a1e50c2ab638c81f6

coding-rate · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005392. 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

import collections


def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data["events"]

    user_history = collections.defaultdict(collections.deque)
    result = []

    for event in events:
        user = event["user"]
        t = event["time"]
        dq = user_history[user]
        cutoff = t - window

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

        if len(dq) < limit:
            dq.append(t)
            result.append(True)
        else:
            result.append(False)

    return result

Response SHA-256: 3317a29c994a24a40227dec7a26d607648559949585d2887e910b06a27a4b378

coding-allocate · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.005886. 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']
    if not weights:
        return []
    total_weight = sum(weights)
    if total_weight == 0:
        return [0] * len(weights)
    
    shares = []
    remainders = []
    for i, w in enumerate(weights):
        q, r = divmod(w * total, total_weight)
        shares.append(q)
        remainders.append((-r, i))
    
    leftover = total - sum(shares)
    remainders.sort()
    for k in range(leftover):
        shares[remainders[k][1]] += 1
        
    return shares

Response SHA-256: 568c1af372192c6a8d601b47a3860f92c6c472bc3b763f1d4c270873e9e9f528

coding-rate · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004612. 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

import collections

def solve(data):
    limit = data['limit']
    window = data['window']
    events = data['events']
    
    user_history = collections.defaultdict(collections.deque)
    result = []
    
    for event in events:
        user = event['user']
        current_time = event['time']
        dq = user_history[user]
        
        threshold = current_time - window
        while dq and dq[0] <= threshold:
            dq.popleft()
            
        if len(dq) < limit:
            dq.append(current_time)
            result.append(True)
        else:
            result.append(False)
            
    return result

Response SHA-256: 80eb3ba3b3a607514e888cbcff8cacacc4cc8285fc0f96f0d2754a628c946440

coding-reconcile · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003726. 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

import collections

def solve(data):
    balances = collections.defaultdict(int)
    for item in data.get('invoices', []):
        balances[item['id']] += item['cents']
    for item in data.get('payments', []):
        balances[item['id']] -= item['cents']
    return {k: balances[k] for k in sorted(balances) if balances[k] != 0}

Response SHA-256: b4134a1141371f6b76cce4a783ee093d5bc4defac5c7560c4a592b564e6ac7f1

coding-slug · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.009375. 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: str) -> str:
    normalized = unicodedata.normalize('NFKD', data)
    without_marks = ''.join(
        c for c in normalized
        if not unicodedata.combining(c) and not unicodedata.category(c).startswith('M')
    )
    lowered = without_marks.lower()
    slug = re.sub(r'[^a-z0-9]+', '-', lowered)
    return slug.strip('-')

Response SHA-256: 2c219f7b413a8a290b698861a631d7a416ea72f1c5c8ddfa37879f5965a96293

coding-rolling · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004861. 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

import collections

def solve(data):
    events = data.get('events', [])
    query_days = data.get('query_days', [])

    counts = collections.defaultdict(int)
    for day, count in events:
        counts[day] += count

    results = []
    for q in query_days:
        total = sum(counts.get(q - i, 0) for i in range(7))
        results.append(total)

    return results

Response SHA-256: 628b6b5351d200a44b43463e80452993898776988fea047d0161044e777e1f29

coding-intervals · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003581. 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):
    valid_intervals = [list(interval) for interval in data if interval[0] < interval[1]]
    if not valid_intervals:
        return []
    valid_intervals.sort(key=lambda x: (x[0], x[1]))
    merged = [valid_intervals[0]]
    for current in valid_intervals[1:]:
        last = merged[-1]
        if current[0] <= last[1]:
            if current[1] > last[1]:
                last[1] = current[1]
        else:
            merged.append(current)
    return merged

Response SHA-256: 97b30f32800d14dbe31546c2db13cd783cb11ee2b270e1e64b01b8f298fb0e81

coding-intervals · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004638. 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 = [list(interval) for interval in data if interval[0] < interval[1]]
    if not intervals:
        return []
    intervals.sort()
    merged = [intervals[0]]
    for current in intervals[1:]:
        if current[0] <= merged[-1][1]:
            if current[1] > merged[-1][1]:
                merged[-1][1] = current[1]
        else:
            merged.append(current)
    return merged

Response SHA-256: e9a36c36cc8b07121be71d4417539df974328f6fd4d73c038217491e71d79527

coding-dedup · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.007282. 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):
    best = {}
    for item in data:
        item_id = item['id']
        if item_id not in best or item['version'] >= best[item_id]['version']:
            best[item_id] = item
    return sorted(best.values(), key=lambda x: str(x['id']))

Response SHA-256: 194766f93387edc02a5c411f33476135bbc565ac4cb80d241572f1a6578e1982

coding-percentile · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005652. 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 = data.get("values")
    if not values:
        return None
    p = data.get("p")
    n = len(values)
    rank = max(1, math.ceil(p / 100 * n))
    sorted_values = sorted(values)
    return sorted_values[rank - 1]

Response SHA-256: 50db1591279db6f3d28ef0997720b7cff3aa2b85c8cbaa55151ce05cbc866398

coding-rolling · repeat 3 · Fail

execution_rejected · responded · 2026-10-04T16:57:05.795573+00:00 UTC

Request: Not exposed. Estimated cost: US$0.005686. 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 = data.get("events", [])
    query_days = data.get("query_days", [])
    
    day_counts = collections.defaultdict(int)
    for day, count in events:
        day_counts[day] += count
        
    unique_days = sorted(day_counts.keys())
    prefix = [0] * (len(unique_days) + 1)
    for idx, d in enumerate(unique_days):
        prefix[idx + 1] = prefix[idx] + day_counts[d]
        
    def bisect_left(arr, x):
        lo, hi = 0, len(arr)
        while lo < hi:
            mid = (lo + hi) // 2
            if arr[mid] < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(arr, x):
        lo, hi = 0, len(arr)
        while lo < hi:
            mid = (lo + hi) // 2
            if arr[mid] <= x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    results = []
    for q in query_days:
        left = bisect_left(unique_days, q - 6)
        right = bisect_right(unique_days, q)
        results.append(prefix[right] - prefix[left])
        
    return results

Response SHA-256: 9cec04374faf4a1512b1459e6fd22d7531c238f08cc608ab663133e8470cd830

coding-fifo · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004422. 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):
    lots = data.get('lots', [])
    sold = data.get('sold', 0)
    
    to_sell = sold
    remaining_units = 0
    remaining_value_cents = 0
    
    for qty, unit_cents in lots:
        if to_sell > 0:
            take = min(qty, to_sell)
            qty_left = qty - take
            to_sell -= take
        else:
            qty_left = qty
        remaining_units += qty_left
        remaining_value_cents += qty_left * unit_cents
        
    return {
        'remaining_units': remaining_units,
        'remaining_value_cents': remaining_value_cents,
        'unfilled_units': to_sell
    }

Response SHA-256: c472def785e4e9b89ad43f5ab3da3261df65b187980ec3a26b9b1f267d99e5ad

coding-dedup · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.005842. 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):
    best = {}
    for item in data:
        item_id = item['id']
        if item_id not in best or item['version'] >= best[item_id]['version']:
            best[item_id] = item
    return sorted(best.values(), key=lambda x: str(x['id']))

Response SHA-256: 4fac33061aa18fcdd941737985fd6378974c2fb3c0d045bbf1a92d79dce52aa8

coding-reconcile · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004048. 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):
    balances = {}
    for inv in data.get('invoices', []):
        balances[inv['id']] = balances.get(inv['id'], 0) + inv['cents']
    for pmt in data.get('payments', []):
        balances[pmt['id']] = balances.get(pmt['id'], 0) - pmt['cents']
    return {k: balances[k] for k in sorted(balances) if balances[k] != 0}

Response SHA-256: f84d76ddaa3dfc4426d34f5434fcef415437c7e7236010260487b157d957dc27

coding-reconcile · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003444. 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):
    balances = {}
    for inv in data.get("invoices", []):
        balances[inv["id"]] = balances.get(inv["id"], 0) + inv["cents"]
    for pmt in data.get("payments", []):
        balances[pmt["id"]] = balances.get(pmt["id"], 0) - pmt["cents"]
    return {k: balances[k] for k in sorted(balances) if balances[k] != 0}

Response SHA-256: 5d5ed27782e4c3b5b1dd9e2e74d8f8cf1eaf90b50630ccc50785bfb26fd7a299

coding-fifo · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003863. 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):
    lots = data.get("lots", [])
    remaining_to_sell = data.get("sold", 0)
    
    remaining_units = 0
    remaining_value_cents = 0
    
    for lot in lots:
        qty, price = lot[0], lot[1]
        if remaining_to_sell > 0:
            take = min(qty, remaining_to_sell)
            qty -= take
            remaining_to_sell -= take
        remaining_units += qty
        remaining_value_cents += qty * price
        
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value_cents,
        "unfilled_units": remaining_to_sell
    }

Response SHA-256: 84a076c619b4c33821a216aa082cd485d07dc02220f87a6be30d2223d67dc47c

coding-redact · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003894. 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 {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in {"password", "token", "secret"})
        }
    if isinstance(data, list):
        return [solve(item) for item in data]
    return data

Response SHA-256: 1174d013ff7236c8839638e92bf0d8b1f9fb9db4f3b031ed9e122e34eb391747

coding-rolling · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005870. 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

import collections

def solve(data):
    events = data.get("events", [])
    query_days = data.get("query_days", [])
    
    day_counts = collections.defaultdict(int)
    for day, count in events:
        day_counts[day] += count
        
    unique_days = sorted(day_counts.keys())
    n = len(unique_days)
    
    pref = [0] * (n + 1)
    for i in range(n):
        pref[i + 1] = pref[i] + day_counts[unique_days[i]]
        
    def bisect_left(target):
        lo, hi = 0, n
        while lo < hi:
            mid = (lo + hi) // 2
            if unique_days[mid] < target:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(target):
        lo, hi = 0, n
        while lo < hi:
            mid = (lo + hi) // 2
            if target < unique_days[mid]:
                hi = mid
            else:
                lo = mid + 1
        return lo

    results = []
    for q in query_days:
        l = bisect_left(q - 6)
        r = bisect_right(q)
        results.append(pref[r] - pref[l])
        
    return results

Response SHA-256: a40f4b2777749517b8515bc0b79313380cb09f40047f4a4c63d7f4cbbb2ee18e

coding-slug · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.005858. 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)
    without_marks = ''.join(
        c for c in normalized
        if not unicodedata.combining(c) and not unicodedata.category(c).startswith('M')
    )
    lowered = without_marks.lower()
    return re.sub(r'[^a-z0-9]+', '-', lowered).strip('-')

Response SHA-256: e37f6232ddaffe87593156e8ebc75d6f36a611c5539fe39b49969569f82eaf6d

coding-rate · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.005373. 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

import collections

def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data["events"]

    history = collections.defaultdict(collections.deque)
    result = []

    for event in events:
        user = event["user"]
        t = event["time"]
        dq = history[user]
        cutoff = t - window
        while dq and dq[0] <= cutoff:
            dq.popleft()
        if len(dq) < limit:
            dq.append(t)
            result.append(True)
        else:
            result.append(False)

    return result

Response SHA-256: 5150471b84f74636f3d61571e1ff392afdbd83a4c15f4b5ce778f985231e8469

coding-redact · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005492. 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):
    forbidden = {"password", "token", "secret"}
    if isinstance(data, dict):
        return {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in forbidden)
        }
    if isinstance(data, list):
        return [solve(item) for item in data]
    return data

Response SHA-256: fabe2c8fe353ae02642a1fe92a73838674fb5d3e0a0d13ef84c8023389996a07

coding-csv · repeat 3 · Fail

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

Request: Not exposed. Estimated cost: US$0.017688. 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):
    if not data:
        return {}
    data = data.lstrip("\ufeff")
    reader = csv.DictReader(io.StringIO(data))
    totals = {}
    pattern = re.compile(r"[+-]?[0-9]+")
    for row in reader:
        customer = row.get("customer")
        cents = row.get("cents")
        if customer is None or cents is None:
            continue
        if not customer.strip():
            continue
        if not pattern.fullmatch(cents):
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)
    return totals

Response SHA-256: 29b27643884ff3a5f693aa9075209210e2f3782f1c01e0f82c83f2f0ff373584

coding-dependencies · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.008935. 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 collections
import heapq

def solve(data):
    nodes = set(data.keys())
    adj = collections.defaultdict(list)
    in_degree = {k: 0 for k in data}
    
    for job, prereqs in data.items():
        unique_prereqs = set(prereqs)
        in_degree[job] = len(unique_prereqs)
        for p in unique_prereqs:
            nodes.add(p)
            adj[p].append(job)
            if p not in in_degree:
                in_degree[p] = 0

    heap = [node for node in nodes if in_degree[node] == 0]
    heapq.heapify(heap)
    
    order = []
    while heap:
        u = heapq.heappop(heap)
        order.append(u)
        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                heapq.heappush(heap, v)
                
    if len(order) == len(nodes):
        return order
    return None

Response SHA-256: 02e445fff15371214334e6988f4befa8b2f17d6339b5bbd013b65452bcdb6d92

coding-csv · repeat 2 · Fail

execution_rejected · responded · 2026-10-04T16:49:32.869422+00:00 UTC

Request: dYPCarS-LteG-8YP4LCuKA. Estimated cost: US$0.030802. 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

" - no markdown, only code.
- "no custom classes, private/dunder attributes, globals/nonlocals, or async."
- "Preserve customer spelling."

Let's write down the function clearly:

```python
import csv
import io
import re

def solve(data):
    reader = csv.reader(io.StringIO(data))
    try:
        header = next(reader)
    except StopIteration:
        return {}
    
    header_map = {col.strip().lower(): i for i, col in enumerate(header)}
    cust_idx = header_map.get('customer')
    cents_idx = header_map.get('cents')
    if cust_idx is None or cents_idx is None:
        return {}
    
    pattern = re.compile(r'^[+-]?\d+$')
    totals = {}
    
    for row in reader:
        if len(row) <= max(cust_idx, cents_idx):
            continue
        cust = row[cust_idx]
        cents = row[cents_idx]
        if not cust or not cust.strip():
            continue
        if not pattern.match(cents):
            continue
        totals[cust] = totals.get(cust, 0) + int(cents)
        
    return totals
```

Everything looks solid and directly adheres to all instructions.import csv
import io
import re

def solve

Response SHA-256: 5519788804c8d62e63735b206ff220745c6732539dbd07c243069da7c8a438ba

coding-allocate · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.005830. 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']
    if not weights:
        return []
    total_weight = sum(weights)
    if total_weight == 0:
        return [0] * len(weights)

    shares = []
    remainders = []
    for i, w in enumerate(weights):
        prod = total * w
        shares.append(prod // total_weight)
        remainders.append((prod % total_weight, i))

    leftover = total - sum(shares)
    remainders.sort(key=lambda item: (-item[0], item[1]))

    for k in range(leftover):
        idx = remainders[k][1]
        shares[idx] += 1

    return shares

Response SHA-256: 3fd57539a5e9dd8c320b09fb6b08dcd7ae3e09a0a0e7e6db440458d82f792b38

coding-intervals · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004702. 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):
    valid = [[iv[0], iv[1]] for iv in data if iv[0] < iv[1]]
    if not valid:
        return []
    valid.sort(key=lambda x: (x[0], x[1]))
    merged = [valid[0]]
    for iv in valid[1:]:
        if iv[0] <= merged[-1][1]:
            if iv[1] > merged[-1][1]:
                merged[-1][1] = iv[1]
        else:
            merged.append(iv)
    return merged

Response SHA-256: e92aa25d90cf0ce27ba3aadd72a7def09e18d8d64a6280d7a1a8522dcdda40fe

coding-redact · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.004299. 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 {
            k: solve(v)
            for k, v in data.items()
            if not (isinstance(k, str) and k.lower() in ("password", "token", "secret"))
        }
    if isinstance(data, list):
        return [solve(item) for item in data]
    return data

Response SHA-256: 7bfeb56fad483265ac4e281aaebdfadcd671eb9fd1ba4889660607cd0723bcbd

coding-dedup · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005546. 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):
    best = {}
    for item in data:
        item_id = item['id']
        if item_id not in best or item['version'] >= best[item_id]['version']:
            best[item_id] = item
    return sorted(best.values(), key=lambda x: str(x['id']))

Response SHA-256: ce3e9ceee1d2562011168fe48481acdf9ef977d9209c6f77696527a2260e35d2

coding-slug · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003042. 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)
    without_marks = ''.join(c for c in normalized if not unicodedata.combining(c))
    lowercased = without_marks.lower()
    slug = re.sub(r'[^a-z0-9]+', '-', lowercased)
    return slug.strip('-')

Response SHA-256: bfa5514b3884038b272585e3fe3b261f1399a5a81ae475cb9768459b9c3b8fb3

coding-fifo · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004009. 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):
    lots = data.get('lots', [])
    to_sell = data.get('sold', 0)
    rem_units = 0
    rem_value = 0
    for q, p in lots:
        if to_sell >= q:
            to_sell -= q
        elif to_sell > 0:
            left_q = q - to_sell
            to_sell = 0
            rem_units += left_q
            rem_value += left_q * p
        else:
            rem_units += q
            rem_value += q * p
    return {
        'remaining_units': rem_units,
        'remaining_value_cents': rem_value,
        'unfilled_units': to_sell
    }

Response SHA-256: f82392962723b28fcf685f90e3a9a94b92a312e530597b0292c8f7e57ca0e186

coding-csv · repeat 1 · Fail

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

Request: Not exposed. Estimated cost: US$0.017066. 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 = {}
    reader = csv.DictReader(io.StringIO(data))
    for row in reader:
        customer = row.get('customer')
        cents = row.get('cents')
        if customer is None or customer.strip() == '':
            continue
        if cents is None or not re.fullmatch(r'[+-]?[0-9]+', cents):
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)
    return totals

Response SHA-256: 09b4b49f9ad4e5c9ca030197e9b7d6b317daea52231aa352ebb2ecd13fbea86e

coding-percentile · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003027. 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 = data.get('values')
    if not values:
        return None
    p = data.get('p')
    n = len(values)
    rank = max(1, math.ceil((p / 100) * n))
    sorted_values = sorted(values)
    return sorted_values[rank - 1]

Response SHA-256: 7c85d7cdc83a1e8febdf930058ebe4489b6e52d683b1e891c185b955543e63ea

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	88.9%	69.4%–100.0%	36 / 36	36 / 36	0	2.72 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-loan · repeat 1 · Fail

answer_mismatch · responded · 2026-10-05T05:43:30.710860+00:00 UTC

Request: Not exposed. Estimated cost: US$0.009011. 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.159879961185, "payment": 564.8816616650494}

Response SHA-256: 47e0bc1e6e905ba7b84017114a44ac8fdeeb9601075b58939a6a87218812d29c

math-queue · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004365. 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: e0ea88125e7df2fe103453fe6f71e634d738483e58f04e92566e4cb466df0a7b

math-discount · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001575. 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: 4d57ad070b67d31d6beab51bff085bcef1b4912c39cb2a5184b321e86f3050c4

math-margin · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.005457. 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: b7958337656ccedb864631aac3965641507bd6ce873bcc17bf73f5398700d520

math-variance · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001923. 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: 2c2fbb985a2da7b1a76e404d7a067aaccc8d9930a818b8b3f0fcc54888e864e0

math-npv · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.004188. 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: 49f05413a0cd82f2345bd1ee8b41f33e835555624bd6b6ac82cafcddfefef123

math-npv · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003989. 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: d5ccfe44e6b8c7931b930ea3b59b4f8ac866307ce33d3fdaf6721410b98ca53c

math-margin · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003792. 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: 61b4d34fa256030f2643d7d051770a17496f7ab912252089b9a3383cd4bd8e5b

math-capacity · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.003275. 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: 1627eed39eea6c393a80ec06a75115c499cbdd1729d9576be8e2d32abf6e31c2

math-break-even · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002343. 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: 70ae202ce0739d51f526b2290805631800db27dde61f95504b1b3203064f3d1a

math-allocation · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001804. 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: 48e4a427683035b77d0a31a7d767af3528bfbab3439a200eff052882e2965f9f

math-margin · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004471. 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: b2df43b89ac71b115a80f4dcb3e6d950f8c300217518f68be4feff6bcfb9be2f

math-variance · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002125. 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.3784048752090222}

Response SHA-256: 225fae507c29f5c383b674cb8dd7c25d4a07da8ff675bd21c42d79d8be249b60

math-discount · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.002307. 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: 7a58ec2a9237cda61584e329896f19c12c15b99aaaf06035db4cef5c1de58f91

math-bayes · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003872. 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.326460481099656}

Response SHA-256: 9ad4ea86191f73bcfea6d96e3ab71b002dbdb6b510daa159325b7b0091e6b31e

math-queue · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003874. 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: 9a5073c868675d4b588ff744ab1bcfbb4f88f0d6b3f8515e6d3131b09be21c44

math-variance · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001926. 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: bc194deba12d68ce1798b1518d843df06b1167a45e351b8a64308d03efa9c0b1

math-mix · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001434. 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: 30866187d95a8c3f073929ddfc4508b6a172d14609b14f729d0be220d4b8b1cd

math-bayes · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.004247. 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: f5025cc546e5380a86b7e64aae3dab48d35cdbca4355599751f043e7fe1fa061

math-discount · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001815. 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: a60a4e03e6bf24868d42ace0e6a0ee3ce2db6acd244b3500c1ac1697094bf488

math-weighted · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.002489. 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.0}

Response SHA-256: ab751c3862e55f9ff9c12548bf276baf5f5528a9162d16d4c613d2099c1f3df2

math-mix · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001854. 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: 95a9ce56f05f6f909eadf8f72b0b6c9d9d84fc52c7814fb921dbdbc2faf22bf0

math-weighted · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002384. 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.0}

Response SHA-256: 100a7fdefa256ffb620513140b89b7085962bceda2cb2f18cdf905e2f5bc1f0d

math-npv · repeat 1 · Fail

answer_mismatch · responded · 2026-10-05T05:44:02.059855+00:00 UTC

Request: Not exposed. Estimated cost: US$0.004476. 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.259196093163035}

Response SHA-256: d61a7a0b7d0305490cf13e6dbf08dfe24399edc88d5e2bdc4df1a7984b05d530

math-break-even · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.002392. 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: 4fd60ee0fbb0bcf6e1854a0c780a81c44dc6739016f1d140c4b765a4803d7d93

math-bayes · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003876. 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: 4e05a94746906cb4b7a91bff082e1ac617f894511576c0e37fbc535965f5c326

math-queue · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003713. 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: e2e54933f74cb61f708884f13b253db6f05980395f620835559d3be03d7d981f

math-weighted · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.002646. 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.0}

Response SHA-256: 92a51f65b4eb21bc0b7b04ec05939ecf66f3bbd985a5ecb44e0334714f0d22ad

math-capacity · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.002832. 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: 011357f97141ccc4a2bca8c6b4b7c0bc58f31d5f242766aded9238d838a3be1b

math-loan · repeat 2 · Fail

answer_mismatch · responded · 2026-10-05T05:46:35.555847+00:00 UTC

Request: Not exposed. Estimated cost: US$0.024686. 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.1598794149, "payment": 564.8816616423}

Response SHA-256: 68cb146a896024f614ef6e07b206b13fe51c9acdf4ba2615139f45df3063c808

math-mix · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001678. 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: 56a77c8bb8c5d1d70949d30e844a562ad674383fe8a2bfd68769b7ed3e6a9400

math-allocation · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001774. 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: 2ee3efa72a863a1a06e09f900510bce8f8c79ba0c43277dcf2147a47c74d0265

math-break-even · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.002077. 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: d3053c1b9f15ca54d4e9d8d852cd948b0fe74279d5335d5632ea01233ff485c5

math-capacity · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.002187. 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: f83c0b50ffcafe62540d684812ff8d2d3aae754313619a0793d5bad847b4aff1

math-loan · repeat 3 · Fail

answer_mismatch · responded · 2026-10-05T05:51:22.060646+00:00 UTC

Request: Not exposed. Estimated cost: US$0.007203. 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.15988296969, "payment": 564.8816617904038}

Response SHA-256: 5e597900a60016255432f8361210dd5b7eaee41bb42f882beba3f48302464c69

math-allocation · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001879. 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: d221242b81cc03f41ce3e2e998ea4ab7344e61a89590fb88bd092f64a7e7eaa9

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.56 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-variance · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001482. 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: b43c7cd404d19768f91f364e321da91f360f46420bd42dacaf611775b958d8c0

math-bayes · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001826. 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: d45ef9eab55b5b2dbf63b57b2c2ffccb84dd8edcf9985aa0571cc32ecf2cd3e7

math-capacity · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003016. 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: 2fd0c99f71efbc5ff9b1a6ab774384c8a64ccdba1291f0a73446aa6ce96a323a

math-bayes · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001627. 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: 983740d670a1296fc0a006cde29da0438fd059a6797f2b3a9a79e8b25848b9c0

math-capacity · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.002780. 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: 8bdb00b05bac116aa84d39603face74a8a293e04ff517cb62c0188e478c2c6a7

math-discount · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001517. 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: e5d79acd68377b3aa4b0f443cc295c717c08bc6b89be465ecdd0b69cc22a9837

math-bayes · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001646. 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.32646048109965635}

Response SHA-256: 77ecf63d38b10e442cda924ff0b997a64e9efe1f711315046b10261cfa6ed670

math-weighted · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001215. 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.0, "change_points": 10.5}

Response SHA-256: 557aca598b59a2cd8027d5141d65f3bfe125e5fe396b24536098537fe340a925

math-loan · repeat 3 · Fail

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

Request: Not exposed. Estimated cost: US$0.009076. 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: 7102bb87633e4a9824a1175382f25ec68c159a0b374bd806a9dfc702ff663982

math-npv · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003199. 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.25920360631106}

Response SHA-256: 131088f1dcba1c71da736050381c59aeefa6043f518b8c335208c1c5a4a038c3

math-npv · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.002685. 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: 1401343a3a7140418d7d1f6630da6dcdf90931ed0fba3865c456dbe5c39cbbd3

math-queue · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.003546. 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: 6f4328a8b77b5f9f2897f12974be1590a5f83ba17db2c708c090f7dade369458

math-variance · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001362. 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: 87be6d9ed6626753f6f4c5cdaa35b1b568b6791c28195e592c6433a4a87dc75f

math-margin · repeat 3 · Fail

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

Request: Not exposed. Estimated cost: US$0.004165. 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: 43c29c2f99a11d4b0a9d36c356752c80c84b78903820098afd7be85c3330f455

math-weighted · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001395. 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: 18fa0916f6fab7496a0a0cb97978b77c5c9f95c34672c5c55f2b1c64eec88b77

math-margin · repeat 2 · Fail

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

Request: Not exposed. Estimated cost: US$0.003119. 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: e832c42ca11a1729087557d24cee4f8410da740a159d9df49ba708daf2294c1b

math-allocation · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001547. 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: 535f9ced8e6aae09a5d676cd5eab7de0064a99ef35cdc7010c6905030220c117

math-allocation · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001622. 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: b245f6d8d5e0ea98f53d1dbb047a53631997591f011554de0f5398dbb21734e9

math-margin · repeat 1 · Fail

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

Request: Not exposed. Estimated cost: US$0.003509. 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: 9da98c8b45903be591429cf0e184cc27aa5a236e9eaa4340cd177a544f7ff99f

math-mix · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001357. 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: 18ae3e36d2c5358d7c6a61c6b083fd9b34087c0674adac9f8937864d8ea9dc54

math-loan · repeat 2 · Fail

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

Request: Not exposed. Estimated cost: US$0.010152. 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: 2eafd57e3ad0352033fdd82819103a760a0aa7f12e0dc646396b6ec422fbbde1

math-break-even · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001291. 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: 7a5d5a702e248f822b1efe61ccd482b6468d345999cce2dc93365857c0faf4d9

math-mix · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001323. 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: 6726a8ef2496e6c6ded5c31e724e6ee200c2357b78031f4d2eb65e6e17fcbafd

math-discount · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001224. 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: e496633da3de3bd0c019d1d51bb22ca0f95ea768841ee70b9fe59d726a8bca96

math-capacity · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002236. 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: 3457523fb98ceaaf75e3e6575b182a7e667d2a95916d7f418f0804c1c738874c

math-break-even · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002120. 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: 19f58c226d69e33c189db3d42e37069bbb2a74384e0a52719125b4c7a40e1150

math-weighted · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001302. 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.0, "change_points": 10.5}

Response SHA-256: 3395c69613812fbf4d701ffc668596675a75dca491b4aed5c5daccebee60fae3

math-discount · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001427. 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: 714790766682bff89ced069514205c4f8594e917bfd9dbf4f9fd2919f3b4ceb9

math-mix · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.001395. 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: 04c5b7d821228b33cfc489816c01ae22f3c6603be31724384998d94e0edf5494

math-allocation · repeat 3 · Pass

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

Request: Not exposed. Estimated cost: US$0.001524. 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: 87c06c591955971de8a788b4b0adb9f5cd290e6a7010889dbd3147805f4f5f22

math-npv · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002730. 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: 2a0ec6f7c2042bf797246c1f38784f4c0bd91e0d97c64d82fa537095271483a2

math-variance · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001474. 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.0, "sample_variance": 9.5, "standard_error": 1.378404875209022}

Response SHA-256: 416a7418c8aeffe432356b02da59b5ff3712948daca8900138fc231e8adde720

math-queue · repeat 1 · Pass

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

Request: Not exposed. Estimated cost: US$0.002196. 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: 05e04e212b9620763b06405212e88e3635324fcd2e75c3943750cbc48cb4e4d3

math-queue · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.003482. 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: 281d5ecc6cbc288872c21938b1b923473c60ae7d332153ab763cafe867053deb

math-break-even · repeat 2 · Pass

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

Request: Not exposed. Estimated cost: US$0.001947. 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: cf222667a7a3e96ee85f27e9c94b899d7fee4b0b5aa2a9b48344313e32f4e047

math-loan · repeat 1 · Fail

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

Request: Not exposed. Estimated cost: US$0.011990. 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: 18728aa6e2fd4050068079d0e9da978dfcdfb72aa924ea93d59348c48e909037