lines = ['# comment', '[db]', ' host = localhost ', 'port=5432', '', '[feature]', 'enabled=true', 'enabled = false']
assert solution.solve(lines) == {'db': {'host': 'localhost', 'port': '5432'}, 'feature': {'enabled': 'false'}}

Prompt: 只输出 Python 代码，不要解释。实现 solve(lines: list[str]) -> dict。lines 是简化 INI：空行和以 # 开头的行忽略；[section] 开始新 section；key=value 写入当前 section；key/value 两侧空白要去掉；同一 section 内重复 key 后者覆盖前者。返回嵌套 dict。

Output:
 ```python
def solve(lines: list[str]) -> dict:
    result = {}
    section = None
    for raw in lines:
        line = raw.strip()
        if not line or line.startswith('#'):
            continue
        if line.startswith('[') and line.endswith(']'):
            section = line[1:-1].strip()
            result.setdefault(section, {})
            continue
        if '=' in line and section is not None:
            key, value = line.split('=', 1)
            result[section][key.strip()] = value.strip()
    return result
```


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

Prompt: 只输出 Python 代码，不要解释。实现 solve(events: list[str]) -> int。事件格式："<id> credit <amount>" 增加余额，"<id> debit <amount>" 减少余额，"rev <id>" 撤销此前尚未撤销过的同 id 事件。重复交易 id 只保留第一次，未知撤销忽略。返回最终余额。

Output:
```python
def solve(events: list[str]) -> int:
    balance = 0
    active = {}
    seen = set()
    for ev in events:
        parts = ev.split()
        if not parts:
            continue
        if parts[0] == "rev":
            if len(parts) != 2:
                continue
            tid = parts[1]
            if tid in active:
                balance -= active[tid]
                del active[tid]
            continue
        if len(parts) != 3:
            continue
        tid, typ, amt_str = parts
        if tid in seen:
            continue
        seen.add(tid)
        amt = int(amt_str)
        if typ == "credit":
            signed = amt
        elif typ == "debit":
            signed = -amt
        else:
            continue
        balance += signed
        active[tid] = signed
    return balance
```


deps = {'build': ['lint', 'test'], 'test': ['install'], 'lint': ['install']}
assert solution.solve(deps) == [['install'], ['lint', 'test'], ['build']]

assert solution.solve({'deploy': ['build'], 'build': []}) == [['build'], ['deploy']]

Prompt: 只输出 Python 代码，不要解释。实现 solve(deps: dict[str, list[str]]) -> list[list[str]]。deps 表示 task -> prerequisites。返回可并行执行的拓扑层，每层任务按字典序排序；如果存在环，返回空列表。所有只出现在 prerequisites 中的任务也要包含。

Output:
```python
from typing import Dict, List

def solve(deps: Dict[str, List[str]]) -> List[List[str]]:
    nodes = set(deps)
    for prereqs in deps.values():
        nodes.update(prereqs)

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

    for task, prereqs in deps.items():
        for p in prereqs:
            adj[p].append(task)
            indeg[task] += 1

    result = []
    current = sorted([node for node in nodes if indeg[node] == 0])

    while current:
        result.append(current)
        nxt = []
        for node in current:
            for nb in adj[node]:
                indeg[nb] -= 1
                if indeg[nb] == 0:
                    nxt.append(nb)
        current = sorted(nxt)

    if sum(len(layer) for layer in result) != len(nodes):
        return []

    return result
```


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]

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。

Output:
 ```python
from collections import OrderedDict

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

Traceback (most recent call last):
  File "/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-ahvjkf0e/test_solution.py", line 4, in <module>
    assert solution.solve(2, ops) == [1, -1, 1, 3]
           ^^^^^^^^^^^^^^^^^^^^^^
  File "/private/var/folders/x_/4cht1kfj1_j31gdv5w01sgmw0000gn/T/dracobench-code-ahvjkf0e/solution.py", line 14, in solve
    key = int(parts[1])
          ^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'a'


Prompt: 只输出 Python 代码，不要解释。实现 solve(base: dict, patch: dict) -> dict，执行 JSON Merge Patch：patch 中值为 None 表示删除该 key；两个值都是 dict 时递归合并；其他值覆盖。不能修改输入对象。

Output:
```python
import copy

def solve(base: dict, patch: dict) -> dict:
    result = copy.deepcopy(base)
    for key, value in patch.items():
        if value is None:
            result.pop(key, None)
        elif isinstance(value, dict) and isinstance(result.get(key), dict):
            result[key] = solve(result[key], value)
        else:
            result[key] = copy.deepcopy(value)
    return result
```


assert solution.solve('1h 30m 500ms') == 5400500

assert solution.solve('2d 1h 2s') == 176402000

assert solution.solve('100ms 2s 3ms') == 2103

Prompt: 只输出 Python 代码，不要解释。实现 solve(text: str) -> int，把时长字符串转换成毫秒。支持整数单位 d、h、m、s、ms，可有空格，单位可重复，顺序任意。例如 "1h 30m 500ms"。

Output:
```python
import re

def solve(text: str) -> int:
    units = {"d": 86400000, "h": 3600000, "m": 60000, "s": 1000, "ms": 1}
    total = 0
    for m in re.finditer(r"(\d+)\s*(ms|d|h|m|s)", text or ""):
        total += int(m.group(1)) * units[m.group(2)]
    return total
```


assert solution.solve('{a:[(1)]}') is True

assert solution.solve("{'x': '(]'}") is True

assert solution.solve("['unterminated]") is False

assert solution.solve("\"paren \\\" ) still quoted\"") is True

Prompt: 只输出 Python 代码，不要解释。实现 solve(s: str) -> bool，检查括号 ()[]{} 是否配对。单引号或双引号内部的括号忽略；反斜杠会转义引号。输入字符串可以包含普通字符。

Output:
 ```python
def solve(s: str) -> bool:
    stack = []
    quote = None
    pairs = {'(': ')', '[': ']', '{': '}'}
    i = 0
    n = len(s)
    while i < n:
        c = s[i]
        if c == '\\':
            i += 2
            continue
        if quote is None:
            if c in "'\"":
                quote = c
            elif c in pairs:
                stack.append(c)
            elif c in pairs.values():
                if not stack or pairs[stack.pop()] != c:
                    return False
        else:
            if c == quote:
                quote = None
        i += 1
    return not stack and quote is None
