DracoBench Report: moonshotai/kimi-k2.6

moonshotai/kimi-k2.6
Pass rate
96.0%
Cases
96/100
Avg latency
25410 ms
Total time
59m 50s
Total cost
$0.459479
Prompt tokens
9995
Completion tokens
119335
Reasoning tokens
122345
Errors
0

By Suite

SuiteCasesPassedPass rateAvg latencyCost
chinese_writing44100.0%21914 ms$0.012223
coding282692.9%50351 ms$0.283861
debugging191789.5%28881 ms$0.081713
instruction_following66100.0%6871 ms$0.008181
rag_long_context1818100.0%12501 ms$0.031312
reasoning2525100.0%9142 ms$0.042190

Failure Examples

challenge-coding-004

Suite: coding
Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(capacity: int, ops: list[str]) -> list[int],模拟 LRU cache。ops 包含 "put key value" 和 "get key"。get 返回 value,不存在返回 -1。put 已存在 key 要更新并变成最近使用。容量为 0 时所有 get 都返回 -1。
Standard Answer / Scoring Expectation
Reference tests:
ops = ['put a 1', 'put b 2', 'get a', 'put c 3', 'get b', 'get a', 'get c']
assert solution.solve(2, ops) == [1, -1, 1, 3]
assert solution.solve(0, ['put a 1', 'get a']) == [-1]
assert solution.solve(1, ['put a 1', 'put a 2', 'get a']) == [2]
Mistake Analysis
Failure type: runtime_type_assumption
题目里的 cache key 是字符串,例如 `a`、`b`、`c`,但模型把 key 强行写成 `int(parts[1])`。测试一遇到 `put a 1` 就在解析 `a` 时抛出 ValueError。根因是模型擅自补了“key 是整数”的类型假设。
Scorer Details
{
  "returncode": 1,
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-hpnzj2ez/test_solution.py\", line 4, in <module>\n    assert solution.solve(2, ops) == [1, -1, 1, 3]\n           ^^^^^^^^^^^^^^^^^^^^^^\n  File \"/private/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-hpnzj2ez/solution.py\", line 18, in solve\n    key = int(parts[1])\n          ^^^^^^^^^^^^^\nValueError: invalid literal for int() with base 10: 'a'\n"
}
Output
```python
from collections import OrderedDict

def solve(capacity: int, ops: list[str]) -> list[int]:
    cache = OrderedDict()
    res = []
    for op in ops:
        parts = op.split()
        if parts[0] == 'get':
            key = int(parts[1])
            if capacity == 0 or key not in cache:
                res.append(-1)
            else:
                res.append(cache[key])
                cache.move_to_end(key)
        else:
            if capacity == 0:
                continue
            key = int(parts[1])
            value = int(parts[2])
            if key in cache:
                cache[key] = value
                cache.move_to_end(key)
            else:
                if len(cache) >= capacity:
                    cache.popitem(last=False)
                cache[key] = value
    return res
```

challenge-debugging-005

Suite: debugging
Finish: stop
Prompt
下面缓存装饰器会把不同参数的调用混在一起。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 key 赋值行>。

```python
cache = {}
def memo(fn):
    def wrapper(*args, **kwargs):
        key = fn.__name__
        if key not in cache:
            cache[key] = fn(*args, **kwargs)
        return cache[key]
    return wrapper
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*key\s*=\s*\(fn\.__name__,\s*args,\s*(?:tuple\(sorted\(kwargs\.items\(\)\)\)|frozenset\(kwargs\.items\(\)\))\)\s*`?
Mistake Analysis
Failure type: regex_miss
模型正确知道缓存 key 必须包含调用参数,也把 kwargs 排序后放进 key 里;失败点在最终 key 形式。当前标准答案期望 `key = (fn.__name__, args, tuple(sorted(kwargs.items())))` 或等价 frozenset 写法,模型输出的是 `key = (fn, args, tuple(sorted(kwargs.items())))`。用函数对象 `fn` 在很多场景下也能区分函数,但没有命中本题的固定 regex。根因更偏评分模式未覆盖这个等价实现,而不是模型完全没修好缓存参数混淆。
Scorer Details
{
  "pattern": "FIX:\\s*`?\\s*key\\s*=\\s*\\(fn\\.__name__,\\s*args,\\s*(?:tuple\\(sorted\\(kwargs\\.items\\(\\)\\)\\)|frozenset\\(kwargs\\.items\\(\\)\\))\\)\\s*`?"
}
Output
Bug:`key` 只使用了函数名,没有包含调用时的参数 `args` 和 `kwargs`,导致不同参数的调用都命中同一个缓存条目。

最小修复:将参数也编码进 `key`,例如用元组 `(fn.__name__, args, tuple(kwargs.items()))` 作为唯一标识。

FIX: key = (fn.__name__, args, tuple(kwargs.items()))

challenge-debugging-008

Suite: debugging
Finish: stop
Prompt
下面代码期望 finally 后仍保留 try 中返回值,但实际总是返回 None。请指出 bug,并给出最小修复。最后单独一行写 FIX: <要删除或替换的 finally 行说明>。

```python
def read_value():
    try:
        return 42
    finally:
        return None
```
Standard Answer / Scoring Expectation
Accepted answers:
- 删除 finally 中的 return None
- 去掉 finally 的 return None
- 不要在 finally 里 return None
- remove return None
- 去掉 finally 中的 return None
- 删除或替换 finally 中的 return None
- 去掉 finally 中的 `return None`
- 删除或替换 finally 中的 `return None`
- 删除 finally 块中的 `return None`
- 删除 finally 块中的 return None
- 删除 finally 中的 `return None`
- 删除 `finally` 块中的 `return None`
- 删除 `finally` 中的 `return None`
- 删除 `finally: return None`
- 将 `finally:` 中的 `return None` 删除
- finally 中的 return None 删除
- finally: 中的 return None 删除
- 删除 finally 块中的 'return None'
- 删除 finally 子句中的 `return None`
- 删除 finally 子句中的 return None
- delete the line `return None` inside the finally block
- delete the line return None inside the finally block
- finally 块不应包含 return 语句
- finally 块不应包含 return
- finally 不应包含 return
Mistake Analysis
Failure type: missing_accepted_answer
模型正确指出 `finally` 里的 `return None` 会覆盖 `try` 中的 `return 42`,修复方向也是删除这个 return。失败点在最后的 `FIX:` 行只写了 `删除 return None`,没有明确说“删除 finally 中的 return None”。当前 contains_any scorer 只接受包含 finally 位置的固定表达;模型正文里虽解释了 finally,但最终短答案没有命中可接受短语。根因是最终修复说明过短/评分短语覆盖不足,而不是调试判断错误。
Scorer Details
{
  "matched": []
}
Output
Bug:`finally` 块中的 `return` 会覆盖 `try` 块里尚未真正返回的值,因此函数总是返回 `None`。

最小修复:去掉 `finally` 中的 `return`,改为 `pass`(或删除整个 `finally` 块)。

```python
def read_value():
    try:
        return 42
    finally:
        pass
```

FIX: 将 `finally` 块中的 `return None` 删除或替换为 `pass`

challenge-coding-025

Suite: coding
Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(grid: list[str]) -> int。grid 中 S 是起点,E 是终点,# 是墙,. 可走。每步上下左右移动一格,返回从 S 到 E 的最短步数;不可达返回 -1。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['S..','##.','..E']) == 4
assert solution.solve(['S#','##','E.']) == -1
assert solution.solve(['SE']) == 1
Mistake Analysis
Failure type: code_execution_failure
当前失败类型是 `code_execution_failure`,scorer 是 `code_python_tests`。可见判分信号为 `{"returncode": 1, "stderr": "Traceback (most recent call last):\n File \"/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000g…`,模型输出片段为 ````python\nfrom collections import deque\n\ndef solve(grid: list[str]) -> int:\n if not grid or not grid[0]:\n …`。报告模板还没有这个组合的专项诊断,因此这里先给出可复查的失败信号;后续应为该 case 补一条 case-aware root cause。
Scorer Details
{
  "returncode": 1,
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-288wiwar/test_solution.py\", line 3, in <module>\n    assert solution.solve(['S..','##.','..E']) == 4\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/private/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-288wiwar/solution.py\", line 22, in solve\n    for x, y in q:\nRuntimeError: deque mutated during iteration\n"
}
Output
```python
from collections import deque

def solve(grid: list[str]) -> int:
    if not grid or not grid[0]:
        return -1
    n = len(grid)
    m = len(grid[0])
    sx = sy = ex = ey = -1
    for i in range(n):
        for j in range(m):
            c = grid[i][j]
            if c == 'S':
                sx, sy = i, j
            elif c == 'E':
                ex, ey = i, j
    if sx == -1 or ex == -1:
        return -1
    dist = [[-1] * m for _ in range(n)]
    q = deque()
    q.append((sx, sy))
    dist[sx][sy] = 0
    for x, y in q:
        if x == ex and y == ey:
            return dist[x][y]
        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nx, ny = x + dx, y + dy
            if 0 <= nx < n and 0 <= ny < m and dist[nx][ny] == -1 and grid[nx][ny] != '#':
                dist[nx][ny] = dist[x][y] + 1
                q.append((nx, ny))
    return -1
```

All Questions & Answers

challenge-coding-001 PASS
Suite: coding · Latency: 32085 ms · Cost: $0.003087 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(lines: list[str]) -> dict。lines 是简化 INI:空行和以 # 开头的行忽略;[section] 开始新 section;key=value 写入当前 section;key/value 两侧空白要去掉;同一 section 内重复 key 后者覆盖前者。返回嵌套 dict。
Standard Answer / Scoring Expectation
Reference tests:
lines = ['# comment', '[db]', ' host = localhost ', 'port=5432', '', '[feature]', 'enabled=true', 'enabled = false']
assert solution.solve(lines) == {'db': {'host': 'localhost', 'port': '5432'}, 'feature': {'enabled': 'false'}}
assert solution.solve(['[x]', 'a=1', 'a=2', '[y]', 'b = hi']) == {'x': {'a': '2'}, 'y': {'b': 'hi'}}
Output
```python
def solve(lines: list[str]) -> dict:
    result = {}
    cur = None
    for line in lines:
        s = line.strip()
        if not s or s.startswith('#'):
            continue
        if s.startswith('[') and s.endswith(']'):
            cur = s[1:-1].strip()
            result.setdefault(cur, {})
        elif '=' in s:
            k, v = s.split('=', 1)
            if cur is not None:
                result[cur][k.strip()] = v.strip()
    return result
```
challenge-coding-002 PASS
Suite: coding · Latency: 59236 ms · Cost: $0.008494 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(events: list[str]) -> int。事件格式:"<id> credit <amount>" 增加余额,"<id> debit <amount>" 减少余额,"rev <id>" 撤销此前尚未撤销过的同 id 事件。重复交易 id 只保留第一次,未知撤销忽略。返回最终余额。
Standard Answer / Scoring Expectation
Reference tests:
events = ['a credit 100', 'b debit 40', 'a credit 999', 'rev b', 'c debit 10']
assert solution.solve(events) == 90
events = ['x debit 5', 'rev y', 'rev x', 'rev x', 'z credit 7']
assert solution.solve(events) == 7
Output
```python
def solve(events: list[str]) -> int:
    seen = set()
    active = {}
    balance = 0
    for event in events:
        parts = event.split()
        if parts[0] == "rev":
            tid = parts[1]
            if tid in active:
                balance -= active[tid]
                del active[tid]
        else:
            tid = parts[0]
            if tid in seen:
                continue
            seen.add(tid)
            typ = parts[1]
            amt = int(parts[2])
            delta = amt if typ == "credit" else -amt
            active[tid] = delta
            balance += delta
    return balance
```
challenge-coding-003 PASS
Suite: coding · Latency: 56991 ms · Cost: $0.011605 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(deps: dict[str, list[str]]) -> list[list[str]]。deps 表示 task -> prerequisites。返回可并行执行的拓扑层,每层任务按字典序排序;如果存在环,返回空列表。所有只出现在 prerequisites 中的任务也要包含。
Standard Answer / Scoring Expectation
Reference tests:
deps = {'build': ['lint', 'test'], 'test': ['install'], 'lint': ['install']}
assert solution.solve(deps) == [['install'], ['lint', 'test'], ['build']]
assert solution.solve({'a': ['b'], 'b': ['a']}) == []
assert solution.solve({'deploy': ['build'], 'build': []}) == [['build'], ['deploy']]
Output
```python
def solve(deps: dict[str, list[str]]) -> list[list[str]]:
    nodes = set(deps)
    for pres in deps.values():
        nodes.update(pres)
    adj = {node: [] for node in nodes}
    indeg = {node: 0 for node in nodes}
    for task, pres in deps.items():
        for p in pres:
            adj[p].append(task)
            indeg[task] += 1
    curr = sorted([node for node in nodes if indeg[node] == 0])
    res = []
    visited = 0
    while curr:
        res.append(curr)
        visited += len(curr)
        nxt = []
        for node in curr:
            for nb in adj[node]:
                indeg[nb] -= 1
                if indeg[nb] == 0:
                    nxt.append(nb)
        curr = sorted(nxt)
    return res if visited == len(nodes) else []
