AI coding comparison tests and results

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    base = []
    rems = []
    for w in weights:
        q, r = divmod(total * w, s)
        base.append(q)
        rems.append(r)
    left = total - sum(base)
    order = sorted(range(n), key=lambda i: (-rems[i], i))
    for k in range(left):
        base[order[k]] += 1
    return base

$0.0032 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    base = []
    rems = []
    for w in weights:
        q, r = divmod(total * w, s)
        base.append(q)
        rems.append(r)
    left = total - sum(base)
    order = sorted(range(n), key=lambda i: (-rems[i], i))
    for k in range(left):
        base[order[k]] += 1
    return base

$0.0032 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    base = []
    rems = []
    for i, w in enumerate(weights):
        q, r = divmod(total * w, s)
        base.append(q)
        rems.append((-r, i))
    left = total - sum(base)
    order = sorted(rems)
    for k in range(left):
        base[order[k][1]] += 1
    return base

$0.0031 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0056 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0060 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0056 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

$0.0021 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

$0.0021 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

$0.0021 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    reader = csv.reader(io.StringIO(data))
    pat = re.compile(r'[+-]?[0-9]+')
    totals = {}
    first = True
    for row in reader:
        if first:
            first = False
            continue
        if not row:
            continue
        if len(row) != 2:
            continue
        cust, cents = row
        if cust.strip() == "":
            continue
        c = cents.strip()
        if not pat.fullmatch(c):
            continue
        v = int(c)
        totals[cust] = totals.get(cust, 0) + v
    return totals

$0.0035 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    reader = csv.reader(io.StringIO(data))
    pat = re.compile(r'[+-]?[0-9]+')
    totals = {}
    first = True
    for row in reader:
        if first:
            first = False
            continue
        if not row:
            continue
        if len(row) != 2:
            continue
        cust, cents = row[0], row[1].strip()
        if cust.strip() == "":
            continue
        if not pat.fullmatch(cents):
            continue
        totals[cust] = totals.get(cust, 0) + int(cents)
    return totals

$0.0035 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    reader = csv.reader(io.StringIO(data))
    pat = re.compile(r'[+-]?[0-9]+')
    totals = {}
    first = True
    for row in reader:
        if first:
            first = False
            continue
        if not row:
            continue
        if len(row) != 2:
            continue
        cust, cents = row
        if cust.strip() == "":
            continue
        c = cents.strip()
        if not pat.fullmatch(c):
            continue
        v = int(c)
        totals[cust] = totals.get(cust, 0) + v
    return totals

$0.0035 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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)

$0.0101 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0073 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0134 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0027 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0022 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0022 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0020 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0020 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0020 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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)]

$0.0088 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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())]

$0.0050 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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())]

$0.0041 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0014 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0015 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    adj = {}
    indeg = {}
    for job, prereqs in data.items():
        nodes.add(job)
        for p in prereqs:
            nodes.add(p)
    for n in nodes:
        adj[n] = set()
        indeg[n] = 0
    for job, prereqs in data.items():
        for p in set(prereqs):
            if job not in adj[p]:
                adj[p].add(job)
                indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    result = []
    while heap:
        n = heapq.heappop(heap)
        result.append(n)
        for m in adj[n]:
            indeg[m] -= 1
            if indeg[m] == 0:
                heapq.heappush(heap, m)
    if len(result) != len(nodes):
        return None
    return result

$0.0045 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    for job, prereqs in data.items():
        nodes.add(job)
        for p in prereqs:
            nodes.add(p)
    indeg = {n: 0 for n in nodes}
    adj = {n: set() for n in nodes}
    for job, prereqs in data.items():
        for p in set(prereqs):
            adj[p].add(job)
            indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    result = []
    while heap:
        n = heapq.heappop(heap)
        result.append(n)
        for m in adj[n]:
            indeg[m] -= 1
            if indeg[m] == 0:
                heapq.heappush(heap, m)
    if len(result) != len(nodes):
        return None
    return result

$0.0043 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    edges = {}
    for job, prereqs in data.items():
        nodes.add(job)
        for p in prereqs:
            nodes.add(p)
    indeg = {n: 0 for n in nodes}
    children = {n: set() for n in nodes}
    for job, prereqs in data.items():
        for p in set(prereqs):
            children[p].add(job)
            indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    result = []
    while heap:
        n = heapq.heappop(heap)
        result.append(n)
        for c in children[n]:
            indeg[c] -= 1
            if indeg[c] == 0:
                heapq.heappush(heap, c)
    if len(result) != len(nodes):
        return None
    return result

$0.0043 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0044 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0060 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0077 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import heapq

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

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

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

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

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

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

$0.0030 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import heapq

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

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

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

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

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

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

$0.0029 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import heapq

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

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

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

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

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

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

$0.0029 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    sold = data["sold"]
    need = sold
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        q = lot[0]
        p = lot[1]
        take = min(q, need)
        need -= take
        left = q - take
        remaining_units += left
        remaining_value += left * p
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": need,
    }

$0.0030 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    sold = data["sold"]
    to_sell = sold
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        q = lot[0]
        p = lot[1]
        take = min(q, to_sell)
        to_sell -= take
        left = q - take
        remaining_units += left
        remaining_value += left * p
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell,
    }

$0.0031 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    sold = data["sold"]
    need = sold
    units = 0
    value = 0
    for q, p in lots:
        take = min(q, need)
        need -= take
        rem = q - take
        units += rem
        value += rem * p
    return {
        "remaining_units": units,
        "remaining_value_cents": value,
        "unfilled_units": need,
    }

$0.0026 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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,
    }

$0.0041 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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,
    }

$0.0041 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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,
    }

$0.0034 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0021 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0020 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0022 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s, e = iv[0], iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    res = []
    for s, e in items:
        if res and s <= res[-1][1]:
            if e > res[-1][1]:
                res[-1][1] = e
        else:
            res.append([s, e])
    return res

$0.0025 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    res = []
    for s, e in items:
        if res and s <= res[-1][1]:
            if e > res[-1][1]:
                res[-1][1] = e
        else:
            res.append([s, e])
    return res