```


rows = [{'user':'a','ts':1,'value':'first'}, {'user':'a','ts':1,'value':'second'}]
assert solution.solve(rows) == [{'user':'a','ts':1,'value':'second'}]

Prompt: 只输出 Python 代码，不要解释。实现 solve(rows: list[dict]) -> list[dict]。每行有 user、ts、value。对每个 user 保留 ts 最大的一行；若 ts 相同，保留在输入中更靠后的行。输出按 user 字典序排序。

Output:
```python
def solve(rows: list[dict]) -> list[dict]:
    best = {}
    for i, row in enumerate(rows):
        user = row["user"]
        ts = row["ts"]
        if user not in best or ts > best[user][0]["ts"] or (ts == best[user][0]["ts"] and i > best[user][1]):
            best[user] = (row, i)
    return [row for user, (row, _) in sorted(best.items(), key=lambda x: x[0])]
```


Prompt:
下面代码在 total 之后再次读取数据会变成空列表。请指出根因，并给出最小修复。最后单独一行写 FIX: <修复后的第一行函数定义>。

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

Output:
 根因：默认参数 `items=iter([1, 2, 3])` 在函数定义时只执行一次，生成的是**同一个迭代器对象**。`sum()` 会把这个迭代器耗尽，之后再次调用默认参数时用的就是已耗尽的迭代器，所以结果为空。

最小修复：用 `None` 作为默认哨兵，每次调用时在函数内部重新创建可迭代对象。

FIX: def summarize(items=None):


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

Output:
根因：`defaultdict(lambda: shared)` 对所有缺失键都返回同一个 `shared` dict 对象，因此所有用户共享同一个 `{'seen': []}`，追加事件会互相影响。

最小修复：让默认值工厂每次返回一个新的 dict。

FIX: `counts = defaultdict(lambda: {'seen': []})`


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
```

Output:
Bug：`range` 的终止值写成了 `len(items) - page_size`，当最后一页不足 `page_size` 时，起始索引会超过该终止值，导致最后一页被跳过。切片 `items[start:start + page_size]` 本身可以安全处理末尾不足一页的情况，所以终止值应直接用 `len(items)`。

FIX: `for start in range(0, len(items), page_size):`


Prompt:
下面代码期望把数字字符串按数值排序，但结果是字典序。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def order(ids):
    return sorted(ids)
```

Output:
 bug：`sorted(ids)` 默认按字符串的字典序比较，而不是按数值大小比较。

最小修复：使用 `key=int` 把每个元素先转成整数再比较。

FIX: return sorted(ids, key=int)


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
```

Output:
Bug：`key` 只使用了函数名 `fn.__name__`，没有包含 `args` 和 `kwargs`，所以不同参数的调用会命中同一条缓存。

最小修复：把参数也加入 `key`，例如把 `args` 和 `kwargs` 转成可哈希的元组。

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


Prompt:
下面代码期望浅拷贝列表后独立追加，但原列表也被修改。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 copy 行>。

```python
def append_copy(items, value):
    copied = items
    copied.append(value)
    return copied
```

Output:
 Bug：`copied = items` 只是让 `copied` 和 `items` 指向同一个列表对象，没有创建副本，所以对 `copied` 的修改会反映到原列表上。

最小修复：使用 `list.copy()` 进行浅拷贝。

FIX: copied = items.copy()


Prompt:
下面代码期望解析 JSON 字符串，但传入已经是 dict 时会报错。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 data 赋值行>。

```python
import json

def load(payload):
    data = json.loads(payload)
    return data['id']
```

Output:
Bug：`json.loads` 只接受字符串/bytes，当 `payload` 已经是 `dict` 时会抛 `TypeError`。

最小修复：先判断类型，字符串才解析，否则直接使用。