```
challenge-coding-004 FAIL
Suite: coding · Latency: 27330 ms · Cost: $0.003958 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(capacity: int, ops: list[str]) -> list[int],模拟 LRU cache。ops 包含 "put key value" 和 "get key"。get 返回 value,不存在返回 -1。put 已存在 key 要更新并变成最近使用。容量为 0 时所有 get 都返回 -1。
Standard Answer / Scoring Expectation
Reference tests:
ops = ['put a 1', 'put b 2', 'get a', 'put c 3', 'get b', 'get a', 'get c']
assert solution.solve(2, ops) == [1, -1, 1, 3]
assert solution.solve(0, ['put a 1', 'get a']) == [-1]
assert solution.solve(1, ['put a 1', 'put a 2', 'get a']) == [2]
Mistake Analysis
Failure type: runtime_type_assumption
题目里的 cache key 是字符串,例如 `a`、`b`、`c`,但模型把 key 强行写成 `int(parts[1])`。测试一遇到 `put a 1` 就在解析 `a` 时抛出 ValueError。根因是模型擅自补了“key 是整数”的类型假设。
Output
```python
from collections import OrderedDict

def solve(capacity: int, ops: list[str]) -> list[int]:
    cache = OrderedDict()
    res = []
    for op in ops:
        parts = op.split()
        if parts[0] == 'get':
            key = int(parts[1])
            if capacity == 0 or key not in cache:
                res.append(-1)
            else:
                res.append(cache[key])
                cache.move_to_end(key)
        else:
            if capacity == 0:
                continue
            key = int(parts[1])
            value = int(parts[2])
            if key in cache:
                cache[key] = value
                cache.move_to_end(key)
            else:
                if len(cache) >= capacity:
                    cache.popitem(last=False)
                cache[key] = value
    return res
```
challenge-coding-005 PASS
Suite: coding · Latency: 60955 ms · Cost: $0.007923 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(base: dict, patch: dict) -> dict,执行 JSON Merge Patch:patch 中值为 None 表示删除该 key;两个值都是 dict 时递归合并;其他值覆盖。不能修改输入对象。
Standard Answer / Scoring Expectation
Reference tests:
base = {'a': 1, 'b': {'x': 1, 'y': 2}, 'c': 3}
patch = {'b': {'y': None, 'z': 4}, 'c': None}
assert solution.solve(base, patch) == {'a': 1, 'b': {'x': 1, 'z': 4}}
assert base == {'a': 1, 'b': {'x': 1, 'y': 2}, 'c': 3}
assert solution.solve({'a': {'b': 1}}, {'a': 5}) == {'a': 5}
Output
```python
def solve(base: dict, patch: dict) -> dict:
    result = dict(base)
    for k, v in patch.items():
        if v is None:
            result.pop(k, None)
        elif isinstance(v, dict) and isinstance(result.get(k), dict):
            result[k] = solve(result[k], v)
        else:
            result[k] = v
    return result
```
challenge-coding-006 PASS
Suite: coding · Latency: 55550 ms · Cost: $0.006263 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(text: str) -> int,把时长字符串转换成毫秒。支持整数单位 d、h、m、s、ms,可有空格,单位可重复,顺序任意。例如 "1h 30m 500ms"。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('1h 30m 500ms') == 5400500
assert solution.solve('2d 1h 2s') == 176402000
assert solution.solve('100ms 2s 3ms') == 2103
Output
```python
import re

def solve(text: str) -> int:
    units = {"d": 86400000, "h": 3600000, "m": 60000, "s": 1000, "ms": 1}
    return sum(int(num) * units[unit] for num, unit in re.findall(r"(\d+)\s*(ms|[dhms])", text))
```
challenge-coding-007 PASS
Suite: coding · Latency: 118324 ms · Cost: $0.012597 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(s: str) -> bool,检查括号 ()[]{} 是否配对。单引号或双引号内部的括号忽略;反斜杠会转义引号。输入字符串可以包含普通字符。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('{a:[(1)]}') is True
assert solution.solve("{'x': '(]'}") is True
assert solution.solve("['unterminated]") is False
assert solution.solve('([)]') is False
assert solution.solve("\"paren \\\" ) still quoted\"") is True
Output
def solve(s: str) -> bool:
    stack = []
    in_str = None
    i = 0
    n = len(s)
    match = {')': '(', ']': '[', '}': '{'}
    opens = set(match.values())
    while i < n:
        c = s[i]
        if c == '\\':
            i += 2
            continue
        if in_str is None:
            if c == '"' or c == "'":
                in_str = c
            elif c in opens:
                stack.append(c)
            elif c in match:
                if not stack or stack[-1] != match[c]:
                    return False
                stack.pop()
        else:
            if c == in_str:
                in_str = None
        i += 1
    return not stack and in_str is None
challenge-coding-008 PASS
Suite: coding · Latency: 49916 ms · Cost: $0.004169 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(rows: list[dict]) -> list[dict]。每行有 user、ts、value。对每个 user 保留 ts 最大的一行;若 ts 相同,保留在输入中更靠后的行。输出按 user 字典序排序。
Standard Answer / Scoring Expectation
Reference tests:
rows = [{'user':'b','ts':1,'value':'old'}, {'user':'a','ts':2,'value':'x'}, {'user':'b','ts':3,'value':'new'}]
assert solution.solve(rows) == [{'user':'a','ts':2,'value':'x'}, {'user':'b','ts':3,'value':'new'}]
rows = [{'user':'a','ts':1,'value':'first'}, {'user':'a','ts':1,'value':'second'}]
assert solution.solve(rows) == [{'user':'a','ts':1,'value':'second'}]
Output
```python
def solve(rows: list[dict]) -> list[dict]:
    best = {}
    for row in rows:
        user = row["user"]
        ts = row["ts"]
        if user not in best or ts >= best[user]["ts"]:
            best[user] = row
    return [best[u] for u in sorted(best)]
```
challenge-debugging-001 PASS
Suite: debugging · Latency: 52143 ms · Cost: $0.008826 · Finish: stop
Prompt
下面代码在 total 之后再次读取数据会变成空列表。请指出根因,并给出最小修复。最后单独一行写 FIX: <修复后的第一行函数定义>。

```python
def summarize(items=iter([1, 2, 3])):
    return sum(items)
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*def\s+summarize\(items=None\)\s*:
Output
根因:Python 默认参数在函数定义时仅求值一次,且该对象在所有调用间共享。`iter([1, 2, 3])` 创建的是一次性迭代器,首次 `sum()` 后即被耗尽,后续调用复用的是同一个已耗尽的迭代器,因此再次读取为空。

最小修复:将默认值改为 `None`,在函数体内重新创建迭代器:

```python
def summarize(items=None):
    if items is None:
        items = iter([1, 2, 3])
    return sum(items)
```

FIX: def summarize(items=None):
challenge-debugging-002 PASS
Suite: debugging · Latency: 24807 ms · Cost: $0.004400 · Finish: stop
Prompt
下面代码期望统计每个用户的事件数,但所有用户计数会互相影响。请指出根因,并给出最小修复。最后单独一行写 FIX: <修复后的 defaultdict 初始化行>。

```python
from collections import defaultdict
shared = {'seen': []}
counts = defaultdict(lambda: shared)

def add(user, event):
    counts[user]['seen'].append(event)
    return counts[user]
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*counts\s*=\s*defaultdict\(lambda\s*:\s*\{'seen'\s*:\s*\[\]\}\)\s*`?
Output
根因:`defaultdict(lambda: shared)` 的工厂函数始终返回**同一个**字典对象 `shared`,其内部的 `[]` 也是同一个列表;因此所有用户共享同一份 `seen` 列表,追加事件时互相影响。

最小修复:将工厂函数改为每次生成新的 `{'seen': []}`,使每个用户拥有独立的字典和列表。

FIX: counts = defaultdict(lambda: {'seen': []})
challenge-debugging-003 PASS
Suite: debugging · Latency: 102399 ms · Cost: $0.003835 · Finish: stop
Prompt
下面分页代码会漏掉最后不足 page_size 的一页。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 range 行>。

```python
def pages(items, page_size):
    out = []
    for start in range(0, len(items) - page_size, page_size):
        out.append(items[start:start + page_size])
    return out
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*for\s+start\s+in\s+range\(0,\s*len\(items\),\s*page_size\)\s*:
Output
`range` 的结束值错误地写成了 `len(items) - page_size`,导致当 `len(items)` 不是 `page_size` 的整数倍时,最后一页的起始索引不会被遍历到,从而漏掉剩余元素。  
只需将结束值改为 `len(items)` 即可,因为切片 `items[start:start+page_size]` 在越界时安全,且 `range` 的 stop 是排他的,不会多出一页。

FIX: for start in range(0, len(items), page_size):
challenge-debugging-004 PASS
Suite: debugging · Latency: 12056 ms · Cost: $0.001014 · Finish: stop
Prompt
下面代码期望把数字字符串按数值排序,但结果是字典序。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def order(ids):
    return sorted(ids)
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*return\s+sorted\(ids,\s*key\s*=\s*int\)\s*`?
Output
Bug:`sorted` 默认对字符串进行字典序比较,而非数值比较(例如 `"10"` 会被排在 `"2"` 前面)。

最小修复:给 `sorted` 传入 `key=int`,让排序依据转换为整数数值,同时返回原字符串。

FIX: return sorted(ids, key=int)
challenge-debugging-005 FAIL
Suite: debugging · Latency: 27864 ms · Cost: $0.003271 · Finish: stop
Prompt
下面缓存装饰器会把不同参数的调用混在一起。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 key 赋值行>。

```python
cache = {}
def memo(fn):
    def wrapper(*args, **kwargs):
        key = fn.__name__
        if key not in cache:
            cache[key] = fn(*args, **kwargs)
        return cache[key]
    return wrapper
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*key\s*=\s*\(fn\.__name__,\s*args,\s*(?:tuple\(sorted\(kwargs\.items\(\)\)\)|frozenset\(kwargs\.items\(\)\))\)\s*`?
Mistake Analysis
Failure type: regex_miss
模型正确知道缓存 key 必须包含调用参数,也把 kwargs 排序后放进 key 里;失败点在最终 key 形式。当前标准答案期望 `key = (fn.__name__, args, tuple(sorted(kwargs.items())))` 或等价 frozenset 写法,模型输出的是 `key = (fn, args, tuple(sorted(kwargs.items())))`。用函数对象 `fn` 在很多场景下也能区分函数,但没有命中本题的固定 regex。根因更偏评分模式未覆盖这个等价实现,而不是模型完全没修好缓存参数混淆。
Output
Bug:`key` 只使用了函数名,没有包含调用时的参数 `args` 和 `kwargs`,导致不同参数的调用都命中同一个缓存条目。

最小修复:将参数也编码进 `key`,例如用元组 `(fn.__name__, args, tuple(kwargs.items()))` 作为唯一标识。

FIX: key = (fn.__name__, args, tuple(kwargs.items()))
challenge-debugging-006 PASS
Suite: debugging · Latency: 9647 ms · Cost: $0.001292 · Finish: stop
Prompt
下面代码期望浅拷贝列表后独立追加,但原列表也被修改。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 copy 行>。

```python
def append_copy(items, value):
    copied = items
    copied.append(value)
    return copied
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*copied\s*=\s*(?:items\.copy\(\)|items\[:\]|list\(items\))\s*`?
Output
`copied = items` 只是让新变量引用同一个列表对象,并非拷贝。因此 `copied.append` 直接修改了原列表。

最小修复:创建浅拷贝后再追加。

FIX: copied = items.copy()
challenge-debugging-007 PASS
Suite: debugging · Latency: 12531 ms · Cost: $0.001488 · Finish: stop
Prompt
下面代码期望解析 JSON 字符串,但传入已经是 dict 时会报错。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 data 赋值行>。

```python
import json

def load(payload):
    data = json.loads(payload)
    return data['id']
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*data\s*=\s*(payload\s+if\s+isinstance\(payload,\s*dict\)\s+else\s+json\.loads\(payload\)|json\.loads\(payload\)\s+if\s+isinstance\(payload,\s*\(str,\s*bytes,\s*bytearray\)\)\s+else\s+payload|json\.loads\(payload\)\s+if\s+isinstance\(payload,\s*str\)\s+else\s+payload)\s*`?
Output
Bug:`json.loads` 只接受字符串/字节类输入,若 `payload` 已是 `dict` 会抛出 `TypeError`。

最小修复:先判断是否为 `dict`,是则直接使用,否则再解析。

```python
import json

def load(payload):
    data = payload if isinstance(payload, dict) else json.loads(payload)
    return data['id']
```

FIX: `data = payload if isinstance(payload, dict) else json.loads(payload)`
challenge-debugging-008 FAIL
Suite: debugging · Latency: 14856 ms · Cost: $0.003351 · Finish: stop
Prompt
下面代码期望 finally 后仍保留 try 中返回值,但实际总是返回 None。请指出 bug,并给出最小修复。最后单独一行写 FIX: <要删除或替换的 finally 行说明>。