$0.0025 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s, e = iv[0], iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    res = []
    for s, e in items:
        if res and s <= res[-1][1]:
            if e > res[-1][1]:
                res[-1][1] = e
        else:
            res.append([s, e])
    return res

$0.0025 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0053 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0043 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0040 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0016 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0016 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0016 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    values = data.get("values") if isinstance(data, dict) else None
    if not values:
        return None
    p = data.get("p", 0)
    s = sorted(values)
    n = len(s)
    rank = max(1, math.ceil(p / 100 * n))
    rank = min(rank, n)
    return s[rank - 1]

$0.0024 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    values = data.get("values") if isinstance(data, dict) else None
    if not values:
        return None
    p = data.get("p", 0)
    s = sorted(values)
    n = len(s)
    rank = max(1, math.ceil(p / 100 * n))
    rank = min(rank, n)
    return s[rank - 1]

$0.0024 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

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

$0.0023 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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]

$0.0074 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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]

$0.0047 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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]

$0.0059 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0014 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0014 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0014 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    from collections import deque, defaultdict
    limit = data["limit"]
    window = data["window"]
    acc = defaultdict(deque)
    res = []
    for ev in data["events"]:
        u = ev["user"]
        t = ev["time"]
        d = acc[u]
        while d and d[0] <= t - window:
            d.popleft()
        if len(d) < limit:
            d.append(t)
            res.append(True)
        else:
            res.append(False)
    return res

$0.0029 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    from collections import deque, defaultdict
    limit = data["limit"]
    window = data["window"]
    acc = defaultdict(deque)
    res = []
    for ev in data["events"]:
        u = ev["user"]
        t = ev["time"]
        d = acc[u]
        while d and d[0] <= t - window:
            d.popleft()
        if len(d) < limit:
            d.append(t)
            res.append(True)
        else:
            res.append(False)
    return res

$0.0029 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

The approach is a sliding window per user, kept as a deque of accepted times. For each event at time t, drop accepted times that are at or below t - window, since only times strictly greater than t - window count. If fewer than `limit` remain, accept the event and record its time. Otherwise reject it, which leaves the allowance unchanged.

Times are nondecreasing, so pruning from the left is safe: a time dropped for one event would also be dropped for every later event.

The input is not mutated, and events are read only through `e["user"]` and `e["time"]`.

import collections is needed for deque.

import collections

def solve(data):
    limit = data["limit"]
    window = data["window"]
    dq = collections.defaultdict(collections.deque)
    res = []
    for e in data["events"]:
        u = e["user"]
        t = e["time"]
        d = dq[u]
        while d and d[0] <= t - window:
            d.popleft()
        if len(d) < limit:
            d.append(t)
            res.append(True)
        else:
            res.append(False)
    return res

$0.0047 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0051 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0047 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0055 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import deque

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

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

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

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

    return result

$0.0021 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import deque

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

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

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

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

    return results

$0.0021 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import deque

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

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

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

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

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

    return result

$0.0021 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0029 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0029 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0029 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0029 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0037 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0032 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0019 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0018 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0018 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    banned = {"password", "token", "secret"}

    def clean(x):
        if isinstance(x, dict):
            result = {}
            for k, v in x.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                result[k] = clean(v)
            return result
        if isinstance(x, list):
            return [clean(i) for i in x]
        return x

    return clean(data)

$0.0026 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    blocked = {"password", "token", "secret"}

    def clean(x):
        if isinstance(x, dict):
            result = {}
            for k, v in x.items():
                if isinstance(k, str) and k.lower() in blocked:
                    continue
                result[k] = clean(v)
            return result
        if isinstance(x, list):
            return [clean(i) for i in x]
        return x

    return clean(data)

$0.0026 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import json

def solve(data):
    banned = {"password", "token", "secret"}

    def clean(x):
        if isinstance(x, dict):
            result = {}
            for k, v in x.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                result[k] = clean(v)
            return result
        if isinstance(x, list):
            return [clean(i) for i in x]
        return x

    return clean(data)

$0.0026 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0036 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0042 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0036 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0015 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

The approach is to aggregate the counts per day, sort the distinct days, and build prefix sums. Each query then needs two binary searches, because `bisect` is not an allowed import, so I wrote a small manual one.

For a query q, the answer is prefix[hi] - prefix[lo], where lo is the number of days less than q-6 and hi is the number of days less than or equal to q.

No input is mutated, and the output is a list of ints in query order. The input is a dict with keys "events" and "query_days"; I assume `data` is already a dict, not a JSON string.

def solve(data):
    events = data.get("events", [])
    queries = data.get("query_days", [])
    agg = {}
    for e in events:
        d = e[0]
        c = e[1]
        agg[d] = agg.get(d, 0) + c
    days = sorted(agg.keys())
    prefix = [0]
    for d in days:
        prefix.append(prefix[-1] + agg[d])

    def count_less(x):
        # number of days < x
        lo = 0
        hi = len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    res = []
    for q in queries:
        a = count_less(q - 6)
        b = count_less(q + 1)
        res.append(prefix[b] - prefix[a])
    return res

$0.0060 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

The approach is to aggregate the counts per day, sort the distinct days, and build prefix sums. Each query then needs two binary searches, since `bisect` is not available and I write them by hand.

For a query q, the total is the sum of counts over days in [q-6, q]. That equals prefix(upper) - prefix(lower), where upper is the number of days <= q and lower is the number of days < q-6.

The function receives a dict, so it reads `data["events"]` and `data["query_days"]`. The input is not mutated.

```python
import math

def solve(data):
    events = data.get("events", [])
    queries = data.get("query_days", [])
    agg = {}
    for e in events:
        d = e[0]
        c = e[1]
        agg[d] = agg.get(d, 0) + c
    days = sorted(agg.keys())
    prefix = [0]
    for d in days:
        prefix.append(prefix[-1] + agg[d])

    def count_le(x):
        # number of days <= x
        lo, hi = 0, len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] <= x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    res = []
    for q in queries:
        hi_i = count_le(q)
        lo_i = count_le(q - 7)
        res.append(prefix[hi_i] - prefix[lo_i])
    return res
```