```python
import json

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

FIX: data = json.loads(payload) if isinstance(payload, str) else payload


Answer: 删除 finally 中的 return None

Answer: 去掉 finally 的 return None

Answer: 不要在 finally 里 return None

Answer: remove return None

Answer: 去掉 finally 中的 return None

Answer: 删除或替换 finally 中的 return None

Answer: 去掉 finally 中的 `return None`

Answer: 删除或替换 finally 中的 `return None`

Answer: 删除 finally 块中的 `return None`

Answer: 删除 finally 块中的 return None

Answer: 删除 finally 中的 `return None`

Answer: 删除 `finally` 块中的 `return None`

Answer: 删除 `finally` 中的 `return None`

Answer: 删除 `finally: return None`

Answer: 将 `finally:` 中的 `return None` 删除

Answer: finally 中的 return None 删除

Answer: finally: 中的 return None 删除

Answer: 删除 finally 块中的 'return None'

Answer: 删除 finally 子句中的 `return None`

Answer: 删除 finally 子句中的 return None

Answer: delete the line `return None` inside the finally block

Answer: delete the line return None inside the finally block

Answer: finally 块不应包含 return 语句

Answer: finally 块不应包含 return

Answer: finally 不应包含 return

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

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

Output:
 bug：`finally` 块里写了 `return None`。在 Python 中，如果 `finally` 执行了 `return`，它会覆盖 `try` 中待返回的值，所以函数总是返回 `None`。

最小修复：去掉 `finally` 里的 `return None`，让它只做清理而不返回值；如果不需要清理，也可以直接删掉整个 `finally`。

FIX: 删除 finally 子句中的 `return None`（或删除整个 `finally`）


Answer: 125

Prompt: 只回答最终数字：有 A、B、C、D 四个服务。A 每分钟处理 6 个请求，B 比 A 少 2 个，C 是 B 的 2 倍，D 是 A 和 C 的平均值。四个服务 5 分钟一共处理多少请求？

Output: 125


Answer: D

Prompt: 只回答一个字母：五个任务 A、B、C、D、E 排队。A 必须在 B 前，B 必须在 C 前；D 不能在两端；E 必须紧挨在 C 后面。在所有满足条件的队列中，按字典序最小的队列第三个任务是谁？

Output: D


Answer: 0

Prompt: 只回答最终数字：一个 4 位二进制数从 1011 开始，先左移一位并只保留低 4 位，再与 0110 做异或，最后转成十进制。结果是多少？

Output: 0


Answer: 18

Prompt: 只回答最终数字：一个集合最初为 {1,2,3,4,5}。依次执行：删除所有偶数；加入 6 和 7；把每个元素乘以 2；删除大于 10 的元素。最终集合元素之和是多少？

Output: 18


Answer: 可满足

Prompt: 只回答“可满足”或“不可满足”：有三个布尔变量 x、y、z。约束为：x 或 y 为真；如果 x 为真则 z 为假；如果 y 为真则 z 为真；x 和 y 不能同时为真。是否存在赋值满足全部约束？

Output: 可满足


默认使用 默认判分 默认采用 作为默认判分

因为成本太高 因为不支持中文

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 作为默认判分？

Output: 根据资料 B，v0.2 不默认使用 LLM-as-judge，但资料中并未说明具体原因，只提到开放中文写作题采用少量规则校验和人工抽检。


Beta 成本 延迟 判断

Alpha 更适合
多模态更强

Prompt:
只根据资料回答，不要自行补充。

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

问题：如果要写低成本高吞吐摘要服务，资料更支持选择哪个模型？另外，多模态表现能否判断？

Output:
资料更支持选择 **Beta**：成本低（0.02 美元 vs 0.08 美元）、延迟低（3 秒 vs 9 秒），更适合低成本高吞吐场景；通过率虽略低（22 vs 24），但资料未说明这与摘要任务的实际质量直接相关。

多模态表现**无法判断**，因为资料没有给出两者在多模态任务上的表现。


空输出 输出为空 未输出

Prompt:
只根据资料回答。

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

问题：更公平的文字结论应该如何描述 K 模型这次 hard set 表现？

Output:
 更公平的描述是：

K 模型在 hard set 上的有效成绩应为 **49/50（98%）**。原始 47/50 中，有 2 题因题面歧义经单独复测通过；另有 1 题因 reasoning tokens 用尽而空输出，应视为未通过。因此，唯一未通过的题目是 token 限制导致的，而非解题能力问题。


Prompt:
只根据资料回答，不要使用资料外知识。

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

问题：根据资料，能否从报告判断供应商利润率？

Output: 不能。报告不包含供应商真实利润率，因此无法从报告中判断供应商利润率。


Prompt: 只输出 JSON 对象，不要 Markdown。字段 status 必须是 "review"；字段 scores 必须是对象，包含 coding、debugging、rag 三个整数；字段 note 必须是不超过 12 个汉字的中文字符串。

Output: {"status": "review", "scores": {"coding": 85, "debugging": 78, "rag": 82}, "note": "表现良好，需复查。"}


Prompt: 只输出 4 行，不要解释。第 1 行是 BEGIN，第 4 行是 END。第 2 行必须包含“模型评测”，第 3 行必须包含“HTML报告”。不能出现任何项目符号。

Output:
BEGIN
模型评测结果如下
HTML报告已生成
END


Prompt: 只输出一个中文句子，不能超过 28 个汉字。必须同时包含“难题”和“区分度”，不能包含“最强”“吊打”“遥遥领先”。

Output: 这道难题的区分度很高，能拉开考生水平。


简单题 真实能力 失败样例

Prompt: 写一段不超过 120 个汉字的公众号结论，主题是“模型在简单题满分不代表真实强”。必须包含“简单题”“真实能力”“失败样例”，不能出现“吊打”。

Output: 简单题满分只是基础，不等于模型真实能力过硬。一旦遇到复杂场景，失败样例便会暴露其推理短板。评价模型，不能只看满分，更要关注真实能力。


Prompt: 把下面口语句改写成专业表达，不超过 80 个汉字：这个模型看起来很猛，但一遇到复杂调试就开始掉链子。必须包含“复杂调试”和“稳定性”，不能包含“猛”“掉链子”。

Output: 该模型在常规场景下表现优异，但在复杂调试中稳定性不足。


assert solution.solve([{'user':'x','type':'remove','amount':'2'}]) == {'x': -2}

Prompt: 只输出 Python 代码，不要解释。实现 solve(events: list[dict]) -> dict[str, int]。每个事件包含 user、type、amount；type 为 "add" 或 "remove"。按 user 汇总 add 减 remove 后的库存，结果中去掉库存为 0 的用户，按 key 字典序返回普通 dict。amount 可能是字符串数字。

Output:
```python
from collections import defaultdict

def solve(events: list[dict]) -> dict[str, int]:
    inventory = defaultdict(int)
    for event in events:
        user = event["user"]
        amount = int(event["amount"])
        if event["type"] == "add":
            inventory[user] += amount
        else:
            inventory[user] -= amount
    return dict(sorted((k, v) for k, v in inventory.items() if v != 0))
```


assert solution.solve('10 - (2 + 3) + 4') == 9

Prompt: 只输出 Python 代码，不要解释。实现 solve(expr: str) -> int。expr 只包含非负整数、+、-、空格和括号，计算表达式结果。不要使用 eval。

Output:
```python
def solve(expr: str) -> int:
    s = expr
    n = len(s)
    i = 0

    def parse_expr():
        nonlocal i
        val = parse_term()
        while i < n and s[i].isspace():
            i += 1
        while i < n and s[i] in '+-':
            op = s[i]
            i += 1
            rhs = parse_term()
            val = val + rhs if op == '+' else val - rhs
            while i < n and s[i].isspace():
                i += 1
        return val

    def parse_term():
        nonlocal i
        while i < n and s[i].isspace():
            i += 1
        sign = 1
        while i < n and s[i] in '+-':
            if s[i] == '-':
                sign = -sign
            i += 1
            while i < n and s[i].isspace():
                i += 1
        while i < n and s[i].isspace():
            i += 1
        if i < n and s[i] == '(':
            i += 1
            val = parse_expr()
            while i < n and s[i].isspace():
                i += 1
            if i < n and s[i] == ')':
                i += 1
        else:
            val = 0
            while i < n and s[i].isdigit():
                val = val * 10 + (ord(s[i]) - 48)
                i += 1
        return sign * val

    return parse_expr()
```


Prompt: 只输出 Python 代码，不要解释。实现 solve(rows: list[str]) -> list[tuple[str, int]]。每行格式为 "name score"，空白数量不定；同名保留最高分；输出按分数降序、同分按 name 升序。忽略空行。

Output:
```python
def solve(rows: list[str]) -> list[tuple[str, int]]:
    best: dict[str, int] = {}
    for line in rows:
        parts = line.split()
        if not parts:
            continue
        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]))