```python
def read_value():
    try:
        return 42
    finally:
        return None
```
Standard Answer / Scoring Expectation
Accepted answers:
- 删除 finally 中的 return None
- 去掉 finally 的 return None
- 不要在 finally 里 return None
- remove return None
- 去掉 finally 中的 return None
- 删除或替换 finally 中的 return None
- 去掉 finally 中的 `return None`
- 删除或替换 finally 中的 `return None`
- 删除 finally 块中的 `return None`
- 删除 finally 块中的 return None
- 删除 finally 中的 `return None`
- 删除 `finally` 块中的 `return None`
- 删除 `finally` 中的 `return None`
- 删除 `finally: return None`
- 将 `finally:` 中的 `return None` 删除
- finally 中的 return None 删除
- finally: 中的 return None 删除
- 删除 finally 块中的 'return None'
- 删除 finally 子句中的 `return None`
- 删除 finally 子句中的 return None
- delete the line `return None` inside the finally block
- delete the line return None inside the finally block
- finally 块不应包含 return 语句
- finally 块不应包含 return
- finally 不应包含 return
Mistake Analysis
Failure type: missing_accepted_answer
模型正确指出 `finally` 里的 `return None` 会覆盖 `try` 中的 `return 42`,修复方向也是删除这个 return。失败点在最后的 `FIX:` 行只写了 `删除 return None`,没有明确说“删除 finally 中的 return None”。当前 contains_any scorer 只接受包含 finally 位置的固定表达;模型正文里虽解释了 finally,但最终短答案没有命中可接受短语。根因是最终修复说明过短/评分短语覆盖不足,而不是调试判断错误。
Output
Bug:`finally` 块中的 `return` 会覆盖 `try` 块里尚未真正返回的值,因此函数总是返回 `None`。

最小修复:去掉 `finally` 中的 `return`,改为 `pass`(或删除整个 `finally` 块)。

```python
def read_value():
    try:
        return 42
    finally:
        pass
```

FIX: 将 `finally` 块中的 `return None` 删除或替换为 `pass`
challenge-reasoning-001 PASS
Suite: reasoning · Latency: 5019 ms · Cost: $0.000653 · Finish: stop
Prompt
只回答最终数字:有 A、B、C、D 四个服务。A 每分钟处理 6 个请求,B 比 A 少 2 个,C 是 B 的 2 倍,D 是 A 和 C 的平均值。四个服务 5 分钟一共处理多少请求?
Standard Answer / Scoring Expectation
Answer: 125
Output
125
challenge-reasoning-002 PASS
Suite: reasoning · Latency: 23221 ms · Cost: $0.006690 · Finish: stop
Prompt
只回答一个字母:五个任务 A、B、C、D、E 排队。A 必须在 B 前,B 必须在 C 前;D 不能在两端;E 必须紧挨在 C 后面。在所有满足条件的队列中,按字典序最小的队列第三个任务是谁?
Standard Answer / Scoring Expectation
Answer: D
Output
D
challenge-reasoning-003 PASS
Suite: reasoning · Latency: 3688 ms · Cost: $0.001333 · Finish: stop
Prompt
只回答最终数字:一个 4 位二进制数从 1011 开始,先左移一位并只保留低 4 位,再与 0110 做异或,最后转成十进制。结果是多少?
Standard Answer / Scoring Expectation
Answer: 0
Output
0
challenge-reasoning-004 PASS
Suite: reasoning · Latency: 7070 ms · Cost: $0.000603 · Finish: stop
Prompt
只回答最终数字:一个集合最初为 {1,2,3,4,5}。依次执行:删除所有偶数;加入 6 和 7;把每个元素乘以 2;删除大于 10 的元素。最终集合元素之和是多少?
Standard Answer / Scoring Expectation
Answer: 18
Output
18
challenge-reasoning-005 PASS
Suite: reasoning · Latency: 15759 ms · Cost: $0.001484 · Finish: stop
Prompt
只回答“可满足”或“不可满足”:有三个布尔变量 x、y、z。约束为:x 或 y 为真;如果 x 为真则 z 为假;如果 y 为真则 z 为真;x 和 y 不能同时为真。是否存在赋值满足全部约束?
Standard Answer / Scoring Expectation
Answer: 可满足
Output
可满足
challenge-rag-001 PASS
Suite: rag_long_context · Latency: 5874 ms · Cost: $0.003073 · Finish: stop
Prompt
只根据资料回答。

资料 A:DracoBench v0.2 的目标是提高区分度,优先增加 coding、debugging、RAG 和 instruction_following 题。
资料 B:DracoBench v0.2 不会默认使用 LLM-as-judge;开放中文写作题只做少量规则校验和人工抽检。
资料 C:v0.2 的 HTML 报告必须展示通过率、成本、reasoning tokens、失败样例和逐题明细。

问题:v0.2 为什么没有把 LLM-as-judge 作为默认判分?
Standard Answer / Scoring Expectation
Required phrases: 人工抽检
At least one from each group: 默认使用 / 默认判分 / 默认采用 / 作为默认判分
Forbidden phrases: 因为成本太高、因为不支持中文
Length guidance (diagnostic only): min=n/a, max=160
Output
根据提供的资料,**未明确说明** v0.2 不将 LLM-as-judge 作为默认判分的具体原因。资料仅陈述了以下事实:

- 资料 B 指出,DracoBench v0.2 **不会默认使用 LLM-as-judge**;
- 对于开放中文写作题,仅做**少量规则校验和人工抽检**。
challenge-rag-002 PASS
Suite: rag_long_context · Latency: 11548 ms · Cost: $0.002261 · Finish: stop
Prompt
只根据资料回答,不要自行补充。

资料:模型 Alpha 在 30 道 challenge 题中通过 24 道,成本 0.08 美元,平均延迟 9 秒。模型 Beta 通过 22 道,成本 0.02 美元,平均延迟 3 秒。资料没有给出两者在多模态任务上的表现。

问题:如果要写低成本高吞吐摘要服务,资料更支持选择哪个模型?另外,多模态表现能否判断?
Standard Answer / Scoring Expectation
Required phrases: Beta、成本、延迟、判断
Forbidden phrases: Alpha 更适合、多模态更强
Length guidance (diagnostic only): min=n/a, max=180
Output
资料更支持选择 **模型 Beta**。

理由:Beta 成本更低(0.02 美元 vs 0.08 美元),且平均延迟更低(3 秒 vs 9 秒),更符合低成本、高吞吐的需求。

**多模态表现无法判断**,因为资料明确未给出两者在多模态任务上的表现。
challenge-rag-003 PASS
Suite: rag_long_context · Latency: 75999 ms · Cost: $0.008302 · Finish: stop
Prompt
只根据资料回答。

资料:一次评测中,K 模型在 smoke set 上 7/7,通过率 100%;在 hard set 上原始结果 47/50,其中 2 题后来被认定为题面歧义,单独复测通过。另有 1 题因 reasoning tokens 用尽而空输出。

问题:更公平的文字结论应该如何描述 K 模型这次 hard set 表现?
Standard Answer / Scoring Expectation
Required phrases: 题面歧义
At least one from each group: 47/50 / 47 题 / 47题;空输出 / 输出为空 / 未输出
Forbidden phrases: 满分、完全失败
Length guidance (diagnostic only): min=n/a, max=240
Output
在 hard set 的 50 题中,K 模型原始通过 47 题。扣除 2 道因题面歧义而无效的题目(单独复测已通过)后,有效题数为 48 题,通过 47 题,有效通过率约 97.9%;剩余 1 题因 reasoning tokens 耗尽导致空输出,属技术资源限制,不应视为模型能力失败。若将空输出题也排除在能力评估之外,则模型在有效题目中实质全部通过。
challenge-rag-004 PASS
Suite: rag_long_context · Latency: 1679 ms · Cost: $0.001043 · Finish: stop
Prompt
只根据资料回答,不要使用资料外知识。

资料:报告字段包括 pass_rate、avg_latency_ms、total_cost、prompt_tokens、completion_tokens、reasoning_tokens。报告不包含模型训练数据来源,也不包含供应商真实利润率。