Here `count_le(q - 7)` counts days <= q-7, which is the same as days < q-6 for integers.

$0.0064 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

The approach is to aggregate the counts per day, sort the distinct days, and build prefix sums. Each query is then answered with binary search over the sorted days, using a hand-written bisect since `bisect` is not an allowed import.

For each query q, the answer is prefix(upper) − prefix(lower), where `lo` is the first index with day >= q−6 and `hi` is the first index with day > q.

Implementation details:
- `data` is a dict with keys "events" and "query_days".
- Counts are integers, so sums stay exact.
- The input is not mutated.

```python
def solve(data):
    events = data.get("events", [])
    queries = data.get("query_days", [])
    agg = {}
    for e in events:
        d = e[0]
        c = e[1]
        agg[d] = agg.get(d, 0) + c
    days = sorted(agg.keys())
    pref = [0]
    for d in days:
        pref.append(pref[-1] + agg[d])

    def first_ge(x):
        lo, hi = 0, len(days)
        while lo < hi:
            m = (lo + hi) // 2
            if days[m] < x:
                lo = m + 1
            else:
                hi = m
        return lo

    def first_gt(x):
        lo, hi = 0, len(days)
        while lo < hi:
            m = (lo + hi) // 2
            if days[m] <= x:
                lo = m + 1
            else:
                hi = m
        return lo

    res = []
    for q in queries:
        a = first_ge(q - 6)
        b = first_gt(q)
        res.append(pref[b] - pref[a])
    return res
```

$0.0067 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0075 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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

$0.0027 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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
    ]

$0.0050 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0022 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

        result[index] = total

    return result

$0.0041 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

    return results

$0.0022 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

The approach is to normalize the input to NFKD, drop combining marks, lowercase it, then turn every run of characters outside a-z and 0-9 into a single hyphen and strip hyphens from the ends.

Lowercasing after NFKD is safe. A few characters, such as "İ", decompose into "I" plus a combining dot, so the combining mark is dropped and "i" remains. Lowercasing a string can also produce new combining characters, so I lowercase first and then remove combining marks.

To be safe I do the steps in this order:
1. Normalize with NFKD.
2. Lowercase.
3. Drop combining marks.
4. Replace runs of non-[a-z0-9] characters with a hyphen.
5. Strip hyphens from the edges.

A character that lowercases to several characters, like "İ" becoming "i̇", is handled by the combining-mark removal in step 3. Because the regex matches only ASCII a-z and digits, anything non-ASCII is replaced. Dropped combining marks are removed outright and do not produce a hyphen.