```


assert solution.solve('a*b?d', 'axxxbc d'.replace(' ','')) is True

assert solution.solve('a*c', 'ab') is False

assert solution.solve('file-??.txt', 'file-ab.txt') is True

Prompt: 只输出 Python 代码，不要解释。实现 solve(pattern: str, text: str) -> bool。pattern 支持 ? 匹配任意单字符，* 匹配任意长度字符串。必须匹配完整 text。

Output:
 ```python
def solve(pattern: str, text: str) -> bool:
    m, n = len(pattern), len(text)
    dp = [[False] * (n + 1) for _ in range(m + 1)]
    dp[0][0] = True
    for i in range(1, m + 1):
        if pattern[i - 1] == '*':
            dp[i][0] = dp[i - 1][0]
        for j in range(1, n + 1):
            p = pattern[i - 1]
            if p == '*':
                dp[i][j] = dp[i - 1][j] or dp[i][j - 1]
            elif p == '?' or p == text[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
    return dp[m][n]
```


Prompt: 只输出 Python 代码，不要解释。实现 solve(tree: dict) -> list[str]。tree 是嵌套字典，叶子是字符串或数字。返回所有叶子的路径，路径用点连接，按字典序排序。例如 {'a': {'b': 1}} -> ['a.b=1']。

Output:
```python
def solve(tree: dict) -> list[str]:
    out = []

    def dfs(node, path):
        for k, v in node.items():
            cur = f"{path}.{k}" if path else k
            if isinstance(v, dict):
                dfs(v, cur)
            else:
                out.append(f"{cur}={v}")

    dfs(tree, "")
    return sorted(out)
```


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

Prompt: 只输出 Python 代码，不要解释。实现 solve(nums: list[int]) -> int。返回删除恰好一个元素后，剩余数组的最大连续子数组和。nums 长度至少为 2，可以全为负数。

Output:
 ```python
def solve(nums: list[int]) -> int:
    n = len(nums)
    left_end = [0] * n
    left_best = [0] * n
    left_end[0] = left_best[0] = nums[0]
    for i in range(1, n):
        left_end[i] = max(nums[i], left_end[i - 1] + nums[i])
        left_best[i] = max(left_best[i - 1], left_end[i])

    right_start = [0] * n
    right_best = [0] * n
    right_start[-1] = right_best[-1] = nums[-1]
    for i in range(n - 2, -1, -1):
        right_start[i] = max(nums[i], right_start[i + 1] + nums[i])
        right_best[i] = max(right_best[i + 1], right_start[i])

    ans = float('-inf')
    for i in range(n):
        cur = float('-inf')
        if i > 0:
            cur = max(cur, left_best[i - 1])
        if i + 1 < n:
            cur = max(cur, right_best[i + 1])
        if i > 0 and i + 1 < n:
            cur = max(cur, left_end[i - 1] + right_start[i + 1])
        ans = max(ans, cur)
    return ans
```


Prompt:
下面代码期望把输入按逗号拆分并去掉空白，但会把空字段也保留下来。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def parse(s):
    return [part.strip() for part in s.split(',')]
```

Output:
Bug：`s.split(',')` 在输入为空或包含连续逗号时会产生空字符串，`part.strip()` 后仍是空字符串，但列表推导式没有过滤掉它们。

最小修复：在推导式中加入 `if part.strip()` 条件。

FIX: return [part.strip() for part in s.split(',') if part.strip()]


Answer: datetime.fromisoformat

Answer: dateutil.parser

Answer: 解析 ts 后排序

Answer: parse ts

Answer: fromisoformat

Answer: int(r['ts'])

Answer: float(r['ts'])

Answer: key=lambda r: int(r['ts'])

Answer: key=lambda r: float(r['ts'])

Prompt:
下面代码期望用 UTC 时间戳排序，但字符串排序会错。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 sort 行>。

```python
rows.sort(key=lambda r: r['ts'])
```

Output:
 Bug：`r['ts']` 是字符串，按字符串字典序排序不能保证时间先后顺序（例如格式不一致、时区不同、缺零补位时都会出错）。

最小修复：把字符串解析成 `datetime` 对象再排序。

FIX: `rows.sort(key=lambda r: datetime.fromisoformat(r['ts'].replace('Z', '+00:00')))`


Prompt:
下面代码在输入包含 0 时会误判为默认值 10。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 limit 赋值行>。

```python
def query(limit=None):
    limit = limit or 10
    return list(range(limit))
```

Output:
bug 在于 `limit or 10` 会把所有“假值”都当成未传参，包括合法的 `0`。

最小修复是仅在 `limit` 为 `None` 时才使用默认值：

```python
def query(limit=None):
    limit = 10 if limit is None else limit
    return list(range(limit))
```

FIX: limit = 10 if limit is None else limit


Prompt:
下面代码期望复制嵌套配置后修改副本，但原配置也被修改。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 copied 赋值行>。

```python
def update(config):
    copied = dict(config)
    copied['db']['host'] = 'localhost'
    return copied
```

Output:
bug：`dict(config)` 只是浅拷贝，嵌套的 `config['db']` 字典仍被原配置和副本共享，所以修改副本里的嵌套字段会改到原配置。

最小修复：使用深拷贝。

FIX: `copied = copy.deepcopy(config)`


Prompt:
下面代码期望找到第一个匹配项，但找不到时会抛 StopIteration。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def find_user(users, name):
    return next(u for u in users if u['name'] == name)
```

Output:
Bug：`next()` 在迭代器耗尽且没有提供默认值时会抛出 `StopIteration`。

最小修复：给 `next()` 加上默认值 `None`，并把生成器表达式用括号括起来。

FIX: return next((u for u in users if u['name'] == name), None)


Prompt:
下面代码期望按请求顺序记录日志，但默认参数导致多次调用共用同一个列表。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的函数定义行>。

```python
def log_request(req, logs=[]):
    logs.append(req['id'])
    return logs
```

Output:
 bug：Python 的默认参数在函数定义时求值，`logs=[]` 会让所有调用共享同一个列表对象，导致多次调用的记录互相污染。

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

FIX: def log_request(req, logs=None): logs = [] if logs is None else logs; logs.append(req['id']); return logs


Answer: 3

Prompt: 只回答最终数字：一个队列从左到右是 A,B,C,D,E。依次执行：把第 2 个移到末尾；删除第 3 个；在最前面插入 X；把最后两个反转。最终队列中 C 的位置是第几位？

Output: 3


Answer: 120

Prompt: 只回答最终数字：某缓存命中率从 60% 提升到 75%。如果总请求数为 800，未命中请求减少了多少个？

Output: 120


Prompt:
只根据资料回答。

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

问题：如果文章讨论“模型真实能力”，应该优先引用哪个模式？如果讨论“低预算可用性”，应该优先引用哪个模式？

Output:
 - 讨论“模型真实能力”：优先引用 **ability mode**（46/50，成本 0.12 美元）。
- 讨论“低预算可用性”：优先引用 **efficiency mode**（34/50，成本 0.04 美元）。


类型假设
假设 key 为整数
假设 key 是整数
key 为整数类型

Prompt:
只根据资料回答。

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

问题：这次失败的根因是什么？

Output: 根因是模型**擅自补充了类型假设**：它把 `key` 假设为整数并写成 `int(parts[1])`，但测试数据中的 `key` 实际是字符串（`a`、`b`、`c`）。


已经支持 折线图 柱状图

Prompt:
只根据资料回答，不要自行补充。

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

问题：报告是否已经支持图表？回答时说明依据。

Output: 根据资料，无法确认报告支持图表。依据是资料仅提到 HTML 报告展示 Summary、By Suite、Failure Examples 和 Case Details，并未提及图表功能。


Prompt: 只输出 JSON 对象。字段 mode 必须是 "ability"；字段 limits 必须是对象，包含 max_tokens:4096 和 temperature:0；字段 warnings 必须是正好两个字符串组成的数组。不要 Markdown。

Output: {"mode": "ability", "limits": {"max_tokens": 4096, "temperature": 0}, "warnings": ["warning one", "warning two"]}


Prompt: 只输出 Markdown 表格，必须有 3 列：模式、用途、风险。必须包含 ability mode 和 efficiency mode 两行。不能添加表格外说明。

Output:
 | 模式 | 用途 | 风险 |
|---|---|---|
| ability mode | 发挥最大能力处理复杂任务 | 可能产生过度自信或冗长输出 |
| efficiency mode | 快速生成简洁回答以节省资源 | 可能简化过度导致信息丢失 |


Prompt: 写一段不超过 140 个汉字的公众号小结，主题是“为什么要同时展示原题、模型输出和错误解释”。必须包含“原题”“错误解释”“可复查”，不能出现“玄学”。

Output: 同时展示原题、模型输出与错误解释，能让读者对照真实输入与输出，看清问题所在；错误解释说明误判原因，便于定位根因；三者并列，结论可复查，避免空口无凭。


Answer: 15

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 等于多少？

Output: 15


Answer: B

Prompt: 只回答一个字母：任务 A、B、C、D、E、F 排列。C 必须紧挨在 A 后面；B 必须在 D 前；D 必须在 F 前；F 必须最后；E 不能第一。在所有满足条件的排列中字典序最小的排列，第三个任务是谁？

Output: B


Answer: 可满足

Prompt: 只回答“可满足”或“不可满足”：布尔变量 x、y、z 满足：x 和 y 恰好一个为真；如果 x 为真则 z 为真；如果 y 为真则 z 为假；z 为真。是否存在赋值满足全部约束？

Output: 可满足


Answer: 20

Prompt: 只回答最终数字：列表 [2,4,6,8] 中每个数先减去它的位置编号（从 1 开始），然后删除所有奇数，再把剩余数平方，最后求和。结果是多少？

Output: 20


Answer: 12

Prompt: 只回答最终数字：一个 5 位二进制数 10110 先循环右移 1 位，再与 00111 做异或，最后转成十进制。结果是多少？

Output: 12


Answer: C

Prompt: 只回答一个字母：模型 A 通过 18 题、成本 0.06；模型 B 通过 20 题、成本 0.10；模型 C 通过 16 题、成本 0.04。按“通过题数/成本”最高选择，应该选哪个模型？

Output: C


Answer: 5

Prompt: 只回答最终数字：同一套 100 道题中，失败题数从 12 降到 7。错误率降低了多少个百分点？

Output: 5


Answer: 3

Prompt: 只回答最终数字：集合 S 初始为 {a,b,c,d}。删除字母序在 c 之前的元素；加入 e 和 b；再删除所有元音字母。最终集合有几个元素？

Output: 3


Answer: 15

Prompt: 只回答最终数字：3x3 矩阵按行是 1 2 3 / 4 5 6 / 7 8 9。顺时针旋转 90 度后，第二行元素之和是多少？

Output: 15


Answer: 3

Prompt: 只回答最终数字：依赖关系为 a 无依赖；b 依赖 a；c 依赖 a；d 依赖 b 和 c；e 依赖 b；f 依赖 d 和 e；g 依赖 a。按可并行执行的拓扑层划分，第二层有几个任务？

Output: 2


Answer: 星期五

Prompt: 只回答星期几：第 0 天是星期二。每 7 天循环一次。第 17 天是星期几？

Output: 星期五


Answer: 8

Prompt: 只回答最终数字：用 A、B、C 组成长度为 3 的字符串，要求恰好包含一个 A，并且最后一个字符不能是 C。满足条件的字符串有多少个？

Output: 8


Answer: -2

Prompt: 只回答最终数字：栈操作从空栈开始。push n 表示入栈；dup 复制栈顶；add 弹出两个数并压入它们的和；swap 交换栈顶两个数；sub 先弹出 x 再弹出 y，并压入 y-x。依次执行：push 2, push 3, dup, add, push 4, swap, sub。最终栈顶是多少？

Output: -2


Answer: 4

Prompt: 只回答最终数字：三个队列 Q1、Q2、Q3 初始长度分别为 2、1、0。每一轮先从所有非空队列各处理 1 个元素，然后向 Q3 加入 2 个元素。执行 3 轮后，三个队列总长度是多少？

Output: 4


Answer: 8

Prompt: 只回答最终数字：映射初始为 {a:1, b:2}。依次执行：设置 c=a+b；设置 a=c-b；删除 b；设置 d=a+c。最终所有 value 之和是多少？

Output: 8


Answer: 丙

Prompt: 只回答“甲”“乙”或“丙”：甲说“乙说的是真话”；乙说“丙说的是假话”；丙说“甲说的是假话”。如果恰好一人说真话，说真话的人是谁？

Output: 丙


Answer: A

Prompt: 只回答一个字母：综合分 = 通过率百分数 - 成本乘以 10。模型 A 通过率 92%、成本 0.20；模型 B 通过率 88%、成本 0.05；模型 C 通过率 90%、成本 0.10。综合分最高的是哪个模型？

Output: A


Answer: 463

Prompt: 只回答最终三位数：一个三位数的百位为 a、十位为 b、个位为 c。已知 a+b+c=13，a=c+1，b=2c。这个三位数是多少？

Output: 463


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

Prompt: 只输出 Python 代码，不要解释。实现 solve(line: str) -> list[str]，解析一行简化 CSV：逗号分隔；字段可以用双引号包裹；引号内逗号保留；引号内两个连续双引号表示一个双引号；空字段保留；空格是普通字符，不要自动 trim。

Output:
```python
def solve(line: str) -> list[str]:
    res: list[str] = []
    cur: list[str] = []
    in_quote = False
    i = 0
    n = len(line)

    while i < n:
        if in_quote:
            if line[i] == '"':
                if i + 1 < n and line[i + 1] == '"':
                    cur.append('"')
                    i += 2
                else:
                    in_quote = False
                    i += 1
            else:
                cur.append(line[i])
                i += 1
        else:
            if line[i] == '"':
                in_quote = True
                i += 1
            elif line[i] == ',':
                res.append(''.join(cur))
                cur = []
                i += 1
            else:
                cur.append(line[i])
                i += 1

    res.append(''.join(cur))
    return res
```


Prompt: 只输出 Python 代码，不要解释。实现 solve(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]。intervals 是整数闭区间，先按起点排序；重叠或端点相邻的区间要合并，例如 [1,2] 和 [3,4] 合并为 [1,4]。

Output:
```python
def solve(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
    if not intervals:
        return []
    intervals = sorted(intervals, key=lambda x: x[0])
    merged = [intervals[0]]
    for s, e in intervals[1:]:
        last_s, last_e = merged[-1]
        if s <= last_e + 1:
            merged[-1] = (last_s, max(last_e, e))
        else:
            merged.append((s, e))
    return merged
```


events=[('a',1),('a',2),('a',3),('a',4),('a',8)]
assert solution.solve(events, 5, 2) == [True, True, False, False, True]

Prompt: 只输出 Python 代码，不要解释。实现 solve(events: list[tuple[str, int]], window: int, limit: int) -> list[bool]，模拟按用户限流。events 按时间非降序排列。某用户在当前事件时间 ts 的窗口 (ts-window, ts] 内，已放行事件数少于 limit 才放行；被拒绝的事件不计入窗口。

Output:
```python
from collections import deque

def solve(events: list[tuple[str, int]], window: int, limit: int) -> list[bool]:
    user_windows: dict[str, deque[int]] = {}
    res: list[bool] = []
    for user, ts in events:
        q = user_windows.setdefault(user, deque())
        while q and q[0] <= ts - window:
            q.popleft()
        if len(q) < limit:
            q.append(ts)
            res.append(True)
        else:
            res.append(False)
    return res
```


assert solution.solve('/a//b/./c/../') == '/a/b'

assert solution.solve('/../../x') == '/x'

Prompt: 只输出 Python 代码，不要解释。实现 solve(path: str) -> str，规范化绝对 Unix 路径：处理重复斜杠、.、..；.. 在根目录时仍留在根目录；返回结果必须以 / 开头且除根目录外不能以 / 结尾。不要使用 os.path。

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


assert solution.solve(['eat','tea','tan','ate','nat','bat']) == [['eat','tea','ate'], ['tan','nat'], ['bat']]

Prompt: 只输出 Python 代码，不要解释。实现 solve(words: list[str]) -> list[list[str]]，按变位词分组。大小写敏感；组内保持输入顺序；组的顺序按该组第一个单词在输入中出现的位置。

Output:
```python
from collections import defaultdict

def solve(words: list[str]) -> list[list[str]]:
    groups = defaultdict(list)
    for word in words:
        key = tuple(sorted(word))
        groups[key].append(word)
    return list(groups.values())
```


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') == {}

Prompt: 只输出 Python 代码，不要解释。实现 solve(text: str) -> dict，解析 Markdown front matter。只有第一行正好是 --- 时才解析，直到下一行 --- 结束；每行 key: value，key 和 value 两侧 trim；形如 [a, b] 的 value 返回字符串列表；其他 value 返回字符串。没有完整 front matter 返回 {}。

Output:
```python
def solve(text: str) -> dict:
    lines = text.splitlines()
    if not lines or lines[0] != '---':
        return {}
    result = {}
    for i in range(1, len(lines)):
        line = lines[i]
        if line == '---':
            return result
        if ':' not in line:
            continue
        key, _, value = line.partition(':')
        key = key.strip()
        value = value.strip()
        if value.startswith('[') and value.endswith(']'):
            result[key] = [x.strip() for x in value[1:-1].split(',') if x.strip() != '']
        else:
            result[key] = value
    return {}
```


assert solution.solve(['a'], 5) == ['a']

Prompt: 只输出 Python 代码，不要解释。实现 solve(items: list[str], k: int) -> list[str]，返回出现次数最高的前 k 个元素；次数相同按第一次出现的先后排序；k 大于不同元素数量时返回全部。

Output:
 ```python
from collections import Counter

def solve(items: list[str], k: int) -> list[str]:
    return [x for x, _ in Counter(items).most_common(k)]
```


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

Prompt: 只输出 Python 代码，不要解释。实现 solve(config: dict, overrides: dict[str, object]) -> dict。overrides 的 key 是点号路径；值为 None 表示删除该路径的叶子 key；其他值写入路径，必要时创建中间 dict；不能修改输入 config。

Output:
 ```python
import copy
from typing import Any, Dict

def solve(config: Dict[str, Any], overrides: Dict[str, Any]) -> Dict[str, Any]:
    result = copy.deepcopy(config)

    for path, value in overrides.items():
        parts = path.split(".")
        if not parts:
            continue

        current = result
        for part in parts[:-1]:
            if part not in current or not isinstance(current[part], dict):
                current[part] = {}
            current = current[part]

        leaf = parts[-1]
        if value is None:
            if isinstance(current, dict) and leaf in current:
                del current[leaf]
        else:
            current[leaf] = value

    return result
```


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']}

Prompt: 只输出 Python 代码，不要解释。实现 solve(query: str) -> dict[str, list[str]]，解析 URL query string。& 分隔参数；没有 = 的参数值为空字符串；+ 表示空格；%XX 需要按 UTF-8 百分号解码；同名 key 保留所有值的列表。可以使用标准库。

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 "=" in part:
            key, value = part.split("=", 1)
        else:
            key, value = part, ""
        key = unquote_plus(key, encoding="utf-8")
        value = unquote_plus(value, encoding="utf-8")
        result.setdefault(key, []).append(value)
    return result
```


Prompt:
只输出 Python 代码，不要解释。实现 solve(html: str) -> bool，校验简化 HTML 标签是否配对。标签形如 、、
，标签名只含小写字母；自闭合标签不入栈；普通文本忽略。

Output:
```python
import re

def solve(html: str) -> bool:
    stack = []
    for m in re.finditer(r'<(/?)([a-z]+)(/?)>', html):
        slash_open, name, slash_close = m.groups()
        if slash_close:
            continue
        if slash_open:
            if not stack or stack[-1] != name:
                return False
            stack.pop()
        else:
            stack.append(name)
    return not stack
```


assert solution.solve(['S#','##','E.']) == -1

Prompt: 只输出 Python 代码，不要解释。实现 solve(grid: list[str]) -> int。grid 中 S 是起点，E 是终点，# 是墙，. 可走。每步上下左右移动一格，返回从 S 到 E 的最短步数；不可达返回 -1。

Output:
```python
from collections import deque

def solve(grid: list[str]) -> int:
    if not grid:
        return -1
    n = len(grid)
    m = len(grid[0])
    sr = sc = er = ec = -1
    for i in range(n):
        for j, ch in enumerate(grid[i]):
            if ch == 'S':
                sr, sc = i, j
            elif ch == 'E':
                er, ec = i, j
    if sr == -1 or er == -1:
        return -1
    q = deque([(sr, sc, 0)])
    visited = {(sr, sc)}
    dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    while q:
        r, c, d = q.popleft()
        if r == er and c == ec:
            return d
        for dr, dc in dirs:
            nr, nc = r + dr, c + dc
            if 0 <= nr < n and 0 <= nc < m and (nr, nc) not in visited and grid[nr][nc] != '#':
                visited.add((nr, nc))
                q.append((nr, nc, d + 1))
    return -1
```


Prompt: 只输出 Python 代码，不要解释。实现 solve(nums: list[int], k: int) -> list[float]，返回每个长度为 k 的滑动窗口中位数。k 为奇数时返回中间值；k 为偶数时返回两个中间值平均数。

Output:
```python
import bisect

def solve(nums: list[int], k: int) -> list[float]:
    if k <= 0 or k > len(nums):
        return []
    sl = []
    res = []
    for i, v in enumerate(nums):
        bisect.insort(sl, v)
        if i >= k:
            out = nums[i - k]
            idx = bisect.bisect_left(sl, out)
            sl.pop(idx)
        if i >= k - 1:
            if k % 2 == 1:
                res.append(float(sl[k // 2]))
            else:
                res.append((sl[k // 2 - 1] + sl[k // 2]) / 2.0)
    return res
```


Prompt: 只输出 Python 代码，不要解释。实现 solve(versions: list[str]) -> list[str]，按简化语义版本排序。版本为 major.minor.patch 或 major.minor.patch-label；major/minor/patch 按数字比较；同一数字版本下，带 label 的预发布版本低于正式版本；label 按字典序比较。

Output:
 ```python
def solve(versions: list[str]) -> list[str]:
    def key(v: str):
        num, _, label = v.partition('-')
        major, minor, patch = num.split('.')
        return (int(major), int(minor), int(patch), 0 if label else 1, label)
    return sorted(versions, key=key)
```


deps={'app':['lib','ui'],'ui':['core'],'lib':['core'],'core':[],'docs':[]}
assert solution.solve(deps, ['core']) == ['app','core','lib','ui']

Prompt: 只输出 Python 代码，不要解释。实现 solve(deps: dict[str, list[str]], changed: list[str]) -> list[str]。deps 表示 package -> 直接依赖。返回所有 changed 包，以及直接或间接依赖 changed 包的包，按字典序排序；只出现在依赖列表中的包也要能作为 changed 包返回。

Output:
```python
def solve(deps: dict[str, list[str]], changed: list[str]) -> list[str]:
    reverse = {}
    for pkg, dep_list in deps.items():
        for dep in dep_list:
            reverse.setdefault(dep, []).append(pkg)

    stack = list(changed)
    result = set(changed)

    while stack:
        cur = stack.pop()
        for parent in reverse.get(cur, []):
            if parent not in result:
                result.add(parent)
                stack.append(parent)

    return sorted(result)
```


不跑 不要立刻 先不跑 不应立刻 不应该立刻 不应立即 不应该立即 不应立刻跑 不应该立刻跑 不应立即跑 不应该立即跑

Prompt:
只根据资料回答。

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

问题：下一步应该新增多少题？是否应该立刻跑模型？

Output:
 根据资料 B，下一步应新增 **50 道题**（v0.3-challenge100，在现有 50 题基础上新增 50 题）。

根据资料 C，**不应该立刻跑模型**。新增题应先生成审题 HTML，确认后再跑模型，避免立即消耗 API。


没有包含 没有提供 资料没有 未包含

Prompt:
只根据资料回答，不要自行补充。

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

问题：能否根据这份报告判断用户满意度？

Output: 不能。这份报告没有包含用户满意度调查或相关反馈数据，无法据此判断用户满意度。


Prompt:
只根据资料回答。

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

问题：如果要选低延迟且稳定的生产摘要模型，资料更支持选择哪个？

Output:
 资料更支持选择 **模型 B**。

理由：
- **低延迟**：模型 B 平均延迟仅 **4 秒**，远低于 A（20 秒）和 C（9 秒）。
- **稳定**：模型 B **没有超时失败**，而模型 C 有 3 次 API 超时；模型 A 虽也无超时，但延迟过高。

虽然模型 B 的通过率（44/50）略低于 A（48/50）和 C（46/50），但在“低延迟且稳定”这两个核心要求上，B 表现最佳。


不扣分 不会 不会因长度 不会因此被扣分 不会直接导致扣分 不会导致扣分 不会导致失败或扣分

Prompt:
只根据资料回答。

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

问题：如果答案超过 max_chars，但 required 都满足且没有 forbidden，会因为长度直接扣分吗？

Output: 不会。长度只作为诊断信息记录，length_scored 为 false，因此仅超过 max_chars 不会导致失败或扣分。


45/50 更合适
原始结果为准

Prompt:
只根据资料回答。

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

问题：写文章引用总览结果时，应写 45/50 还是 46/50？

Output: 应写 **46/50**。因为总览 index 使用 rescored JSONL 作为展示结果。


Prompt:
只根据资料回答。

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

问题：复现评测主要应该依赖哪些记录字段？

Output: 复现评测主要应依赖这些记录字段：**model、case_id、prompt_hash、parameters、scorer details、output、latency_ms、usage**。


Prompt:
只根据资料回答。

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

问题：当前总览页对应的 token limit 是多少？

Output:
 当前总览页对应的 token limit 是 **16384**。

依据资料 C：当前总览页只展示 “ability16384” 的结果。


rag-006 规则 评分规则 同义表达

Prompt:
只根据资料回答。

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

问题：哪类失败更需要人工复查评分规则？回答时也说明 coding-004 是否属于这种情况。

Output:
 更需要人工复查评分规则的是 **因评分规则本身不完善导致的失败**（例如规则未覆盖同义表达、类型表述等语义等价情况）。

`coding-004` **不属于**这种情况。它的失败是代码运行时的 `ValueError`，根因是代码实现中把字符串 key 强制转为 int，属于代码/实现错误，而不是评分规则的问题。


Prompt:
只根据资料回答。

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

问题：能否从 usage 字段判断供应商利润率？

Output: 不能。usage 字段只包含 token 数量和 cost，但资料中说明没有供应商的真实利润率和内部成本。利润率需要知道成本与收入/利润的关系，仅凭 usage 字段无法判断。


不应该 不展示 未展示 不显示 均不显示 不应展示

Prompt:
只根据资料回答。

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

问题：index 页是否应该展示旧版本结果？当前展示范围是什么？

Output:
根据资料：

- **index 页不应该展示旧版本结果**。
- **当前展示范围**：只显示最后这版 50 道题的 **v0.2-challenge50** 结果，并且 token limit 统一为 **ability16384**。之前的版本和 ability4096 结果不显示。


Prompt:
只根据资料回答。

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

问题：这次失败应如何归因？

Output: 应归因于**输出截断（length 限制）**，即模型生成被截断，未能输出完整的可执行 `solve` 函数，而不是算法逻辑错误。


Prompt:
下面代码期望 funcs[0]()、funcs[1]()、funcs[2]() 分别返回 0、1、2，但实际都会返回 2。请指出根因，并给出最小修复。最后单独一行写 FIX: <修复后的 append 行>。

```python
funcs = []
for i in range(3):
    funcs.append(lambda: i)
```

Output:
根因：Python 的闭包按**变量名**捕获，而不是按值。循环结束后 `i` 的值为 2，所以所有 lambda 执行时读取到的都是同一个 `i` 的最终值。

最小修复：利用默认参数在定义时求值的特性，把当前 `i` 绑定到 lambda 的参数默认值上。

FIX: `funcs.append(lambda i=i: i)`


Prompt:
下面 context manager 期望异常继续向外抛出，但实际异常被吞掉。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
class Span:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc, tb):
        return True
```

Output:
 Bug：`__exit__` 返回 `True` 会告诉 Python 吞掉上下文内抛出的异常；要让它继续向外抛出，应返回 `False`（或 `None`）。

FIX: return False


Prompt:
下面代码期望每个 Bag 实例都有独立列表，但不同实例会共享 items。请指出 bug，并给出最小修复。最后单独一行写 FIX: <新增到 __init__ 中的赋值行>。

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

Output:
bug：`items = []` 是类属性，只创建一次，所有 `Bag` 实例共享同一个列表。`self.items.append` 因为没有给实例赋值，实际访问的是这个类属性。

最小修复：在 `__init__` 中为每个实例创建独立列表。

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

FIX: self.items = []


Prompt:
下面代码期望每次不传 ts 时使用当前时间，但默认时间只会在函数定义时计算一次。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的函数定义行>。

```python
from datetime import datetime

def mark(ts=datetime.utcnow()):
    return ts.isoformat()
```

Output:
bug：`datetime.utcnow()` 作为默认参数只在函数定义时求值一次，所以之后每次不传 `ts` 都会返回同一个时间。

最小修复：把默认值改为 `None`，在函数内部再计算当前时间。

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


Prompt:
下面代码期望返回小写字符串，但实际返回的是方法对象。请指出 bug，并给出最小修复。最后单独一行写 FIX: <修复后的 return 行>。

```python
def normalize(s):
    return s.strip().lower
```

Output:
bug：`s.strip().lower` 后面缺少括号，返回的是 `lower` 方法对象本身，而不是调用后的结果。

最小修复：在 `lower` 后加 `()` 以调用方法。

FIX: `return s.strip().lower()`


Prompt: 只输出 JSON 对象，不要 Markdown。字段 version 必须是 "v0.3"；字段 ready 必须是 true；字段 cases 必须是正好两个对象组成的数组。cases 中每个对象只能包含 id、weight、active 三个字段；id 是字符串且匹配 case-1 或 case-2；weight 是整数；active 是布尔值。

Output: {"version": "v0.3", "ready": true, "cases": [{"id": "case-1", "weight": 1, "active": true}, {"id": "case-2", "weight": 1, "active": true}]}


推理题 边界条件 人工复查

Prompt: 写一段不超过 160 个汉字的公众号小结，主题是“为什么 v0.3 要扩到 100 题”。必须包含“推理题”“边界条件”“人工复查”，不能出现“排行榜”。

Output: 为什么 v0.3 要扩到 100 题？因为推理题需要覆盖更多边界条件，才能全面检验模型能力。题量翻倍后，我们逐题进行人工复查，确保答案与标注准确可靠。样本更充分，结论也更稳健。