问题:根据资料,能否从报告判断供应商利润率?
Standard Answer / Scoring Expectation
Required phrases: 不能、不包含、利润率
Forbidden phrases: 可以判断、训练数据
Length guidance (diagnostic only): min=n/a, max=100
Output
不能。资料明确说明报告“不包含供应商真实利润率”。
challenge-if-001 PASS
Suite: instruction_following · Latency: 2762 ms · Cost: $0.002342 · Finish: stop
Prompt
只输出 JSON 对象,不要 Markdown。字段 status 必须是 "review";字段 scores 必须是对象,包含 coding、debugging、rag 三个整数;字段 note 必须是不超过 12 个汉字的中文字符串。
Standard Answer / Scoring Expectation
Expected JSON schema:
{
  "type": "object",
  "required": [
    "status",
    "scores",
    "note"
  ],
  "additionalProperties": false,
  "properties": {
    "status": {
      "type": "string",
      "const": "review"
    },
    "scores": {
      "type": "object",
      "required": [
        "coding",
        "debugging",
        "rag"
      ],
      "additionalProperties": false,
      "properties": {
        "coding": {
          "type": "integer"
        },
        "debugging": {
          "type": "integer"
        },
        "rag": {
          "type": "integer"
        }
      }
    },
    "note": {
      "type": "string"
    }
  }
}
Output
{"status":"review","scores":{"coding":8,"debugging":7,"rag":9},"note":"建议人工复核"}
challenge-if-002 PASS
Suite: instruction_following · Latency: 4824 ms · Cost: $0.000597 · Finish: stop
Prompt
只输出 4 行,不要解释。第 1 行是 BEGIN,第 4 行是 END。第 2 行必须包含“模型评测”,第 3 行必须包含“HTML报告”。不能出现任何项目符号。
Standard Answer / Scoring Expectation
Expected regex pattern:
^\s*BEGIN\s*\n[^\n]*模型评测[^\n]*\n[^\n]*HTML报告[^\n]*\nEND\s*$
Output
BEGIN
模型评测
HTML报告
END
challenge-if-003 PASS
Suite: instruction_following · Latency: 7849 ms · Cost: $0.001185 · Finish: stop
Prompt
只输出一个中文句子,不能超过 28 个汉字。必须同时包含“难题”和“区分度”,不能包含“最强”“吊打”“遥遥领先”。
Standard Answer / Scoring Expectation
Required phrases: 难题、区分度
Forbidden phrases: 最强、吊打、遥遥领先
Length guidance (diagnostic only): min=n/a, max=28
Output
这份试卷的难题展现了良好的区分度。
challenge-zh-writing-001 PASS
Suite: chinese_writing · Latency: 12315 ms · Cost: $0.002218 · Finish: stop
Prompt
写一段不超过 120 个汉字的公众号结论,主题是“模型在简单题满分不代表真实强”。必须包含“简单题”“真实能力”“失败样例”,不能出现“吊打”。
Standard Answer / Scoring Expectation
Required phrases: 简单题、真实能力、失败样例
Forbidden phrases: 吊打
Length guidance (diagnostic only): min=n/a, max=120
Output
简单题满分只是基础,不等于真实能力。诸多失败样例证明,模型在复杂场景中仍会暴露短板。真正的强弱评估,不能止步于简单题,而要深入考察其边界表现与稳健性。
challenge-zh-writing-002 PASS
Suite: chinese_writing · Latency: 13800 ms · Cost: $0.001904 · Finish: stop
Prompt
把下面口语句改写成专业表达,不超过 80 个汉字:这个模型看起来很猛,但一遇到复杂调试就开始掉链子。必须包含“复杂调试”和“稳定性”,不能包含“猛”“掉链子”。
Standard Answer / Scoring Expectation
Required phrases: 复杂调试、稳定性
Forbidden phrases: 猛、掉链子
Length guidance (diagnostic only): min=n/a, max=80
Output
该模型表面性能优异,但在复杂调试中稳定性不足。
challenge-coding-009 PASS
Suite: coding · Latency: 12501 ms · Cost: $0.002194 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(events: list[dict]) -> dict[str, int]。每个事件包含 user、type、amount;type 为 "add" 或 "remove"。按 user 汇总 add 减 remove 后的库存,结果中去掉库存为 0 的用户,按 key 字典序返回普通 dict。amount 可能是字符串数字。
Standard Answer / Scoring Expectation
Reference tests:
events=[{'user':'b','type':'add','amount':'5'},{'user':'a','type':'add','amount':3},{'user':'b','type':'remove','amount':2},{'user':'a','type':'remove','amount':3}]
assert solution.solve(events) == {'b': 3}
assert solution.solve([]) == {}
assert solution.solve([{'user':'x','type':'remove','amount':'2'}]) == {'x': -2}
Output
```python
def solve(events: list[dict]) -> dict[str, int]:
    d = {}
    for e in events:
        u = e["user"]
        a = int(e["amount"])
        d[u] = d.get(u, 0) + (a if e["type"] == "add" else -a)
    return {k: v for k, v in sorted(d.items()) if v != 0}
```
challenge-coding-010 PASS
Suite: coding · Latency: 67746 ms · Cost: $0.011913 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(expr: str) -> int。expr 只包含非负整数、+、-、空格和括号,计算表达式结果。不要使用 eval。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('1 + 2 - 3') == 0
assert solution.solve('10 - (2 + 3) + 4') == 9
assert solution.solve('(1+(4+5+2)-3)+(6+8)') == 23
Output
```python
def solve(expr: str) -> int:
    stack, num, sign, res = [], 0, 1, 0
    for ch in expr:
        if ch.isdigit():
            num = num * 10 + int(ch)
        elif ch == '+':
            res += sign * num
            num, sign = 0, 1
        elif ch == '-':
            res += sign * num
            num, sign = 0, -1
        elif ch == '(':
            stack.append(res)
            stack.append(sign)
            res, sign = 0, 1
        elif ch == ')':
            res += sign * num
            num = 0
            res *= stack.pop()
            res += stack.pop()
    return res + sign * num
```
challenge-coding-011 PASS
Suite: coding · Latency: 20510 ms · Cost: $0.001882 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(rows: list[str]) -> list[tuple[str, int]]。每行格式为 "name score",空白数量不定;同名保留最高分;输出按分数降序、同分按 name 升序。忽略空行。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['alice 10','bob   12','alice 15','','bob 11']) == [('alice',15),('bob',12)]
assert solution.solve(['x -1','a -1','b 0']) == [('b',0),('a',-1),('x',-1)]
Output
```python
def solve(rows: list[str]) -> list[tuple[str, int]]:
    best = {}
    for row in rows:
        if not row.strip():
            continue
        parts = row.split()
        name, score = parts[0], int(parts[1])
        if name not in best or score > best[name]:
            best[name] = score
    return sorted(best.items(), key=lambda x: (-x[1], x[0]))
```
challenge-coding-012 PASS
Suite: coding · Latency: 9677 ms · Cost: $0.008444 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(pattern: str, text: str) -> bool。pattern 支持 ? 匹配任意单字符,* 匹配任意长度字符串。必须匹配完整 text。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('a*b?d', 'axxxbc d'.replace(' ','')) is True
assert solution.solve('a*c', 'ab') is False
assert solution.solve('*', '') is True
assert solution.solve('file-??.txt', 'file-ab.txt') is True
Output
```python
def solve(pattern: str, text: str) -> bool:
    n = len(text)
    dp = [True] + [False] * n
    for c in pattern:
        new = [False] * (n + 1)
        if c == '*':
            new[0] = dp[0]
            for j in range(n):
                new[j + 1] = new[j] or dp[j + 1]
        else:
            for j in range(n):
                if c == '?' or c == text[j]:
                    new[j + 1] = dp[j]
        dp = new
    return dp[n]
```
challenge-coding-013 PASS
Suite: coding · Latency: 6370 ms · Cost: $0.005025 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(tree: dict) -> list[str]。tree 是嵌套字典,叶子是字符串或数字。返回所有叶子的路径,路径用点连接,按字典序排序。例如 {'a': {'b': 1}} -> ['a.b=1']。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve({'a': {'b': 1, 'c': 'x'}, 'd': 2}) == ['a.b=1','a.c=x','d=2']
assert solution.solve({'z': {'a': {'b': 3}}}) == ['z.a.b=3']
assert solution.solve({}) == []
Output
```python
def solve(tree: dict) -> list[str]:
    res = []
    def dfs(node, path):
        for k in sorted(node.keys()):
            new_path = f"{path}.{k}" if path else k
            if isinstance(node[k], dict):
                dfs(node[k], new_path)
            else:
                res.append(f"{new_path}={node[k]}")
    dfs(tree, "")
    return sorted(res)
```
challenge-coding-014 PASS
Suite: coding · Latency: 128689 ms · Cost: $0.057229 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(nums: list[int]) -> int。返回删除恰好一个元素后,剩余数组的最大连续子数组和。nums 长度至少为 2,可以全为负数。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve([1,-2,0,3]) == 4
assert solution.solve([1,-2,-2,3]) == 3
assert solution.solve([-1,-1,-1]) == -1
assert solution.solve([2,1,-2,3]) == 6
Output
```python
def solve(nums: list[int]) -> int:
    n = len(nums)
    left_end = [0] * n
    left_best = [0] * n
    left_end[0] = nums[0]
    left_best[0] = nums[0]
    for i in range(1, n):
        left_end[i] = max(left_end[i-1] + nums[i], nums[i])
        left_best[i] = max(left_best[i-1], left_end[i])
    
    right_start = [0] * n
    right_best = [0] * n
    right_start[n-1] = nums[n-1]
    right_best[n-1] = nums[n-1]
    for i in range(n-2, -1, -1):
        right_start[i] = max(right_start[i+1] + nums[i], nums[i])
        right_best[i] = max(right_best[i+1], right_start[i])
    
    ans = -float('inf')
    for k in range(n):
        if k > 0:
            ans = max(ans, left_best[k-1])
            if k < n - 1:
                ans = max(ans, left_end[k-1] + right_start[k+1])
        if k < n - 1:
            ans = max(ans, right_best[k+1])
    
    return ans
```
challenge-debugging-009 PASS
Suite: debugging · Latency: 7845 ms · Cost: $0.001720 · Finish: stop
Prompt
下面代码期望把输入按逗号拆分并去掉空白,但会把空字段也保留下来。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def parse(s):
    return [part.strip() for part in s.split(',')]
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*return\s+\[part\.strip\(\)\s+for\s+part\s+in\s+s\.split\('\,'\)\s+if\s+part\.strip\(\)\]\s*`?
Output
Bug:`s.split(',')` 在遇到连续逗号或首尾逗号时会产生空字符串,`strip()` 后仍为 `''`,而列表推导式没有过滤掉这些空串,导致空字段被保留。

最小修复:在列表推导式中加上条件 `if part.strip()`,过滤掉结果为空的元素。

FIX: return [part.strip() for part in s.split(',') if part.strip()]
challenge-debugging-010 PASS
Suite: debugging · Latency: 15756 ms · Cost: $0.015229 · Finish: stop
Prompt
下面代码期望用 UTC 时间戳排序,但字符串排序会错。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 sort 行>。

```python
rows.sort(key=lambda r: r['ts'])
```
Standard Answer / Scoring Expectation
Accepted answers:
- datetime.fromisoformat
- dateutil.parser
- 解析 ts 后排序
- parse ts
- fromisoformat
- int(r['ts'])
- float(r['ts'])
- key=lambda r: int(r['ts'])
- key=lambda r: float(r['ts'])
Output
Bug:`r['ts']` 是字符串,Python 会按字典序(字符编码顺序)比较,导致数值大小关系错乱(例如 `"2"` > `"10"`),无法按实际时间先后排序。

最小修复:将字符串转为数值(或解析为 datetime 对象)后再比较。

FIX: `rows.sort(key=lambda r: float(r['ts']))`
challenge-debugging-011 PASS
Suite: debugging · Latency: 17393 ms · Cost: $0.001689 · Finish: stop
Prompt
下面代码在输入包含 0 时会误判为默认值 10。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 limit 赋值行>。

```python
def query(limit=None):
    limit = limit or 10
    return list(range(limit))
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*(?:limit\s*=\s*10\s+if\s+limit\s+is\s+None\s+else\s+limit|limit\s*=\s*limit\s+if\s+limit\s+is\s+not\s+None\s+else\s+10|if\s+limit\s+is\s+None\s*:\s*limit\s*=\s*10)\s*`?
Output
Bug:`or` 会把所有 falsy 值(包括合法的 `0`)误判为“未传参”,从而覆盖为默认值 10。应仅在值为 `None` 时才使用默认值。

最小修复:将赋值改为显式判断 `None`。

FIX: limit = 10 if limit is None else limit
challenge-debugging-012 PASS
Suite: debugging · Latency: 15655 ms · Cost: $0.002945 · Finish: stop
Prompt
下面代码期望复制嵌套配置后修改副本,但原配置也被修改。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 copied 赋值行>。

```python
def update(config):
    copied = dict(config)
    copied['db']['host'] = 'localhost'
    return copied
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*copied\s*=\s*(?:copy\.deepcopy\(config\)|__import__\(['\"]copy['\"]\)\.deepcopy\(config\))\s*`?
Output
Bug:`dict(config)` 是浅拷贝,`copied['db']` 与原配置中的 `'db'` 字典仍指向同一个对象,因此修改副本的嵌套字段会同时改动原配置。

最小修复:使用 `copy.deepcopy` 对 `config` 进行深拷贝(需 `import copy`)。

FIX: copied = copy.deepcopy(config)
challenge-debugging-013 PASS
Suite: debugging · Latency: 8046 ms · Cost: $0.001909 · Finish: stop
Prompt
下面代码期望找到第一个匹配项,但找不到时会抛 StopIteration。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def find_user(users, name):
    return next(u for u in users if u['name'] == name)
```
Standard Answer / Scoring Expectation
Expected regex pattern:
\*{0,2}FIX\*{0,2}:\*{0,2}\s*`?\s*return\s+next\(\(u\s+for\s+u\s+in\s+users\s+if\s+u\['name'\]\s*==\s*name\),\s*None\)\s*`?
Output
Bug:`next()` 在生成器没有匹配项时会抛出 `StopIteration`。应为其提供第二个参数作为默认值。

最小修复是给 `next()` 添加默认值(如 `None`),并将生成器表达式用括号包裹以正确传入第二个参数。

FIX: return next((u for u in users if u['name'] == name), None)
challenge-debugging-014 PASS
Suite: debugging · Latency: 147960 ms · Cost: $0.016785 · Finish: stop
Prompt
下面代码期望按请求顺序记录日志,但默认参数导致多次调用共用同一个列表。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的函数定义行>。

```python
def log_request(req, logs=[]):
    logs.append(req['id'])
    return logs
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*(?:```(?:python)?\s*)?`?\s*def\s+log_request\(req,\s*logs=None\)\s*:
Output
Bug:Python 的默认参数在函数定义时仅被求值一次,`logs=[]` 会导致所有不带该参数的调用共享同一个列表对象。

最小修复:将默认值改为 `None`,在函数体内部按需创建新列表。

FIX:
```python
def log_request(req, logs=None):
    if logs is None:
        logs = []
    logs.append(req['id'])
    return logs
```
challenge-reasoning-006 PASS
Suite: reasoning · Latency: 9748 ms · Cost: $0.001139 · Finish: stop
Prompt
只回答最终数字:一个队列从左到右是 A,B,C,D,E。依次执行:把第 2 个移到末尾;删除第 3 个;在最前面插入 X;把最后两个反转。最终队列中 C 的位置是第几位?
Standard Answer / Scoring Expectation
Answer: 3
Output
3
challenge-reasoning-007 PASS
Suite: reasoning · Latency: 7442 ms · Cost: $0.000838 · Finish: stop
Prompt
只回答最终数字:某缓存命中率从 60% 提升到 75%。如果总请求数为 800,未命中请求减少了多少个?
Standard Answer / Scoring Expectation
Answer: 120
Output
120
challenge-rag-005 PASS
Suite: rag_long_context · Latency: 7054 ms · Cost: $0.000924 · Finish: stop
Prompt
只根据资料回答。

资料:A 模型在 ability mode 中通过 46/50,成本 0.12 美元;在 efficiency mode 中通过 34/50,成本 0.04 美元。报告建议把 ability mode 用于能力判断,把 efficiency mode 用于成本和稳定性判断。

问题:如果文章讨论“模型真实能力”,应该优先引用哪个模式?如果讨论“低预算可用性”,应该优先引用哪个模式?
Standard Answer / Scoring Expectation
Required phrases: ability mode、efficiency mode、真实能力、低预算
Forbidden phrases: 只看一个模式
Length guidance (diagnostic only): min=n/a, max=180
Output
讨论“模型真实能力”应优先引用 **ability mode**;讨论“低预算可用性”应优先引用 **efficiency mode**。
challenge-rag-006 PASS
Suite: rag_long_context · Latency: 1584 ms · Cost: $0.001069 · Finish: stop
Prompt
只根据资料回答。

资料:一次失败分析显示,模型输出了 key = int(parts[1]),但测试数据里的 key 是字符串 a、b、c。报告认为这是“擅自补类型假设”,不是 token 截断。

问题:这次失败的根因是什么?
Standard Answer / Scoring Expectation
Required phrases: key
At least one from each group: 字符串 / 类型不匹配;整数 / int;类型假设 / 假设 key 为整数 / 假设 key 是整数 / key 为整数类型
Length guidance (diagnostic only): min=n/a, max=120
Output
这次失败的根因是**模型擅自补充了类型假设**:它错误地假设 `key` 是整数类型并使用了 `int(parts[1])`,但测试数据中的 `key` 实际是字符串(`a`、`b`、`c`),导致类型转换失败。
challenge-rag-007 PASS
Suite: rag_long_context · Latency: 12231 ms · Cost: $0.001041 · Finish: stop
Prompt
只根据资料回答,不要自行补充。

资料:DracoBench 的 HTML 报告目前展示 Summary、By Suite、Failure Examples 和 Case Details。Failure Examples 中包括 Prompt、Mistake Analysis、Scorer Details 和 Output。资料没有提到图表功能。

问题:报告是否已经支持图表?回答时说明依据。
Standard Answer / Scoring Expectation
Required phrases: 图表、资料
At least one from each group: 提到 / 提及
Forbidden phrases: 已经支持、折线图、柱状图
Length guidance (diagnostic only): min=n/a, max=100
Output
根据资料,**无法确认报告已支持图表功能**。

**依据**:资料仅说明 DracoBench 的 HTML 报告目前展示 Summary、By Suite、Failure Examples 和 Case Details,且明确提到“资料没有提到图表功能”。因此,仅根据现有资料,不能得出报告支持图表的结论。
challenge-if-004 PASS
Suite: instruction_following · Latency: 12745 ms · Cost: $0.001151 · Finish: stop
Prompt
只输出 JSON 对象。字段 mode 必须是 "ability";字段 limits 必须是对象,包含 max_tokens:4096 和 temperature:0;字段 warnings 必须是正好两个字符串组成的数组。不要 Markdown。
Standard Answer / Scoring Expectation
Expected JSON schema:
{
  "type": "object",
  "required": [
    "mode",
    "limits",
    "warnings"
  ],
  "additionalProperties": false,
  "properties": {
    "mode": {
      "type": "string",
      "const": "ability"
    },
    "limits": {
      "type": "object",
      "required": [
        "max_tokens",
        "temperature"
      ],
      "additionalProperties": false,
      "properties": {
        "max_tokens": {
          "type": "integer",
          "const": 4096
        },
        "temperature": {
          "type": "integer",
          "const": 0
        }
      }
    },
    "warnings": {
      "type": "array",
      "minItems": 2,
      "maxItems": 2,
      "items": {
        "type": "string"
      }
    }
  }
}
Output
{"mode":"ability","limits":{"max_tokens":4096,"temperature":0},"warnings":["内容仅供参考","请核实关键信息"]}
challenge-if-005 PASS
Suite: instruction_following · Latency: 6700 ms · Cost: $0.001344 · Finish: stop
Prompt
只输出 Markdown 表格,必须有 3 列:模式、用途、风险。必须包含 ability mode 和 efficiency mode 两行。不能添加表格外说明。
Standard Answer / Scoring Expectation
Expected regex pattern:
^\s*\|\s*模式\s*\|\s*用途\s*\|\s*风险\s*\|\s*\n\s*\|\s*-+\s*\|\s*-+\s*\|\s*-+\s*\|[\s\S]*ability mode[\s\S]*efficiency mode[\s\S]*$
Output
| 模式 | 用途 | 风险 |
|------|------|------|
| ability mode | 最大化模型能力,处理复杂推理与创作任务 | 计算资源消耗高,响应延迟增加 |
| efficiency mode | 优先保证响应速度与资源利用率 | 可能牺牲部分精度或输出质量 |
challenge-zh-writing-003 PASS
Suite: chinese_writing · Latency: 37430 ms · Cost: $0.003049 · Finish: stop
Prompt
写一段不超过 140 个汉字的公众号小结,主题是“为什么要同时展示原题、模型输出和错误解释”。必须包含“原题”“错误解释”“可复查”,不能出现“玄学”。
Standard Answer / Scoring Expectation
Required phrases: 原题、错误解释、可复查
Forbidden phrases: 玄学
Length guidance (diagnostic only): min=n/a, max=140
Output
同时展示原题、模型输出与错误解释,能让评测链路透明闭环。读者速览原题即可定位偏差,结合输出与错误解释看清模型失误逻辑。三者完整呈现,确保结论真实可复查,拒绝黑箱,共建可信的评测生态。
challenge-reasoning-008 PASS
Suite: reasoning · Latency: 9260 ms · Cost: $0.001102 · Finish: stop
Prompt
只回答最终数字:变量初始为 x=2, y=5, z=1。若 x<y,交换 x 和 y;然后令 z=z+x-y;若 z 为偶数,令 y=y+z,否则令 x=x+z。最终 x+y+z 等于多少?
Standard Answer / Scoring Expectation
Answer: 15
Output
15
challenge-reasoning-009 PASS
Suite: reasoning · Latency: 19292 ms · Cost: $0.004263 · Finish: stop
Prompt
只回答一个字母:任务 A、B、C、D、E、F 排列。C 必须紧挨在 A 后面;B 必须在 D 前;D 必须在 F 前;F 必须最后;E 不能第一。在所有满足条件的排列中字典序最小的排列,第三个任务是谁?
Standard Answer / Scoring Expectation
Answer: B
Output
B
challenge-reasoning-010 PASS
Suite: reasoning · Latency: 19109 ms · Cost: $0.002115 · Finish: stop
Prompt
只回答“可满足”或“不可满足”:布尔变量 x、y、z 满足:x 和 y 恰好一个为真;如果 x 为真则 z 为真;如果 y 为真则 z 为假;z 为真。是否存在赋值满足全部约束?
Standard Answer / Scoring Expectation
Answer: 可满足
Output
可满足
challenge-reasoning-011 PASS
Suite: reasoning · Latency: 3002 ms · Cost: $0.000891 · Finish: stop
Prompt
只回答最终数字:列表 [2,4,6,8] 中每个数先减去它的位置编号(从 1 开始),然后删除所有奇数,再把剩余数平方,最后求和。结果是多少?
Standard Answer / Scoring Expectation
Answer: 20
Output
20
challenge-reasoning-012 PASS
Suite: reasoning · Latency: 4022 ms · Cost: $0.000755 · Finish: stop
Prompt
只回答最终数字:一个 5 位二进制数 10110 先循环右移 1 位,再与 00111 做异或,最后转成十进制。结果是多少?
Standard Answer / Scoring Expectation
Answer: 12
Output
12
challenge-reasoning-013 PASS
Suite: reasoning · Latency: 1695 ms · Cost: $0.000397 · Finish: stop
Prompt
只回答一个字母:模型 A 通过 18 题、成本 0.06;模型 B 通过 20 题、成本 0.10;模型 C 通过 16 题、成本 0.04。按“通过题数/成本”最高选择,应该选哪个模型?
Standard Answer / Scoring Expectation
Answer: C
Output
C
challenge-reasoning-014 PASS
Suite: reasoning · Latency: 14338 ms · Cost: $0.000568 · Finish: stop
Prompt
只回答最终数字:同一套 100 道题中,失败题数从 12 降到 7。错误率降低了多少个百分点?
Standard Answer / Scoring Expectation
Answer: 5
Output
5
challenge-reasoning-015 PASS
Suite: reasoning · Latency: 4531 ms · Cost: $0.000956 · Finish: stop
Prompt
只回答最终数字:集合 S 初始为 {a,b,c,d}。删除字母序在 c 之前的元素;加入 e 和 b;再删除所有元音字母。最终集合有几个元素?
Standard Answer / Scoring Expectation
Answer: 3
Output
3
challenge-reasoning-016 PASS
Suite: reasoning · Latency: 16923 ms · Cost: $0.003401 · Finish: stop
Prompt
只回答最终数字:3x3 矩阵按行是 1 2 3 / 4 5 6 / 7 8 9。顺时针旋转 90 度后,第二行元素之和是多少?
Standard Answer / Scoring Expectation
Answer: 15
Output
15
challenge-reasoning-017 PASS
Suite: reasoning · Latency: 12572 ms · Cost: $0.002599 · Finish: stop
Prompt
只回答最终数字:依赖关系为 a 无依赖;b 依赖 a;c 依赖 a;d 依赖 b 和 c;e 依赖 b;f 依赖 d 和 e;g 依赖 a。按可并行执行的拓扑层划分,第二层有几个任务?
Standard Answer / Scoring Expectation
Answer: 3
Output
3
challenge-reasoning-018 PASS
Suite: reasoning · Latency: 3702 ms · Cost: $0.000431 · Finish: stop
Prompt
只回答星期几:第 0 天是星期二。每 7 天循环一次。第 17 天是星期几?
Standard Answer / Scoring Expectation
Answer: 星期五
Output
星期五
challenge-reasoning-019 PASS
Suite: reasoning · Latency: 8793 ms · Cost: $0.003541 · Finish: stop
Prompt
只回答最终数字:用 A、B、C 组成长度为 3 的字符串,要求恰好包含一个 A,并且最后一个字符不能是 C。满足条件的字符串有多少个?
Standard Answer / Scoring Expectation
Answer: 8
Output
8
challenge-reasoning-020 PASS
Suite: reasoning · Latency: 2918 ms · Cost: $0.001411 · Finish: stop
Prompt
只回答最终数字:栈操作从空栈开始。push n 表示入栈;dup 复制栈顶;add 弹出两个数并压入它们的和;swap 交换栈顶两个数;sub 先弹出 x 再弹出 y,并压入 y-x。依次执行:push 2, push 3, dup, add, push 4, swap, sub。最终栈顶是多少?
Standard Answer / Scoring Expectation
Answer: -2
Output
-2
challenge-reasoning-021 PASS
Suite: reasoning · Latency: 13286 ms · Cost: $0.003510 · Finish: stop
Prompt
只回答最终数字:三个队列 Q1、Q2、Q3 初始长度分别为 2、1、0。每一轮先从所有非空队列各处理 1 个元素,然后向 Q3 加入 2 个元素。执行 3 轮后,三个队列总长度是多少?
Standard Answer / Scoring Expectation
Answer: 4
Output
4
challenge-reasoning-022 PASS
Suite: reasoning · Latency: 2247 ms · Cost: $0.000786 · Finish: stop
Prompt
只回答最终数字:映射初始为 {a:1, b:2}。依次执行:设置 c=a+b;设置 a=c-b;删除 b;设置 d=a+c。最终所有 value 之和是多少?
Standard Answer / Scoring Expectation
Answer: 8
Output
8
challenge-reasoning-023 PASS
Suite: reasoning · Latency: 13009 ms · Cost: $0.001253 · Finish: stop
Prompt
只回答“甲”“乙”或“丙”:甲说“乙说的是真话”;乙说“丙说的是假话”;丙说“甲说的是假话”。如果恰好一人说真话,说真话的人是谁?
Standard Answer / Scoring Expectation
Answer: 丙
Output
challenge-reasoning-024 PASS
Suite: reasoning · Latency: 1196 ms · Cost: $0.000785 · Finish: stop
Prompt
只回答一个字母:综合分 = 通过率百分数 - 成本乘以 10。模型 A 通过率 92%、成本 0.20;模型 B 通过率 88%、成本 0.05;模型 C 通过率 90%、成本 0.10。综合分最高的是哪个模型?
Standard Answer / Scoring Expectation
Answer: A
Output
A
challenge-reasoning-025 PASS
Suite: reasoning · Latency: 6714 ms · Cost: $0.000687 · Finish: stop
Prompt
只回答最终三位数:一个三位数的百位为 a、十位为 b、个位为 c。已知 a+b+c=13,a=c+1,b=2c。这个三位数是多少?
Standard Answer / Scoring Expectation
Answer: 463
Output
463
challenge-coding-015 PASS
Suite: coding · Latency: 28762 ms · Cost: $0.020630 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(line: str) -> list[str],解析一行简化 CSV:逗号分隔;字段可以用双引号包裹;引号内逗号保留;引号内两个连续双引号表示一个双引号;空字段保留;空格是普通字符,不要自动 trim。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('a,"b,c",d') == ['a', 'b,c', 'd']
assert solution.solve('"a""b",,x') == ['a"b', '', 'x']
assert solution.solve('  a ," b " ') == ['  a ', ' b  ']
Output
```python
def solve(line: str) -> list[str]:
    res = []
    cur = []
    i = 0
    n = len(line)
    in_quote = False
    while i < n:
        c = line[i]
        if not in_quote:
            if c == ',':
                res.append(''.join(cur))
                cur = []
            elif c == '"':
                in_quote = True
            else:
                cur.append(c)
        else:
            if c == '"':
                if i + 1 < n and line[i + 1] == '"':
                    cur.append('"')
                    i += 2
                    continue
                else:
                    in_quote = False
            else:
                cur.append(c)
        i += 1
    res.append(''.join(cur))
    return res
```
challenge-coding-016 PASS
Suite: coding · Latency: 22860 ms · Cost: $0.003040 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]。intervals 是整数闭区间,先按起点排序;重叠或端点相邻的区间要合并,例如 [1,2] 和 [3,4] 合并为 [1,4]。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve([(5,7),(1,2),(3,4),(10,10)]) == [(1,7),(10,10)]
assert solution.solve([(1,1),(3,3)]) == [(1,1),(3,3)]
assert solution.solve([]) == []
Output
```python
def solve(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
    if not intervals:
        return []
    intervals.sort(key=lambda x: x[0])
    res = [list(intervals[0])]
    for start, end in intervals[1:]:
        if start <= res[-1][1] + 1:
            if end > res[-1][1]:
                res[-1][1] = end
        else:
            res.append([start, end])
    return [(s, e) for s, e in res]
```
challenge-coding-017 PASS
Suite: coding · Latency: 52155 ms · Cost: $0.004620 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(events: list[tuple[str, int]], window: int, limit: int) -> list[bool],模拟按用户限流。events 按时间非降序排列。某用户在当前事件时间 ts 的窗口 (ts-window, ts] 内,已放行事件数少于 limit 才放行;被拒绝的事件不计入窗口。
Standard Answer / Scoring Expectation
Reference tests:
events=[('a',1),('a',2),('a',3),('a',4),('a',8)]
assert solution.solve(events, 5, 2) == [True, True, False, False, True]
assert solution.solve([('x',10),('x',11),('x',16)], 5, 1) == [True, False, True]
Output
```python
from collections import deque

def solve(events: list[tuple[str, int]], window: int, limit: int) -> list[bool]:
    user_queues: dict[str, deque[int]] = {}
    res: list[bool] = []
    for user, ts in events:
        q = user_queues.get(user)
        if q is None:
            q = deque()
            user_queues[user] = q
        cutoff = ts - window
        while q and q[0] <= cutoff:
            q.popleft()
        if len(q) < limit:
            q.append(ts)
            res.append(True)
        else:
            res.append(False)
    return res
```
challenge-coding-018 PASS
Suite: coding · Latency: 28949 ms · Cost: $0.003139 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(path: str) -> str,规范化绝对 Unix 路径:处理重复斜杠、.、..;.. 在根目录时仍留在根目录;返回结果必须以 / 开头且除根目录外不能以 / 结尾。不要使用 os.path。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('/a//b/./c/../') == '/a/b'
assert solution.solve('/../../x') == '/x'
assert solution.solve('/') == '/'
Output
```python
def solve(path: str) -> str:
    stack = []
    for part in path.split('/'):
        if part == '' or part == '.':
            continue
        if part == '..':
            if stack:
                stack.pop()
        else:
            stack.append(part)
    return '/' + '/'.join(stack) if stack else '/'
```
challenge-coding-019 PASS
Suite: coding · Latency: 10602 ms · Cost: $0.002290 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(words: list[str]) -> list[list[str]],按变位词分组。大小写敏感;组内保持输入顺序;组的顺序按该组第一个单词在输入中出现的位置。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['eat','tea','tan','ate','nat','bat']) == [['eat','tea','ate'], ['tan','nat'], ['bat']]
assert solution.solve(['b','B','bb']) == [['b'], ['B'], ['bb']]
Output
```python
def solve(words: list[str]) -> list[list[str]]:
    groups = {}
    for word in words:
        key = tuple(sorted(word))
        groups.setdefault(key, []).append(word)
    return list(groups.values())
```
challenge-coding-020 PASS
Suite: coding · Latency: 12352 ms · Cost: $0.012264 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(text: str) -> dict,解析 Markdown front matter。只有第一行正好是 --- 时才解析,直到下一行 --- 结束;每行 key: value,key 和 value 两侧 trim;形如 [a, b] 的 value 返回字符串列表;其他 value 返回字符串。没有完整 front matter 返回 {}。
Standard Answer / Scoring Expectation
Reference tests:
text='---\ntitle: Test\ntags: [ai, bench,  v0]\ndraft: false\n---\nbody'
assert solution.solve(text) == {'title':'Test','tags':['ai','bench','v0'],'draft':'false'}
assert solution.solve('hello\n---\na: b') == {}
assert solution.solve('---\na: 1') == {}
Output
```python
def solve(text: str) -> dict:
    lines = text.splitlines()
    if not lines or lines[0] != '---':
        return {}
    result = {}
    for line in lines[1:]:
        if line == '---':
            return result
        if ':' not in line:
            continue
        key, value = line.split(':', 1)
        key = key.strip()
        value = value.strip()
        if value.startswith('[') and value.endswith(']'):
            inner = value[1:-1]
            result[key] = [item.strip() for item in inner.split(',')] if inner.strip() else []
        else:
            result[key] = value
    return {}
```
challenge-coding-021 PASS
Suite: coding · Latency: 8217 ms · Cost: $0.002667 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(items: list[str], k: int) -> list[str],返回出现次数最高的前 k 个元素;次数相同按第一次出现的先后排序;k 大于不同元素数量时返回全部。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['b','a','b','c','a','b'], 2) == ['b','a']
assert solution.solve(['x','y','z','y','z','x'], 2) == ['x','y']
assert solution.solve(['a'], 5) == ['a']
Output
```python
def solve(items: list[str], k: int) -> list[str]:
    cnt = {}
    first = {}
    for i, x in enumerate(items):
        cnt[x] = cnt.get(x, 0) + 1
        if x not in first:
            first[x] = i
    sorted_items = sorted(cnt.keys(), key=lambda x: (-cnt[x], first[x]))
    return sorted_items[:k]
```
challenge-coding-022 PASS
Suite: coding · Latency: 22321 ms · Cost: $0.005975 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(config: dict, overrides: dict[str, object]) -> dict。overrides 的 key 是点号路径;值为 None 表示删除该路径的叶子 key;其他值写入路径,必要时创建中间 dict;不能修改输入 config。
Standard Answer / Scoring Expectation
Reference tests:
base={'db':{'host':'old','port':5432},'feature':{'x':1}}
overrides={'db.host':'new','feature.x':None,'api.timeout':30}
res=solution.solve(base, overrides)
assert res == {'db':{'host':'new','port':5432},'feature':{},'api':{'timeout':30}}
assert base == {'db':{'host':'old','port':5432},'feature':{'x':1}}
assert solution.solve({'a':1}, {'a.b':2}) == {'a': {'b': 2}}
Output
```python
import copy

def solve(config: dict, overrides: dict[str, object]) -> dict:
    result = copy.deepcopy(config)
    for path, value in overrides.items():
        keys = path.split(".")
        node = result
        for key in keys[:-1]:
            if key not in node or not isinstance(node[key], dict):
                if value is None:
                    node = None
                    break
                node[key] = {}
            node = node[key]
        if node is not None:
            if value is None:
                node.pop(keys[-1], None)
            else:
                node[keys[-1]] = value
    return result
```
challenge-coding-023 PASS
Suite: coding · Latency: 42301 ms · Cost: $0.005918 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(query: str) -> dict[str, list[str]],解析 URL query string。& 分隔参数;没有 = 的参数值为空字符串;+ 表示空格;%XX 需要按 UTF-8 百分号解码;同名 key 保留所有值的列表。可以使用标准库。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('a=1&b=two+words&a=3') == {'a':['1','3'], 'b':['two words']} 
assert solution.solve('empty=&flag&x=a%2Bb') == {'empty':[''], 'flag':[''], 'x':['a+b']} 
assert solution.solve('') == {}
Output
```python
from urllib.parse import unquote_plus

def solve(query: str) -> dict[str, list[str]]:
    result: dict[str, list[str]] = {}
    if not query:
        return result
    for part in query.split("&"):
        if not part:
            continue
        if "=" in part:
            key, value = part.split("=", 1)
        else:
            key, value = part, ""
        key = unquote_plus(key)
        value = unquote_plus(value)
        result.setdefault(key, []).append(value)
    return result
```
challenge-coding-024 PASS
Suite: coding · Latency: 56991 ms · Cost: $0.007424 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(html: str) -> bool,校验简化 HTML 标签是否配对。标签形如 <a>、</a>、<br/>,标签名只含小写字母;自闭合标签不入栈;普通文本忽略。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve('<div><br/><p>x</p></div>') is True
assert solution.solve('<a><b></a></b>') is False
assert solution.solve('text<a><b/></a>') is True
Output
```python
def solve(html: str) -> bool:
    stack = []
    i = 0
    n = len(html)
    while i < n:
        if html[i] != '<':
            i += 1
            continue
        j = html.find('>', i)
        if j == -1:
            return False
        tag = html[i + 1:j]
        if not tag:
            return False
        if tag[0] == '/':
            name = tag[1:]
            if not name or not all('a' <= c <= 'z' for c in name):
                return False
            if not stack or stack[-1] != name:
                return False
            stack.pop()
        elif tag[-1] == '/':
            name = tag[:-1]
            if not name or not all('a' <= c <= 'z' for c in name):
                return False
        else:
            name = tag
            if not name or not all('a' <= c <= 'z' for c in name):
                return False
            stack.append(name)
        i = j + 1
    return not stack
```
challenge-coding-025 FAIL
Suite: coding · Latency: 14357 ms · Cost: $0.003066 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(grid: list[str]) -> int。grid 中 S 是起点,E 是终点,# 是墙,. 可走。每步上下左右移动一格,返回从 S 到 E 的最短步数;不可达返回 -1。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['S..','##.','..E']) == 4
assert solution.solve(['S#','##','E.']) == -1
assert solution.solve(['SE']) == 1
Mistake Analysis
Failure type: code_execution_failure
当前失败类型是 `code_execution_failure`,scorer 是 `code_python_tests`。可见判分信号为 `{"returncode": 1, "stderr": "Traceback (most recent call last):\n File \"/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000g…`,模型输出片段为 ````python\nfrom collections import deque\n\ndef solve(grid: list[str]) -> int:\n if not grid or not grid[0]:\n …`。报告模板还没有这个组合的专项诊断,因此这里先给出可复查的失败信号;后续应为该 case 补一条 case-aware root cause。
Output
```python
from collections import deque

def solve(grid: list[str]) -> int:
    if not grid or not grid[0]:
        return -1
    n = len(grid)
    m = len(grid[0])
    sx = sy = ex = ey = -1
    for i in range(n):
        for j in range(m):
            c = grid[i][j]
            if c == 'S':
                sx, sy = i, j
            elif c == 'E':
                ex, ey = i, j
    if sx == -1 or ex == -1:
        return -1
    dist = [[-1] * m for _ in range(n)]
    q = deque()
    q.append((sx, sy))
    dist[sx][sy] = 0
    for x, y in q:
        if x == ex and y == ey:
            return dist[x][y]
        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nx, ny = x + dx, y + dy
            if 0 <= nx < n and 0 <= ny < m and dist[nx][ny] == -1 and grid[nx][ny] != '#':
                dist[nx][ny] = dist[x][y] + 1
                q.append((nx, ny))
    return -1
```
challenge-coding-026 PASS
Suite: coding · Latency: 344412 ms · Cost: $0.054040 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(nums: list[int], k: int) -> list[float],返回每个长度为 k 的滑动窗口中位数。k 为奇数时返回中间值;k 为偶数时返回两个中间值平均数。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve([1,3,-1,-3,5,3,6,7], 3) == [1, -1, -1, 3, 5, 6]
assert solution.solve([1,2,3,4], 2) == [1.5, 2.5, 3.5]
Output
```python
import heapq

def solve(nums: list[int], k: int) -> list[float]:
    if not nums or k == 0:
        return []
    
    small = []
    large = []
    delayed = {}
    small_size = 0
    large_size = 0
    
    def prune(heap):
        while heap:
            num = -heap[0] if heap is small else heap[0]
            if delayed.get(num, 0):
                heapq.heappop(heap)
                delayed[num] -= 1
                if delayed[num] == 0:
                    del delayed[num]
            else:
                break
    
    def make_balance():
        nonlocal small_size, large_size
        if small_size > large_size + 1:
            prune(small)
            val = -heapq.heappop(small)
            heapq.heappush(large, val)
            small_size -= 1
            large_size += 1
        elif small_size < large_size:
            prune(large)
            val = heapq.heappop(large)
            heapq.heappush(small, -val)
            large_size -= 1
            small_size += 1
    
    def insert(num):
        nonlocal small_size, large_size
        if not small or num <= -small[0]:
            heapq.heappush(small, -num)
            small_size += 1
        else:
            heapq.heappush(large, num)
            large_size += 1
        make_balance()
    
    def erase(num):
        nonlocal small_size, large_size
        delayed[num] = delayed.get(num, 0) + 1
        if num <= -small[0]:
            small_size -= 1
            if num == -small[0]:
                prune(small)
        else:
            large_size -= 1
            if large and num == large[0]:
                prune(large)
        make_balance()
    
    def get_median():
        prune(small)
        prune(large)
        if k % 2 == 1:
            return float(-small[0])
        else:
            return (-small[0] + large[0]) / 2.0
    
    res = []
    for i, num in enumerate(nums):
        insert(num)
        if i >= k:
            erase(nums[i - k])
        if i >= k - 1:
            res.append(get_median())
    return res
```
challenge-coding-027 PASS
Suite: coding · Latency: 34747 ms · Cost: $0.004442 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(versions: list[str]) -> list[str],按简化语义版本排序。版本为 major.minor.patch 或 major.minor.patch-label;major/minor/patch 按数字比较;同一数字版本下,带 label 的预发布版本低于正式版本;label 按字典序比较。
Standard Answer / Scoring Expectation
Reference tests:
assert solution.solve(['1.0.0','1.0.0-alpha','1.0.1','1.0.0-beta','0.9.9']) == ['0.9.9','1.0.0-alpha','1.0.0-beta','1.0.0','1.0.1']
assert solution.solve(['1.0.10','1.0.2']) == ['1.0.2','1.0.10']
Output
```python
def solve(versions: list[str]) -> list[str]:
    def parse(v: str):
        parts = v.split('-', 1)
        major, minor, patch = map(int, parts[0].split('.'))
        if len(parts) == 2:
            return (major, minor, patch, 0, parts[1])
        return (major, minor, patch, 1, "")
    return sorted(versions, key=parse)
```
challenge-coding-028 PASS
Suite: coding · Latency: 24932 ms · Cost: $0.009566 · Finish: stop
Prompt
只输出 Python 代码,不要解释。实现 solve(deps: dict[str, list[str]], changed: list[str]) -> list[str]。deps 表示 package -> 直接依赖。返回所有 changed 包,以及直接或间接依赖 changed 包的包,按字典序排序;只出现在依赖列表中的包也要能作为 changed 包返回。
Standard Answer / Scoring Expectation
Reference tests:
deps={'app':['lib','ui'],'ui':['core'],'lib':['core'],'core':[],'docs':[]}
assert solution.solve(deps, ['core']) == ['app','core','lib','ui']
assert solution.solve({'a':['x']}, ['x']) == ['a','x']
assert solution.solve({'a':['b'], 'b':[]}, ['a']) == ['a']
Output
```python
def solve(deps: dict[str, list[str]], changed: list[str]) -> list[str]:
    from collections import deque
    rev = {}
    for pkg, dlist in deps.items():
        rev.setdefault(pkg, [])
        for d in dlist:
            rev.setdefault(d, []).append(pkg)
    res = set(changed)
    q = deque(changed)
    while q:
        cur = q.popleft()
        for pkg in rev.get(cur, []):
            if pkg not in res:
                res.add(pkg)
                q.append(pkg)
    return sorted(res)
```
challenge-rag-008 PASS
Suite: rag_long_context · Latency: 11654 ms · Cost: $0.001122 · Finish: stop
Prompt
只根据资料回答。

资料 A:早期草案说 v0.3 只新增 20 道题。
资料 B:2026-06-16 的确认方案是 v0.3-challenge100,在现有 50 题基础上新增 50 道题。
资料 C:新增题应先生成审题 HTML,确认后再跑模型,不要立即消耗 API。

问题:下一步应该新增多少题?是否应该立刻跑模型?
Standard Answer / Scoring Expectation
Required phrases: 50、审题
At least one from each group: 不跑 / 不要立刻 / 先不跑 / 不应立刻 / 不应该立刻 / 不应立即 / 不应该立即 / 不应立刻跑 / 不应该立刻跑 / 不应立即跑 / 不应该立即跑
Length guidance (diagnostic only): min=n/a, max=160
Output
下一步应新增 **50 道题**(依据资料 B 的确认方案 v0.3-challenge100)。

**不应该立刻跑模型**;应先生成审题 HTML 并确认后再跑模型,避免立即消耗 API(依据资料 C)。
challenge-rag-009 PASS
Suite: rag_long_context · Latency: 5610 ms · Cost: $0.000647 · Finish: stop
Prompt
只根据资料回答,不要自行补充。

资料:报告展示 pass_rate、avg_latency_ms、total_cost、reasoning_tokens、失败样例和逐题明细。资料没有包含用户满意度调查,也没有包含模型训练数据来源。

问题:能否根据这份报告判断用户满意度?
Standard Answer / Scoring Expectation
Required phrases: 不能、用户满意度
At least one from each group: 没有包含 / 没有提供 / 资料没有 / 未包含
Forbidden phrases: 可以判断
Length guidance (diagnostic only): min=n/a, max=120
Output
不能。资料明确说明报告没有包含用户满意度调查。
challenge-rag-010 PASS
Suite: rag_long_context · Latency: 20388 ms · Cost: $0.005005 · Finish: stop
Prompt
只根据资料回答。

资料:模型 A 通过 48/50,平均延迟 20 秒,成本 0.20 美元,没有超时失败。模型 B 通过 44/50,平均延迟 4 秒,成本 0.05 美元,没有超时失败。模型 C 通过 46/50,平均延迟 9 秒,成本 0.04 美元,但有 3 次 API 超时。

问题:如果要选低延迟且稳定的生产摘要模型,资料更支持选择哪个?
Standard Answer / Scoring Expectation
Required phrases: B、延迟
At least one from each group: 没有超时 / 无超时
Forbidden phrases: 选择 A、选择 C
Length guidance (diagnostic only): min=n/a, max=160
Output
资料更支持选择**模型 B**。

理由:
- **低延迟**:模型 B 平均延迟仅 **4 秒**,远低于模型 A(20 秒)和模型 C(9 秒)。
- **稳定性**:模型 B **没有超时失败**,响应时间稳定;模型 C 有 3 次 API 超时,存在稳定性风险;模型 A 虽通过率最高,但延迟过高。

因此,在“低延迟且稳定”的权衡下,模型 B 最符合生产摘要模型的需求。
challenge-rag-011 PASS
Suite: rag_long_context · Latency: 8632 ms · Cost: $0.000798 · Finish: stop
Prompt
只根据资料回答。

资料:DracoBench 当前 scoring policy 中,text_rules 的 max_chars/min_chars 只作为诊断信息记录,length_scored 为 false。缺少 required、required_any 或出现 forbidden 才会导致失败。

问题:如果答案超过 max_chars,但 required 都满足且没有 forbidden,会因为长度直接扣分吗?
Standard Answer / Scoring Expectation
Required phrases: 诊断
At least one from each group: 不扣分 / 不会 / 不会因长度 / 不会因此被扣分 / 不会直接导致扣分 / 不会导致扣分 / 不会导致失败或扣分;length_scored / 长度
Forbidden phrases: 直接失败、必须重跑
Length guidance (diagnostic only): min=n/a, max=140
Output
不会。根据资料,max_chars 仅作为诊断信息记录,且 length_scored 为 false;只要 required 都满足且没有 forbidden,不会因长度直接扣分或失败。
challenge-rag-012 PASS
Suite: rag_long_context · Latency: 12205 ms · Cost: $0.000783 · Finish: stop
Prompt
只根据资料回答。

资料 A:某模型原始结果为 45/50。
资料 B:修正一个同义表达评分规则后,rescored 结果为 46/50。
资料 C:总览 index 使用 rescored JSONL 作为展示结果。

问题:写文章引用总览结果时,应写 45/50 还是 46/50?
Standard Answer / Scoring Expectation
Required phrases: 46/50
Forbidden phrases: 45/50 更合适、原始结果为准
Length guidance (diagnostic only): min=n/a, max=140
Output
应写 **46/50**。

依据资料 C,总览 index 使用 rescored JSONL 作为展示结果;而资料 B 显示 rescored 结果为 46/50。因此引用总览结果时应采用 rescored 后的 46/50。
challenge-rag-013 PASS
Suite: rag_long_context · Latency: 4335 ms · Cost: $0.000645 · Finish: stop
Prompt
只根据资料回答。

资料:为了复现一次 benchmark,记录中包含 model、case_id、prompt_hash、parameters、scorer details、output、latency_ms 和 usage。记录不包含 chain of thought,也不包含训练数据。

问题:复现评测主要应该依赖哪些记录字段?
Standard Answer / Scoring Expectation
Required phrases: model、prompt_hash、parameters、scorer
Forbidden phrases: chain of thought、训练数据
Length guidance (diagnostic only): min=n/a, max=200
Output
根据资料,复现评测主要应该依赖的记录字段包括:**model、case_id、prompt_hash、parameters、scorer details、output、latency_ms、usage**。
challenge-rag-014 PASS
Suite: rag_long_context · Latency: 7782 ms · Cost: $0.000641 · Finish: stop
Prompt
只根据资料回答。

资料 A:早期 ability mode 使用 4096 max_tokens。
资料 B:后来为了公平,ability mode 统一放宽到 16384 max_tokens。
资料 C:当前总览页只展示 v0.2-challenge50 且 ability16384 的结果。

问题:当前总览页对应的 token limit 是多少?
Standard Answer / Scoring Expectation
Required phrases: 16384
Forbidden phrases: 4096
Length guidance (diagnostic only): min=n/a, max=100
Output
16384
challenge-rag-015 PASS
Suite: rag_long_context · Latency: 6501 ms · Cost: $0.001077 · Finish: stop
Prompt
只根据资料回答。

资料:coding-004 的失败是代码运行时 ValueError,根因是把字符串 key 强转 int。rag-006 的失败曾经是规则没有把 int 类型视作“整数”的同义表达,后来通过人工复查修正规则。

问题:哪类失败更需要人工复查评分规则?回答时也说明 coding-004 是否属于这种情况。
Standard Answer / Scoring Expectation
Required phrases: 人工复查、coding-004
At least one from each group: rag-006 / 规则 / 评分规则 / 同义表达;不属于 / 不是 / 不需要
Length guidance (diagnostic only): min=n/a, max=180
Output
根据资料,**因评分规则本身缺陷导致的失败(如 rag-006 这类规则未覆盖同义表达的情况)更需要人工复查评分规则**。

coding-004 **不属于**这种情况。它的失败是代码运行时 ValueError(把字符串 key 强转 int),属于代码执行错误,而非评分规则定义问题。
challenge-rag-016 PASS
Suite: rag_long_context · Latency: 7947 ms · Cost: $0.001176 · Finish: stop
Prompt
只根据资料回答。

资料:usage 字段包含 prompt_tokens、completion_tokens、reasoning_tokens 和 cost。报告没有供应商真实利润率,也没有供应商内部成本。

问题:能否从 usage 字段判断供应商利润率?
Standard Answer / Scoring Expectation
Required phrases: 不能、利润率
At least one from each group: 不包含 / 没有
Forbidden phrases: 可以判断
Length guidance (diagnostic only): min=n/a, max=120
Output
不能。usage 字段仅包含 token 用量和 cost,但资料明确说明报告**没有供应商真实利润率,也没有供应商内部成本**,因此无法判断利润率。
challenge-rag-017 PASS
Suite: rag_long_context · Latency: 19879 ms · Cost: $0.000911 · Finish: stop
Prompt
只根据资料回答。

资料:当前 index 页只显示最后这版 50 道题的 v0.2-challenge50 结果,并且 token limit 都统一为 ability16384。之前的版本和 ability4096 结果不显示在 index 页。

问题:index 页是否应该展示旧版本结果?当前展示范围是什么?
Standard Answer / Scoring Expectation
Required phrases: v0.2-challenge50、ability16384
At least one from each group: 不应该 / 不展示 / 未展示 / 不显示 / 均不显示 / 不应展示;旧版本 / 之前的版本
Length guidance (diagnostic only): min=n/a, max=160
Output
根据资料:

1. **index 页不应该展示旧版本结果**——资料明确说明“之前的版本……不显示在 index 页”。
2. **当前展示范围**是:最后这版 50 道题的 **v0.2-challenge50** 结果,且 **token limit 统一为 ability16384**。
challenge-rag-018 PASS
Suite: rag_long_context · Latency: 4122 ms · Cost: $0.000794 · Finish: stop
Prompt
只根据资料回答。

资料:某 coding 题中,模型响应的 finish_reason 为 length,output 为空,测试报错为 module has no attribute solve。报告认为这不是算法逻辑错误,而是输出被截断后没有形成可执行函数。

问题:这次失败应如何归因?
Standard Answer / Scoring Expectation
Required phrases: 输出
At least one from each group: 截断 / length / token
Length guidance (diagnostic only): min=n/a, max=140
Output
应归因于**输出被截断**(长度限制导致),而非算法逻辑错误。
challenge-debugging-015 PASS
Suite: debugging · Latency: 9368 ms · Cost: $0.001088 · Finish: stop
Prompt
下面代码期望 funcs[0]()、funcs[1]()、funcs[2]() 分别返回 0、1、2,但实际都会返回 2。请指出根因,并给出最小修复。最后单独一行写 FIX: <修复后的 append 行>。

```python
funcs = []
for i in range(3):
    funcs.append(lambda: i)
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*funcs\.append\(lambda\s+i=i\s*:\s*i\)\s*`?
Output
根因:Python 的闭包对变量是**延迟绑定**(late binding),`lambda` 内部捕获的是变量名 `i`,而非循环当时的值。循环结束后 `i` 最终停留在 `2`,因此所有函数执行时都读取到同一个 `i` 即 `2`。

最小修复:利用默认参数在函数定义时**立即求值**绑定当前 `i` 的快照。

FIX: funcs.append(lambda i=i: i)
challenge-debugging-016 PASS
Suite: debugging · Latency: 9281 ms · Cost: $0.002033 · Finish: stop
Prompt
下面 context manager 期望异常继续向外抛出,但实际异常被吞掉。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
class Span:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc, tb):
        return True
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*return(?:\s+False|\s+None)?\s*`?
Output
`__exit__` 返回 `True` 会抑制异常传播,导致异常被吞掉。要让它继续向外抛出,应返回 `False`(或默认 `None`)。

FIX: return False
challenge-debugging-017 PASS
Suite: debugging · Latency: 3172 ms · Cost: $0.002981 · Finish: stop
Prompt
下面代码期望每个 Bag 实例都有独立列表,但不同实例会共享 items。请指出 bug,并给出最小修复。最后单独一行写 FIX: <新增到 __init__ 中的赋值行>。

```python
class Bag:
    items = []
    def add(self, x):
        self.items.append(x)
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*self\.items\s*=\s*\[\]\s*`?
Output
Bug:`items = []` 是类属性,所有 `Bag` 实例共享同一个列表对象。通过 `self.items.append` 修改时,由于实例自身没有 `items` 属性,会修改到类属性上,导致实例间互相影响。

最小修复:添加 `__init__` 方法,在每个实例创建时为其绑定独立的列表。

```python
class Bag:
    def __init__(self):
        self.items = []
    def add(self, x):
        self.items.append(x)
```

FIX: self.items = []
challenge-debugging-018 PASS
Suite: debugging · Latency: 55723 ms · Cost: $0.007176 · Finish: stop
Prompt
下面代码期望每次不传 ts 时使用当前时间,但默认时间只会在函数定义时计算一次。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的函数定义行>。

```python
from datetime import datetime

def mark(ts=datetime.utcnow()):
    return ts.isoformat()
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*def\s+mark\(ts=None\)\s*:
Output
Bug:Python 的默认参数只在函数**定义时**求值一次,因此 `datetime.utcnow()` 只在模块加载时执行一次,之后所有不传 `ts` 的调用都会返回同一个时间。

最小修复:将默认值改为 `None`,在函数体内判断并实时获取当前时间。

```python
def mark(ts=None):
    if ts is None:
        ts = datetime.utcnow()
    return ts.isoformat()
```

FIX: def mark(ts=None): return (ts if ts is not None else datetime.utcnow()).isoformat()
challenge-debugging-019 PASS
Suite: debugging · Latency: 2232 ms · Cost: $0.000681 · Finish: stop
Prompt
下面代码期望返回小写字符串,但实际返回的是方法对象。请指出 bug,并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def normalize(s):
    return s.strip().lower
```
Standard Answer / Scoring Expectation
Expected regex pattern:
FIX:\s*`?\s*return\s+s\.strip\(\)\.lower\(\)\s*`?
Output
Bug:`lower` 是字符串的方法对象,但代码没有加 `()` 调用它,因此返回的是方法本身而非调用后的结果。

最小修复:在 `lower` 后添加 `()` 以执行调用。

FIX: `return s.strip().lower()`
challenge-if-006 PASS
Suite: instruction_following · Latency: 6348 ms · Cost: $0.001562 · Finish: stop
Prompt
只输出 JSON 对象,不要 Markdown。字段 version 必须是 "v0.3";字段 ready 必须是 true;字段 cases 必须是正好两个对象组成的数组。cases 中每个对象只能包含 id、weight、active 三个字段;id 是字符串且匹配 case-1 或 case-2;weight 是整数;active 是布尔值。
Standard Answer / Scoring Expectation
Expected JSON schema:
{
  "type": "object",
  "required": [
    "version",
    "ready",
    "cases"
  ],
  "additionalProperties": false,
  "properties": {
    "version": {
      "type": "string",
      "const": "v0.3"
    },
    "ready": {
      "type": "boolean",
      "const": true
    },
    "cases": {
      "type": "array",
      "minItems": 2,
      "maxItems": 2,
      "items": {
        "type": "object",
        "required": [
          "id",
          "weight",
          "active"
        ],
        "additionalProperties": false,
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^case-[12]$"
          },
          "weight": {
            "type": "integer"
          },
          "active": {
            "type": "boolean"
          }
        }
      }
    }
  }
}
Output
{"version":"v0.3","ready":true,"cases":[{"id":"case-1","weight":1,"active":true},{"id":"case-2","weight":2,"active":false}]}
challenge-zh-writing-004 PASS
Suite: chinese_writing · Latency: 24112 ms · Cost: $0.005052 · Finish: stop
Prompt
写一段不超过 160 个汉字的公众号小结,主题是“为什么 v0.3 要扩到 100 题”。必须包含“推理题”“边界条件”“人工复查”,不能出现“排行榜”。
Standard Answer / Scoring Expectation
Required phrases: 推理题、边界条件、人工复查
Forbidden phrases: 排行榜
Length guidance (diagnostic only): min=n/a, max=160
Output
v0.3将题库扩充至100题,是因为少量题目无法覆盖复杂推理题的全貌。增加题量后,既能充分暴露模型在不同边界条件上的能力差异,也能为人工复查提供更充足的样本支撑,让评估结果更稳健可信。