```python
import unicodedata
import re

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

$0.0059 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0023 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata

def solve(data):
    s = unicodedata.normalize("NFKD", data)
    s = "".join(c for c in s if not unicodedata.combining(c))
    s = s.lower()
    out = []
    pending = False
    for c in s:
        if ("a" <= c <= "z") or ("0" <= c <= "9"):
            if pending and out:
                out.append("-")
            pending = False
            out.append(c)
        else:
            pending = True
    return "".join(out)

$0.0029 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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('-')

$0.0030 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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('-')

$0.0036 estimated; billed reconciliation remains separate.

Gemini Developer API, paid Standard · medium reasoning

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('-')

$0.0050 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0015 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0004 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0003 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    rows = csv.reader(io.StringIO(data))
    header = next(rows, None)
    while header == []:
        header = next(rows, None)

    totals = {}
    if header != ["customer", "cents"]:
        return totals

    for row in rows:
        if len(row) != 2:
            continue
        customer, cents = row
        if customer.strip() == "":
            continue
        cents = cents.strip()
        if re.fullmatch(r"[+-]?[0-9]+", cents) is None:
            continue
        totals[customer] = totals.get(customer, 0) + int(cents)

    return totals

$0.0005 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import heapq

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

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

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

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

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

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

$0.0003 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from heapq import heapify, heappop, heappush

def solve(data):
    dependencies = {}
    nodes = set(data)

    for name, prerequisites in data.items():
        unique_prerequisites = set(prerequisites)
        dependencies[name] = unique_prerequisites
        nodes.update(unique_prerequisites)

    for name in nodes:
        if name not in dependencies:
            dependencies[name] = set()

    outgoing = {name: [] for name in nodes}
    indegree = {}

    for name in nodes:
        indegree[name] = len(dependencies[name])
        for prerequisite in dependencies[name]:
            outgoing[prerequisite].append(name)

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

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

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

$0.0004 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import heapq
from collections import defaultdict

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

    indegree = {name: 0 for name in names}
    dependents = defaultdict(list)

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

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

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

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

$0.0003 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

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

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import math

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import deque

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

    for event in data["events"]:
        user = event["user"]
        time = event["time"]
        times = accepted.get(user)
        if times is None:
            times = deque()
            accepted[user] = times

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

        if len(times) < limit:
            result.append(True)
            times.append(time)
        else:
            result.append(False)

    return result

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import defaultdict, deque

def solve(data):
    limit = data["limit"]
    window = data["window"]
    accepted = defaultdict(deque)
    result = []

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

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

        if len(times) < limit:
            result.append(True)
            times.append(time)
        else:
            result.append(False)

    return result

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

from collections import defaultdict, deque

def solve(data):
    accepted = defaultdict(deque)
    result = []

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

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

        if len(history) < data["limit"]:
            result.append(True)
            history.append(time)
        else:
            result.append(False)

    return result

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

def solve(data):
    balances = {}
    for invoice in data["invoices"]:
        ident = invoice["id"]
        if ident not in balances:
            balances[ident] = 0
        balances[ident] += invoice["cents"]

    for payment in data["payments"]:
        ident = payment["id"]
        if ident not in balances:
            balances[ident] = 0
        balances[ident] -= payment["cents"]

    return {ident: balances[ident] for ident in sorted(balances) if balances[ident] != 0}

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

    return clean(data)

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

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

    return clean(data)

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

def solve(data):
    blocked = ("password", "token", "secret")

    def clean(value):
        if isinstance(value, dict):
            return {
                key: clean(item)
                for key, item in value.items()
                if key.lower() not in blocked
            }
        if isinstance(value, list):
            return [clean(item) for item in value]
        return value

    return clean(data)

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

def solve(data):
    totals = {}
    for day, count in data["events"]:
        totals[day] = totals.get(day, 0) + count

    return [
        sum(totals.get(day, 0) for day in range(query - 6, query + 1))
        for query in data["query_days"]
    ]

$0.0002 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

def solve(data):
    return [
        sum(count for day, count in data["events"] if query_day - 6 <= day <= query_day)
        for query_day in data["query_days"]
    ]

$0.0001 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

def solve(data):
    totals = {}
    for day, count in data["events"]:
        totals[day] = totals.get(day, 0) + count

    days = sorted(totals)
    prefix = [0]
    for day in days:
        prefix.append(prefix[-1] + totals[day])

    result = []
    for query in data["query_days"]:
        left_value = query - 6
        low, high = 0, len(days)
        while low < high:
            middle = (low + high) // 2
            if days[middle] < left_value:
                low = middle + 1
            else:
                high = middle
        left = low

        low, high = 0, len(days)
        while low < high:
            middle = (low + high) // 2
            if days[middle] <= query:
                low = middle + 1
            else:
                high = middle
        right = low
        result.append(prefix[right] - prefix[left])

    return result

$0.0004 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata

def solve(data):
    text = unicodedata.normalize("NFKD", data).lower()
    parts = []
    separator = False

    for char in text:
        if unicodedata.category(char).startswith("M"):
            continue
        if "a" <= char <= "z" or "0" <= char <= "9":
            if separator and parts:
                parts.append("-")
            parts.append(char)
            separator = False
        else:
            separator = True

    return "".join(parts)

$0.0003 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    text = ""
    for char in normalized:
        if unicodedata.category(char)[0] != "M":
            text += char
    text = text.lower()

    slug = ""
    for char in text:
        if "a" <= char <= "z" or "0" <= char <= "9":
            slug += char
        elif slug and slug[-1] != "-":
            slug += "-"

    while slug and slug[0] == "-":
        slug = slug[1:]
    while slug and slug[-1] == "-":
        slug = slug[:-1]
    return slug

$0.0004 estimated; billed reconciliation remains separate.

OpenAI direct API, Standard global · medium reasoning

import unicodedata

def solve(data):
    normalized = unicodedata.normalize("NFKD", data)
    result = []
    pending_hyphen = False

    for char in normalized:
        if unicodedata.category(char)[0] == "M":
            continue
        for lowered in char.lower():
            if "a" <= lowered <= "z" or "0" <= lowered <= "9":
                if pending_hyphen:
                    result.append("-")
                    pending_hyphen = False
                result.append(lowered)
            elif result:
                pending_hyphen = True

    return "".join(result)

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data.get("total", 0)
    weights = list(data.get("weights", []))
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    shares = []
    rems = []
    for i, w in enumerate(weights):
        q, r = divmod(total * w, s)
        shares.append(q)
        rems.append((-r, i))
    left = total - sum(shares)
    rems.sort()
    for k in range(left):
        shares[rems[k][1]] += 1
    return shares

$0.0064 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data["total"]
    weights = list(data["weights"])
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    shares = []
    rems = []
    for i, w in enumerate(weights):
        q, r = divmod(total * w, s)
        shares.append(q)
        rems.append((-r, i))
    left = total - sum(shares)
    rems.sort()
    for k in range(left):
        shares[rems[k][1]] += 1
    return shares

$0.0062 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0] * n
    shares = []
    rems = []
    for i, w in enumerate(weights):
        q, r = divmod(total * w, s)
        shares.append(q)
        rems.append((-r, i))
    left = total - sum(shares)
    rems.sort()
    for k in range(left):
        shares[rems[k][1]] += 1
    return shares

$0.0062 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    pattern = re.compile(r'[+-]?[0-9]+', re.ASCII)
    reader = csv.reader(io.StringIO(data, newline=''))
    totals = {}
    header_seen = False
    for row in reader:
        if not row:
            continue
        if not header_seen:
            header_seen = True
            continue
        if len(row) != 2:
            continue
        customer, cents = row[0], row[1]
        if customer.strip() == '':
            continue
        c = cents.strip()
        if not pattern.fullmatch(c):
            continue
        totals[customer] = totals.get(customer, 0) + int(c)
    return totals

$0.0158 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re


def solve(data):
    pattern = re.compile(r'[+-]?[0-9]+')
    totals = {}
    reader = csv.reader(io.StringIO(data, newline=''))
    first = True
    for row in reader:
        if first:
            first = False
            continue
        if not row:
            continue
        if len(row) != 2:
            continue
        customer, cents = row[0], row[1]
        if customer.strip() == "":
            continue
        c = cents.strip()
        if not pattern.fullmatch(c):
            continue
        value = int(c)
        totals[customer] = totals.get(customer, 0) + value
    return totals

$0.0144 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re


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

    for row in reader:
        # Skip empty lines
        if not row:
            continue

        # The first non-empty row is the header
        if not header_seen:
            header_seen = True
            continue

        # Ignore rows missing a field or containing extra fields
        if len(row) != 2:
            continue

        customer, cents = row[0], row[1]

        # Ignore blank customers (including whitespace-only)
        if customer.strip() == "":
            continue

        # Accept only optional +/- followed by ASCII digits
        c = cents.strip()
        if not pattern.fullmatch(c):
            continue

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

    return totals

$0.0165 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    for item in data:
        i = item["id"]
        v = item["version"]
        if i not in best or v >= best[i]["version"]:
            best[i] = item
    result = []
    for k in sorted(best.keys()):
        it = best[k]
        result.append(dict(it))
    return result

$0.0046 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    for item in data:
        i = item["id"]
        v = item["version"]
        if i not in best or v >= best[i]["version"]:
            best[i] = item
    result = []
    for k in sorted(best.keys()):
        it = best[k]
        result.append({"id": it["id"], "version": it["version"], "value": it["value"]})
    return result

$0.0050 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    for item in data:
        i = item["id"]
        v = item["version"]
        cur = best.get(i)
        if cur is None or v >= cur["version"]:
            best[i] = item
    return [dict(best[k]) for k in sorted(best)]

$0.0044 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    indeg = {}
    adj = {}
    for job, prereqs in data.items():
        nodes.add(job)
        for p in prereqs:
            nodes.add(p)
    for n in nodes:
        indeg[n] = 0
        adj[n] = []
    for job, prereqs in data.items():
        for p in set(prereqs):
            adj[p].append(job)
            indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    order = []
    while heap:
        n = heapq.heappop(heap)
        order.append(n)
        for m in adj[n]:
            indeg[m] -= 1
            if indeg[m] == 0:
                heapq.heappush(heap, m)
    if len(order) != len(nodes):
        return None
    return order

$0.0087 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    deps = {}
    for job, prereqs in data.items():
        nodes.add(job)
        s = set(prereqs)
        deps[job] = s
        for p in s:
            nodes.add(p)
    indeg = {n: 0 for n in nodes}
    children = {n: [] for n in nodes}
    for job, s in deps.items():
        for p in s:
            if p == job:
                return None
            children[p].append(job)
            indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    order = []
    while heap:
        n = heapq.heappop(heap)
        order.append(n)
        for c in children[n]:
            indeg[c] -= 1
            if indeg[c] == 0:
                heapq.heappush(heap, c)
    if len(order) != len(nodes):
        return None
    return order

$0.0090 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    deps = {}
    for job, prereqs in data.items():
        nodes.add(job)
        s = set(prereqs)
        deps[job] = s
        for p in s:
            nodes.add(p)
    indeg = {n: 0 for n in nodes}
    children = {n: [] for n in nodes}
    for job, s in deps.items():
        for p in s:
            indeg[job] += 1
            children[p].append(job)
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    order = []
    while heap:
        n = heapq.heappop(heap)
        order.append(n)
        for c in children[n]:
            indeg[c] -= 1
            if indeg[c] == 0:
                heapq.heappush(heap, c)
    if len(order) != len(nodes):
        return None
    return order

$0.0088 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data.get("lots", []) or []
    sold = data.get("sold", 0) or 0
    to_sell = sold
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        q = lot[0]
        p = lot[1]
        take = min(q, to_sell)
        to_sell -= take
        left = q - take
        remaining_units += left
        remaining_value += left * p
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell,
    }

$0.0065 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data.get("lots", []) or []
    sold = data.get("sold", 0) or 0
    remaining_units = 0
    remaining_value = 0
    to_sell = sold
    for lot in lots:
        q = lot[0]
        p = lot[1]
        take = min(q, to_sell)
        to_sell -= take
        left = q - take
        remaining_units += left
        remaining_value += left * p
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell,
    }

$0.0065 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data.get("lots", []) or []
    to_sell = data.get("sold", 0) or 0
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        q = lot[0]
        p = lot[1]
        take = min(q, to_sell)
        to_sell -= take
        left = q - take
        remaining_units += left
        remaining_value += left * p
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell,
    }

$0.0064 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1][1] = e
        else:
            result.append([s, e])
    return result

$0.0050 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1][1] = e
        else:
            result.append([s, e])
    return result

$0.0050 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s, e = iv[0], iv[1]
        if s < e:
            items.append((s, e))
    items.sort()
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1][1] = e
        else:
            result.append([s, e])
    return result

$0.0050 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math


def solve(data):
    values = data.get("values") or []
    n = len(values)
    if n == 0:
        return None

    p = data.get("p", 0)

    # Compute ceil(p/100*n) exactly from p's rational value,
    # avoiding floating-point rounding errors.
    if isinstance(p, int):
        num, den = p, 1
    else:
        num, den = float(p).as_integer_ratio()

    rank = -((-(num * n)) // (den * 100))

    if rank < 1:
        rank = 1
    if rank > n:
        rank = n

    s = sorted(values)
    return s[rank - 1]

$0.0134 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math


def _to_fraction(p):
    # Return (numerator, denominator) for p as an exact rational,
    # using its shortest decimal form so that e.g. 14.3 stays 14.3.
    if isinstance(p, int):
        return p, 1
    s = repr(float(p)).lower()
    neg = False
    if s.startswith('-'):
        neg = True
        s = s[1:]
    elif s.startswith('+'):
        s = s[1:]
    exp = 0
    if 'e' in s:
        mant, e = s.split('e')
        exp = int(e)
    else:
        mant = s
    if '.' in mant:
        ip, fp = mant.split('.')
    else:
        ip, fp = mant, ''
    digits = (ip + fp).lstrip('0') or '0'
    num = int(digits)
    exp -= len(fp)
    if exp >= 0:
        num = num * (10 ** exp)
        den = 1
    else:
        den = 10 ** (-exp)
    if neg:
        num = -num
    return num, den


def solve(data):
    values = data.get('values') or []
    n = len(values)
    if n == 0:
        return None
    p = data.get('p', 0)
    num, den = _to_fraction(p)
    # rank = ceil(p * n / 100), computed exactly with integers
    rank = -((-num * n) // (den * 100))
    if rank < 1:
        rank = 1
    if rank > n:
        rank = n
    s = sorted(values)
    return s[rank - 1]

$0.0231 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math

def solve(data):
    values = data.get("values") or []
    n = len(values)
    if n == 0:
        return None
    p = data.get("p", 0)
    s = sorted(values)
    # Exact rational arithmetic avoids float rounding errors in ceil(p/100*n)
    if isinstance(p, int) and not isinstance(p, bool):
        num, den = p, 1
    else:
        num, den = float(p).as_integer_ratio()
    rank = -((-num * n) // (den * 100))
    rank = max(1, rank)
    rank = min(n, rank)
    return s[rank - 1]

$0.0124 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import collections

def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data.get("events", [])
    accepted = collections.defaultdict(collections.deque)
    result = []
    for ev in events:
        user = ev["user"]
        t = ev["time"]
        q = accepted[user]
        threshold = t - window
        while q and q[0] <= threshold:
            q.popleft()
        if len(q) < limit:
            q.append(t)
            result.append(True)
        else:
            result.append(False)
    return result

$0.0062 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import collections

def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data["events"]
    accepted_times = collections.defaultdict(collections.deque)
    result = []
    for event in events:
        user = event["user"]
        t = event["time"]
        q = accepted_times[user]
        while q and q[0] <= t - window:
            q.popleft()
        if len(q) < limit:
            q.append(t)
            result.append(True)
        else:
            result.append(False)
    return result

$0.0060 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import collections

def solve(data):
    limit = data["limit"]
    window = data["window"]
    events = data["events"]
    accepted = collections.defaultdict(collections.deque)
    result = []
    for ev in events:
        user = ev["user"]
        t = ev["time"]
        q = accepted[user]
        while q and q[0] <= t - window:
            q.popleft()
        if len(q) < limit:
            q.append(t)
            result.append(True)
        else:
            result.append(False)
    return result

$0.0059 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0059 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0059 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    totals = {}
    for inv in data.get("invoices", []) or []:
        k = inv["id"]
        totals[k] = totals.get(k, 0) + inv["cents"]
    for p in data.get("payments", []) or []:
        k = p["id"]
        totals[k] = totals.get(k, 0) - p["cents"]
    result = {}
    for k in sorted(totals):
        if totals[k] != 0:
            result[k] = totals[k]
    return result

$0.0058 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    banned = {"password", "token", "secret"}

    def clean(x):
        if isinstance(x, dict):
            out = {}
            for k, v in x.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                out[k] = clean(v)
            return out
        if isinstance(x, list):
            return [clean(v) for v in x]
        if isinstance(x, tuple):
            return [clean(v) for v in x]
        return x

    return clean(data)

$0.0057 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    banned = {"password", "token", "secret"}

    def clean(v):
        if isinstance(v, dict):
            out = {}
            for k, val in v.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                out[k] = clean(val)
            return out
        if isinstance(v, list):
            return [clean(x) for x in v]
        if isinstance(v, tuple):
            return [clean(x) for x in v]
        return v

    stack_safe = True
    try:
        return clean(data)
    except RecursionError if False else Exception:
        pass

    # Iterative fallback for very deep structures
    root_holder = [None]
    work = [(data, root_holder, 0)]
    while work:
        v, parent, key = work.pop()
        if isinstance(v, dict):
            new = {}
            parent[key] = new
            for k, val in v.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                new[k] = None
                work.append((val, new, k))
        elif isinstance(v, (list, tuple)):
            new = [None] * len(v)
            parent[key] = new
            for i, x in enumerate(v):
                work.append((x, new, i))
        else:
            parent[key] = v
    return root_holder[0]

$0.0111 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    banned = {"password", "token", "secret"}

    def rec(x):
        if isinstance(x, dict):
            out = {}
            for k, v in x.items():
                if isinstance(k, str) and k.lower() in banned:
                    continue
                out[k] = rec(v)
            return out
        if isinstance(x, list):
            return [rec(v) for v in x]
        if isinstance(x, tuple):
            return [rec(v) for v in x]
        return x

    return rec(data)

$0.0057 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import collections

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

    agg = collections.defaultdict(int)
    for ev in events:
        agg[int(ev[0])] += int(ev[1])

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

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

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

    result = []
    for q in queries:
        q = int(q)
        left = lower_bound(q - 6)
        right = upper_bound(q)
        result.append(prefix[right] - prefix[left])
    return result

$0.0118 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

    # Combine counts that fall on the same day.
    agg = {}
    for ev in events:
        d = ev[0]
        c = ev[1]
        agg[d] = agg.get(d, 0) + c

    days = sorted(agg.keys())

    # prefix[i] is the total count of the first i sorted days.
    prefix = [0]
    for d in days:
        prefix.append(prefix[-1] + agg[d])

    def lower_bound(x):
        # First index whose day is >= x.
        lo, hi = 0, len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def upper_bound(x):
        # First index whose day is > x.
        lo, hi = 0, len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] <= x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    result = []
    for q in queries:
        left = lower_bound(q - 6)
        right = upper_bound(q)
        result.append(prefix[right] - prefix[left])
    return result

$0.0129 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

    # Combine counts for repeated days.
    agg = {}
    for ev in events:
        d = ev[0]
        c = ev[1]
        agg[d] = agg.get(d, 0) + c

    days = sorted(agg.keys())

    # prefix[i] is the total count of days[0..i-1].
    prefix = [0]
    for d in days:
        prefix.append(prefix[-1] + agg[d])

    def upper(x):
        # Number of days that are <= x.
        lo, hi = 0, len(days)
        while lo < hi:
            mid = (lo + hi) // 2
            if days[mid] <= x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    res = []
    for q in queries:
        hi_idx = upper(q)
        lo_idx = upper(q - 7)
        res.append(prefix[hi_idx] - prefix[lo_idx])
    return res

$0.0110 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0046 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0046 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata
import re

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

$0.0046 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0 for _ in range(n)]
    floors = [total * w // s for w in weights]
    rems = [total * w % s for w in weights]
    leftover = total - sum(floors)
    order = sorted(range(n), key=lambda i: (-rems[i], i))
    result = list(floors)
    for k in range(leftover):
        result[order[k]] += 1
    return result

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0 for _ in range(n)]
    products = [total * w for w in weights]
    floors = [p // s for p in products]
    rems = [p % s for p in products]
    leftover = total - sum(floors)
    order = sorted(range(n), key=lambda i: (-rems[i], i))
    result = list(floors)
    for k in range(leftover):
        result[order[k]] += 1
    return result

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    total = data["total"]
    weights = data["weights"]
    n = len(weights)
    if n == 0:
        return []
    s = sum(weights)
    if s == 0:
        return [0 for _ in range(n)]
    floors = [total * w // s for w in weights]
    rems = [total * w % s for w in weights]
    leftover = total - sum(floors)
    order = sorted(range(n), key=lambda i: (-rems[i], i))
    result = list(floors)
    for k in range(leftover):
        result[order[k]] += 1
    return result

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0008 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

def solve(data):
    totals = {}
    pat = re.compile(r'[+-]?[0-9]+')
    reader = csv.reader(io.StringIO(data))
    first = True
    for row in reader:
        if first:
            first = False
            continue
        if len(row) != 2:
            continue
        customer = row[0]
        cents = row[1]
        if customer.strip() == "":
            continue
        c = cents.strip()
        if pat.fullmatch(c) is None:
            continue
        if customer not in totals:
            totals[customer] = 0
        totals[customer] += int(c)
    return totals

$0.0006 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import csv
import io
import re

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

$0.0007 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    order = []
    for item in data:
        key = item["id"]
        ver = item["version"]
        if key not in best:
            best[key] = {"id": item["id"], "version": ver, "value": item["value"]}
        else:
            if ver >= best[key]["version"]:
                best[key] = {"id": item["id"], "version": ver, "value": item["value"]}
    result = []
    for key in sorted(best.keys()):
        result.append(best[key])
    return result

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    order = []
    for item in data:
        k = item["id"]
        v = item["version"]
        if k not in best:
            best[k] = item
        else:
            if v >= best[k]["version"]:
                best[k] = item
    ids = sorted(best.keys())
    result = []
    for k in ids:
        it = best[k]
        result.append({"id": it["id"], "version": it["version"], "value": it["value"]})
    return result

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    best = {}
    order = []
    for item in data:
        key = item["id"]
        ver = item["version"]
        if key not in best:
            best[key] = {"id": item["id"], "version": ver, "value": item["value"]}
        else:
            if ver >= best[key]["version"]:
                best[key] = {"id": item["id"], "version": ver, "value": item["value"]}
    result = []
    for key in sorted(best.keys()):
        result.append(best[key])
    return result

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq


def solve(data):
    nodes = set()
    prereqs = {}
    for job in data:
        nodes.add(job)
        ps = set(data[job])
        prereqs[job] = ps
        nodes.update(ps)

    indeg = {}
    dependents = {}
    for n in nodes:
        indeg[n] = 0
        dependents[n] = []

    for job in prereqs:
        for p in prereqs[job]:
            indeg[job] += 1
            dependents[p].append(job)

    heap = []
    for n in nodes:
        if indeg[n] == 0:
            heap.append(n)
    heapq.heapify(heap)

    result = []
    while heap:
        n = heapq.heappop(heap)
        result.append(n)
        for d in dependents[n]:
            indeg[d] -= 1
            if indeg[d] == 0:
                heapq.heappush(heap, d)

    if len(result) != len(nodes):
        return None
    return result

$0.0006 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq

def solve(data):
    nodes = set()
    for job in data:
        nodes.add(job)
        for p in data[job]:
            nodes.add(p)
    indeg = {}
    children = {}
    for n in nodes:
        indeg[n] = 0
        children[n] = []
    for job in data:
        for p in set(data[job]):
            children[p].append(job)
            indeg[job] += 1
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    order = []
    while heap:
        n = heapq.heappop(heap)
        order.append(n)
        for c in children[n]:
            indeg[c] -= 1
            if indeg[c] == 0:
                heapq.heappush(heap, c)
    if len(order) != len(nodes):
        return None
    return order

$0.0005 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import heapq


def solve(data):
    nodes = set()
    prereq_sets = {}
    for job in data:
        nodes.add(job)
        ps = set(data[job])
        prereq_sets[job] = ps
        for p in ps:
            nodes.add(p)
    for n in nodes:
        if n not in prereq_sets:
            prereq_sets[n] = set()
    dependents = {}
    for n in nodes:
        dependents[n] = []
    indeg = {}
    for job in prereq_sets:
        indeg[job] = len(prereq_sets[job])
        for p in prereq_sets[job]:
            dependents[p].append(job)
    heap = [n for n in nodes if indeg[n] == 0]
    heapq.heapify(heap)
    order = []
    while heap:
        n = heapq.heappop(heap)
        order.append(n)
        for d in dependents[n]:
            indeg[d] -= 1
            if indeg[d] == 0:
                heapq.heappush(heap, d)
    if len(order) != len(nodes):
        return None
    return order

$0.0007 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    need = data["sold"]
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        qty = lot[0]
        unit = lot[1]
        take = qty if qty < need else need
        need = need - take
        left = qty - take
        remaining_units = remaining_units + left
        remaining_value = remaining_value + left * unit
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": need
    }

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    to_sell = data["sold"]
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        qty = lot[0]
        price = lot[1]
        take = min(qty, to_sell)
        to_sell = to_sell - take
        left = qty - take
        remaining_units = remaining_units + left
        remaining_value = remaining_value + left * price
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell
    }

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    lots = data["lots"]
    to_sell = data["sold"]
    remaining_units = 0
    remaining_value = 0
    for lot in lots:
        qty = lot[0]
        price = lot[1]
        take = min(qty, to_sell)
        to_sell = to_sell - take
        left = qty - take
        remaining_units = remaining_units + left
        remaining_value = remaining_value + left * price
    return {
        "remaining_units": remaining_units,
        "remaining_value_cents": remaining_value,
        "unfilled_units": to_sell
    }

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items = sorted(items)
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1][1] = e
        else:
            result.append([s, e])
    return [[a, b] for a, b in result]

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items = sorted(items)
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1] = [result[-1][0], e]
        else:
            result.append([s, e])
    return result

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    items = []
    for iv in data:
        s = iv[0]
        e = iv[1]
        if s < e:
            items.append((s, e))
    items = sorted(items)
    result = []
    for s, e in items:
        if result and s <= result[-1][1]:
            if e > result[-1][1]:
                result[-1] = [result[-1][0], e]
        else:
            result.append([s, e])
    return result

$0.0001 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math


def solve(data):
    values = data["values"]
    p = data["p"]
    n = len(values)
    if n == 0:
        return None
    rank = math.ceil(p * n / 100)
    if rank < 1:
        rank = 1
    if rank > n:
        rank = n
    ordered = sorted(values)
    return ordered[rank - 1]

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    import math
    values = data["values"]
    p = data["p"]
    n = len(values)
    if n == 0:
        return None
    x = round(p * n / 100, 12)
    rank = math.ceil(x)
    if rank < 1:
        rank = 1
    if rank > n:
        rank = n
    s = sorted(values)
    return s[rank - 1]

$0.0006 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import math


def solve(data):
    values = data["values"]
    p = data["p"]
    n = len(values)
    if n == 0:
        return None
    q = p * n / 100
    r = round(q)
    if abs(q - r) < 1e-9:
        c = r
    else:
        c = math.ceil(q)
    rank = max(1, int(c))
    rank = min(rank, n)
    ordered = sorted(values)
    return ordered[rank - 1]

$0.0005 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

from collections import deque, defaultdict

def solve(data):
    limit = data["limit"]
    window = data["window"]
    queues = defaultdict(deque)
    result = []
    for ev in data["events"]:
        user = ev["user"]
        t = ev["time"]
        q = queues[user]
        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

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import collections


def solve(data):
    limit = data["limit"]
    window = data["window"]
    queues = collections.defaultdict(collections.deque)
    result = []
    for ev in data["events"]:
        user = ev["user"]
        t = ev["time"]
        q = queues[user]
        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

$0.0005 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

from collections import deque, defaultdict

def solve(data):
    limit = data["limit"]
    window = data["window"]
    queues = defaultdict(deque)
    result = []
    for ev in data["events"]:
        user = ev["user"]
        t = ev["time"]
        q = queues[user]
        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

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    totals = {}
    for inv in data["invoices"]:
        k = inv["id"]
        if k in totals:
            totals[k] = totals[k] + inv["cents"]
        else:
            totals[k] = inv["cents"]
    for p in data["payments"]:
        k = p["id"]
        if k in totals:
            totals[k] = totals[k] - p["cents"]
        else:
            totals[k] = 0 - p["cents"]
    result = {}
    for k in sorted(totals):
        v = totals[k]
        if v != 0:
            result[k] = v
    return result

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    totals = dict()
    for inv in data["invoices"]:
        k = inv["id"]
        totals[k] = totals.get(k, 0) + inv["cents"]
    for pay in data["payments"]:
        k = pay["id"]
        totals[k] = totals.get(k, 0) - pay["cents"]
    result = dict()
    for k in sorted(totals):
        v = totals[k]
        if v != 0:
            result[k] = v
    return result

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def strip_secrets(value):
    if isinstance(value, dict):
        result = {}
        for key in value:
            if isinstance(key, str) and key.lower() in ("password", "token", "secret"):
                continue
            result[key] = strip_secrets(value[key])
        return result
    if isinstance(value, list):
        return [strip_secrets(item) for item in value]
    return value

def solve(data):
    return strip_secrets(data)

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def clean_value(value):
    if isinstance(value, dict):
        result = {}
        for key in value:
            if isinstance(key, str) and key.lower() in ("password", "token", "secret"):
                continue
            result[key] = clean_value(value[key])
        return result
    if isinstance(value, list):
        return [clean_value(item) for item in value]
    return value


def solve(data):
    return clean_value(data)

$0.0005 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

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

$0.0004 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    events = data["events"]
    queries = data["query_days"]
    totals = {}
    for pair in events:
        d = pair[0]
        c = pair[1]
        if d in totals:
            totals[d] = totals[d] + c
        else:
            totals[d] = c
    result = []
    for q in queries:
        s = 0
        for d in range(q - 6, q + 1):
            if d in totals:
                s = s + totals[d]
        result.append(s)
    return result

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    events = data["events"]
    queries = data["query_days"]
    totals = {}
    for pair in events:
        day = pair[0]
        totals[day] = totals.get(day, 0) + pair[1]
    result = []
    for q in queries:
        s = 0
        for d in range(q - 6, q + 1):
            s += totals.get(d, 0)
        result.append(s)
    return result

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

def solve(data):
    events = data["events"]
    result = []
    for q in data["query_days"]:
        total = 0
        for pair in events:
            d = pair[0]
            c = pair[1]
            if q - 6 <= d <= q:
                total += c
        result.append(total)
    return result

$0.0003 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata


def solve(data):
    s = unicodedata.normalize("NFKD", data)
    out = []
    for ch in s:
        if unicodedata.category(ch)[0] == "M":
            continue
        for c in ch.lower():
            if ("a" <= c <= "z") or ("0" <= c <= "9"):
                out.append(c)
            elif out and out[-1] != "-":
                out.append("-")
    while out and out[-1] == "-":
        out.pop()
    return "".join(out)

$0.0007 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata


def solve(data):
    s = unicodedata.normalize('NFKD', data)
    parts = []
    pending = False
    for ch in s:
        if unicodedata.category(ch)[0] == 'M':
            continue
        for c in ch.lower():
            if ('a' <= c <= 'z') or ('0' <= c <= '9'):
                if pending and parts:
                    parts.append('-')
                pending = False
                parts.append(c)
            else:
                pending = True
    return ''.join(parts)

$0.0007 estimated; billed reconciliation remains separate.

Claude direct API, Standard global · medium reasoning

import unicodedata

def solve(data):
    s = unicodedata.normalize("NFKD", data)
    kept = []
    for ch in s:
        if unicodedata.combining(ch) != 0:
            continue
        kept.append(ch)
    t = "".join(kept).lower()
    out = []
    prev_hyphen = False
    for ch in t:
        if ("a" <= ch <= "z") or ("0" <= ch <= "9"):
            out.append(ch)
            prev_hyphen = False
        else:
            if not prev_hyphen:
                out.append("-")
            prev_hyphen = True
    res = "".join(out)
    return res.strip("-")

$0.0006 estimated; billed reconciliation remains separate.