Case Details

CaseSuiteStatusFailure TypeScoreLatencyCostFinish
challenge-coding-001codingPASS-1.032085 ms$0.003087stop
challenge-coding-002codingPASS-1.059236 ms$0.008494stop
challenge-coding-003codingPASS-1.056991 ms$0.011605stop
challenge-coding-004codingFAILruntime_type_assumption0.027330 ms$0.003958stop
challenge-coding-005codingPASS-1.060955 ms$0.007923stop
challenge-coding-006codingPASS-1.055550 ms$0.006263stop
challenge-coding-007codingPASS-1.0118324 ms$0.012597stop
challenge-coding-008codingPASS-1.049916 ms$0.004169stop
challenge-debugging-001debuggingPASS-1.052143 ms$0.008826stop
challenge-debugging-002debuggingPASS-1.024807 ms$0.004400stop
challenge-debugging-003debuggingPASS-1.0102399 ms$0.003835stop
challenge-debugging-004debuggingPASS-1.012056 ms$0.001014stop
challenge-debugging-005debuggingFAILregex_miss0.027864 ms$0.003271stop
challenge-debugging-006debuggingPASS-1.09647 ms$0.001292stop
challenge-debugging-007debuggingPASS-1.012531 ms$0.001488stop
challenge-debugging-008debuggingFAILmissing_accepted_answer0.014856 ms$0.003351stop
challenge-reasoning-001reasoningPASS-1.05019 ms$0.000653stop
challenge-reasoning-002reasoningPASS-1.023221 ms$0.006690stop
challenge-reasoning-003reasoningPASS-1.03688 ms$0.001333stop
challenge-reasoning-004reasoningPASS-1.07070 ms$0.000603stop
challenge-reasoning-005reasoningPASS-1.015759 ms$0.001484stop
challenge-rag-001rag_long_contextPASS-1.05874 ms$0.003073stop
challenge-rag-002rag_long_contextPASS-1.011548 ms$0.002261stop
challenge-rag-003rag_long_contextPASS-1.075999 ms$0.008302stop
challenge-rag-004rag_long_contextPASS-1.01679 ms$0.001043stop
challenge-if-001instruction_followingPASS-1.02762 ms$0.002342stop
challenge-if-002instruction_followingPASS-1.04824 ms$0.000597stop
challenge-if-003instruction_followingPASS-1.07849 ms$0.001185stop
challenge-zh-writing-001chinese_writingPASS-1.012315 ms$0.002218stop
challenge-zh-writing-002chinese_writingPASS-1.013800 ms$0.001904stop
challenge-coding-009codingPASS-1.012501 ms$0.002194stop
challenge-coding-010codingPASS-1.067746 ms$0.011913stop
challenge-coding-011codingPASS-1.020510 ms$0.001882stop
challenge-coding-012codingPASS-1.09677 ms$0.008444stop
challenge-coding-013codingPASS-1.06370 ms$0.005025stop
challenge-coding-014codingPASS-1.0128689 ms$0.057229stop
challenge-debugging-009debuggingPASS-1.07845 ms$0.001720stop
challenge-debugging-010debuggingPASS-1.015756 ms$0.015229stop
challenge-debugging-011debuggingPASS-1.017393 ms$0.001689stop
challenge-debugging-012debuggingPASS-1.015655 ms$0.002945stop
challenge-debugging-013debuggingPASS-1.08046 ms$0.001909stop
challenge-debugging-014debuggingPASS-1.0147960 ms$0.016785stop
challenge-reasoning-006reasoningPASS-1.09748 ms$0.001139stop
challenge-reasoning-007reasoningPASS-1.07442 ms$0.000838stop
challenge-rag-005rag_long_contextPASS-1.07054 ms$0.000924stop
challenge-rag-006rag_long_contextPASS-1.01584 ms$0.001069stop
challenge-rag-007rag_long_contextPASS-1.012231 ms$0.001041stop
challenge-if-004instruction_followingPASS-1.012745 ms$0.001151stop
challenge-if-005instruction_followingPASS-1.06700 ms$0.001344stop
challenge-zh-writing-003chinese_writingPASS-1.037430 ms$0.003049stop
challenge-reasoning-008reasoningPASS-1.09260 ms$0.001102stop
challenge-reasoning-009reasoningPASS-1.019292 ms$0.004263stop
challenge-reasoning-010reasoningPASS-1.019109 ms$0.002115stop
challenge-reasoning-011reasoningPASS-1.03002 ms$0.000891stop
challenge-reasoning-012reasoningPASS-1.04022 ms$0.000755stop
challenge-reasoning-013reasoningPASS-1.01695 ms$0.000397stop
challenge-reasoning-014reasoningPASS-1.014338 ms$0.000568stop
challenge-reasoning-015reasoningPASS-1.04531 ms$0.000956stop
challenge-reasoning-016reasoningPASS-1.016923 ms$0.003401stop
challenge-reasoning-017reasoningPASS-1.012572 ms$0.002599stop
challenge-reasoning-018reasoningPASS-1.03702 ms$0.000431stop
challenge-reasoning-019reasoningPASS-1.08793 ms$0.003541stop
challenge-reasoning-020reasoningPASS-1.02918 ms$0.001411stop
challenge-reasoning-021reasoningPASS-1.013286 ms$0.003510stop
challenge-reasoning-022reasoningPASS-1.02247 ms$0.000786stop
challenge-reasoning-023reasoningPASS-1.013009 ms$0.001253stop
challenge-reasoning-024reasoningPASS-1.01196 ms$0.000785stop
challenge-reasoning-025reasoningPASS-1.06714 ms$0.000687stop
challenge-coding-015codingPASS-1.028762 ms$0.020630stop
challenge-coding-016codingPASS-1.022860 ms$0.003040stop
challenge-coding-017codingPASS-1.052155 ms$0.004620stop
challenge-coding-018codingPASS-1.028949 ms$0.003139stop
challenge-coding-019codingPASS-1.010602 ms$0.002290stop
challenge-coding-020codingPASS-1.012352 ms$0.012264stop
challenge-coding-021codingPASS-1.08217 ms$0.002667stop
challenge-coding-022codingPASS-1.022321 ms$0.005975stop
challenge-coding-023codingPASS-1.042301 ms$0.005918stop
challenge-coding-024codingPASS-1.056991 ms$0.007424stop
challenge-coding-025codingFAILcode_execution_failure0.014357 ms$0.003066stop
challenge-coding-026codingPASS-1.0344412 ms$0.054040stop
challenge-coding-027codingPASS-1.034747 ms$0.004442stop
challenge-coding-028codingPASS-1.024932 ms$0.009566stop
challenge-rag-008rag_long_contextPASS-1.011654 ms$0.001122stop
challenge-rag-009rag_long_contextPASS-1.05610 ms$0.000647stop
challenge-rag-010rag_long_contextPASS-1.020388 ms$0.005005stop
challenge-rag-011rag_long_contextPASS-1.08632 ms$0.000798stop
challenge-rag-012rag_long_contextPASS-1.012205 ms$0.000783stop
challenge-rag-013rag_long_contextPASS-1.04335 ms$0.000645stop
challenge-rag-014rag_long_contextPASS-1.07782 ms$0.000641stop
challenge-rag-015rag_long_contextPASS-1.06501 ms$0.001077stop
challenge-rag-016rag_long_contextPASS-1.07947 ms$0.001176stop
challenge-rag-017rag_long_contextPASS-1.019879 ms$0.000911stop
challenge-rag-018rag_long_contextPASS-1.04122 ms$0.000794stop
challenge-debugging-015debuggingPASS-1.09368 ms$0.001088stop
challenge-debugging-016debuggingPASS-1.09281 ms$0.002033stop
challenge-debugging-017debuggingPASS-1.03172 ms$0.002981stop
challenge-debugging-018debuggingPASS-1.055723 ms$0.007176stop
challenge-debugging-019debuggingPASS-1.02232 ms$0.000681stop
challenge-if-006instruction_followingPASS-1.06348 ms$0.001562stop
challenge-zh-writing-004chinese_writingPASS-1.024112 ms$0.005052stop