YZ Index
原始数据
所有评测运行记录及模型原始评分数据，完整透明
#8 轻量评测 done 2026-03-16 00:14:00 2026-03-16 00:25:17 8 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| DeepSeek R1 | deepseek | 87.8 | 93.3 | 75.6 | 99.6 | 77.8 | 87.6 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 3.292,
"cost_est": 0.00137,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 2.223,
"cost_est": 0.00137,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n cleaned = re.sub(r'[^a-zA-Z0-9]', '', s).lower()\n return cleaned == cleaned[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 6.053,
"cost_est": 0.00137,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_all",
"score": 66.7,
"prompt": "请仔细阅读以下会议纪要。\n\n【项目例会纪要 — \"智能客服3.0\"升级项目】\n日期：2026年3月10日（周二）14:00-16:30\n地点：公司A座3楼会议室\n参会人：李总（产品VP）、王工（技术负责人）、赵经理（项目经理）、陈设计（UI负责人）、刘测（QA负责人）\n\n一、项目背景回顾（赵经理）\n\n赵经理首先回顾了项目背景：当前客服系统日均处理对话量约12万通，用户满意度评分78分（满分100），平均响应时间4.2秒。3.0版本的目标是将满意度提升到88分以上，响应时间控制在2秒以内。项目总预算为300万元，已使用约45万元。预计上线日期为4月20日。\n\n二、技术方案讨论（王工）\n\n王工提出将现有的单体架构拆分为微服务架构，核心改造包括三个部分：（1）对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务：向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断。\n\n王工估计技术改造需要6-8周，团队需要5名后端、2名前端、1名算法工程师。目前团队有4名后端可用，还需要从其他项目借调或外包1名后端开发。\n\n三、预算讨论（李总）\n\n李总对预算表示关注。他指出300万的总预算需要覆盖到6月份的运维期，不能全部用于开发。他建议将外包费用控制在50万以内。但随后李总又表示，如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。这与他之前在邮件中提到的\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入。\n\n四、设计与测试（陈设计、刘测）\n\n陈设计展示了新版UI原型，整体风格从拟物化转向扁平化，增加了暗色模式。刘测提出需要至少2周的回归测试时间，加上1周的压力测试。他担心按照当前排期，测试时间会被压缩到不足10天。赵经理回应说可以在开发阶段同步进行部分测试工作来缓解这个问题。\n\n五、风险与决议\n\n会议识别了三个主要风险：（1）人手不足可能导致延期；（2）大模型API调用成本不确定；（3）数据迁移可能影响线上服务。经讨论，最终确定以下决议：\n1. 采用王工提出的微服务方案，分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\n2. 赵经理本周内完成借调人员的协调\n3. 刘测编写完整的测试用例文档，3月17日前提交评审\n4. 下次例会时间：3月17日（周二）同一时间\n\n请回答以下三个问题：\n1. 王工提出的技术方案具体是什么？\n2. 李总对预算的态度是什么？\n3. 最终确定的上线日期是哪天？",
"elapsed": 4.192,
"cost_est": 0.00137,
"expected": [
"微服务",
"300万",
"4月20日"
],
"response": "1. 将现有的单体架构拆分为微服务架构，核心改造包括三个部分：对话引擎微服务、知识库微服务、工单路由微服务。\n2. 李总对预算的态度是关注，建议外包费用控制在50万以内，但表示如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。\n3. 最终确定的上线日期是分两阶段：对话引擎于4月20日上线，工单路由于5月10日上线。",
"task_name": "会议纪要细节查找"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下研究论文摘要和正文。\n\n【论文标题】SparseFlash: 面向超长序列的稀疏注意力加速方法\n\n【摘要】\n\nTransformer架构在处理超长序列时面临注意力计算的二次方复杂度瓶颈。本文提出SparseFlash，一种结合动态稀疏模式和硬件感知优化的注意力加速方法。SparseFlash通过两阶段策略实现加速：第一阶段使用轻量级评分网络预测每个query token最相关的key token子集；第二阶段仅在选中的token对之间计算完整注意力。实验表明，在128K序列长度下，SparseFlash相比标准FlashAttention-2实现了4.7倍加速，同时在下游任务上的性能损失不超过0.3%。\n\n【1. 引言】\n\n大型语言模型处理长文档、代码仓库和多轮对话时，需要支持超长上下文窗口。当前主流模型已将上下文长度扩展到100K-1M token，但标准自注意力机制的O(n²)计算复杂度和内存消耗成为严重的效率瓶颈。以128K序列为例，标准注意力需要约128GB的中间存储，即使使用FlashAttention-2优化，单次前向传播仍需约2.4秒（A100 GPU）。\n\n现有的稀疏注意力方法（如Longformer的滑动窗口、BigBird的随机+全局模式）采用固定的稀疏模式，无法自适应地捕获不同输入的注意力分布特征。我们的核心观察是：在实际的长文本处理中，超过90%的注意力权重集中在不到15%的token对上。这为动态稀疏化提供了充分的空间。\n\n【2. 方法】\n\n2.1 轻量级评分网络\n\n我们设计了一个参数量仅为主模型0.5%的评分网络S(q, K)，它接收query向量q和所有key向量的压缩表示，输出每个key position的重要性分数。评分网络使用2层MLP结构，通过对key序列进行分块平均池化（块大小=64）来降低计算量。在128K序列长度下，评分阶段的计算开销仅占总注意力计算的3.2%。\n\n2.2 Top-K选择与注意力计算\n\n基于评分结果，我们为每个query token选择得分最高的K个key token（实验中K设为序列长度的10-20%）。随后仅在选中的(query, key)对之间计算完整的缩放点积注意力。为保持局部连续性，我们始终保留query位置前后256个token的局部窗口。\n\n2.3 硬件感知优化\n\n我们将稀疏注意力计算与FlashAttention的分块策略结合，确保所有内存访问都在GPU的SRAM中完成。具体而言，我们对选中的token索引进行排序和分组，使得同一计算块内的内存访问具有良好的局部性。\n\n【3. 实验结果】\n\n我们在三个基准上评估SparseFlash：（1）长文档QA（NarrativeQA, QuALITY）；（2）代码理解（LCC, RepoBench）；（3）多轮对话摘要（SummScreen）。\n\n主要发现：在128K序列长度下，SparseFlash相比FlashAttention-2实现了4.7倍的端到端加速（0.51秒 vs 2.4秒），峰值内存降低62%（48GB vs 128GB）。在下游任务准确率方面，SparseFlash的平均得分为89.1%，仅比完整注意力的89.4%低0.3个百分点。当序列长度增加到256K时，加速比进一步提升到7.2倍。\n\n消融实验表明，评分网络的准确率对最终性能至关重要：当评分网络的Top-K召回率低于85%时，下游任务性能开始显著下降。我们当前的评分网络在128K长度下的Top-K召回率为92%。\n\n请用中文回答：\n1. 这篇论文要解决什么问题？（一句话）\n2. 提出的方法叫什么？核心思路是什么？（两句话）\n3. 主要实验结论是什么？（一句话）",
"elapsed": 3.396,
"cost_est": 0.00137,
"expected": [
"注意力",
"稀疏",
"效率",
"长序列"
],
"response": "1. 解决Transformer处理超长序列时注意力计算二次方复杂度的效率瓶颈问题。\n2. 方法叫SparseFlash；核心思路是通过轻量级评分网络动态预测每个query最相关的key子集，然后仅在这些选中的token对之间计算完整注意力。\n3. 在128K序列长度下，相比FlashAttention-2实现了4.7倍加速且下游任务性能损失不超过0.3%。",
"task_name": "论文核心观点提取"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下是一份混合了有效信息和无关内容的日志。请只提取与「数据库性能问题」相关的条目，忽略所有其他内容。\n\n[2026-03-10 08:00:12] INFO: 用户张三登录系统\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:02:00] INFO: 定时任务「日报生成」开始执行\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:03:30] INFO: 用户李四上传文件 report.pdf (2.3MB)\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:05:00] INFO: 邮件发送成功，收件人: support@example.com\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:07:00] INFO: 缓存命中率: 94.2%\n[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:09:00] INFO: 前端部署完成 v2.3.1\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n请只列出与数据库性能问题相关的条目（保留原始时间戳和级别），并按严重程度排序，最后用一句话总结根因。",
"elapsed": 7.363,
"cost_est": 0.00137,
"expected": [
"连接池",
"慢查询",
"主从延迟",
"超时"
],
"response": "[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n根因：大量无索引的慢查询导致数据库连接池耗尽和主从延迟。",
"task_name": "噪音过滤提取"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有5个人参加比赛，已知：\n1. A的名次比B好\n2. C是第3名\n3. D的名次比E好，但比A差\n4. B不是最后一名\n请推理出5个人的排名顺序（第1名到第5名），只回答排名结果。",
"elapsed": 1.09,
"cost_est": 0.00137,
"expected": [
"A",
"D",
"C",
"B",
"E"
],
"response": "A、D、E、C、B",
"task_name": "逻辑推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下是某SaaS产品过去6个月的关键指标：\n\n| 月份 | MRR($) | 新增客户 | 流失客户 | NPS |\n|------|--------|----------|----------|-----|\n| 10月 | 52000 | 45 | 12 | 42 |\n| 11月 | 58000 | 52 | 15 | 40 |\n| 12月 | 55000 | 38 | 22 | 35 |\n| 1月 | 51000 | 30 | 25 | 31 |\n| 2月 | 48000 | 28 | 28 | 28 |\n| 3月 | 44000 | 25 | 32 | 25 |\n\n请分析这组数据，指出核心问题、可能原因和建议对策。用中文回答，300字以内。",
"elapsed": 3.425,
"cost_est": 0.00137,
"expected": [
"流失",
"MRR",
"NPS",
"下降"
],
"response": "核心问题：MRR持续下滑，客户流失加剧，NPS显著下降，显示产品竞争力减弱。\n\n可能原因：客户满意度下降导致流失增加，新增客户不足以弥补流失；市场或产品可能未跟上需求变化。\n\n建议对策：立即分析流失原因，针对性优化产品与服务；加强客户成功管理，提升留存；调整获客策略，提高转化质量。",
"task_name": "数据分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请找出以下段落中的所有错误（事实错误、逻辑错误、语法错误），列出每个错误并给出修正：\n\n\"Python是一种编译型语言，由James Gosling在1989年发明。Python 3.0发布于2012年，完全向后兼容Python 2。Python使用大括号{}来定义代码块，这使得代码非常易读。目前Python最新版本是2.7，广泛用于Web开发和数据科学。\"",
"elapsed": 8.772,
"cost_est": 0.00137,
"expected": [
"解释型",
"Guido",
"2008",
"缩进"
],
"response": "1. 事实错误：Python不是编译型语言，而是解释型语言。\n 修正：Python是一种解释型语言。\n\n2. 事实错误：Python不是由James Gosling发明的，而是由Guido van Rossum发明的。\n 修正：由Guido van Rossum在1989年发明。\n\n3. 事实错误：Python 3.0发布于2008年，不是2012年。\n 修正：Python 3.0发布于2008年。\n\n4. 事实错误：Python 3不完全向后兼容Python 2。\n 修正：Python 3不完全向后兼容Python 2。\n\n5. 事实错误：Python不使用大括号{}来定义代码块，而是使用缩进。\n 修正：Python使用缩进来定义代码块。\n\n6. 事实错误：目前Python最新版本不是2.7，2.7是旧版本；最新稳定版本是3.x系列（如3.12）。\n 修正：目前Python最新稳定版本是3.x系列（如3.12）。\n\n7. 逻辑错误：虽然Python用于Web开发和数据科学，但“这使得代码非常易读”与前文使用大括号的错误描述逻辑不符。\n 修正：删除“这使得代码非常易读”或改为“其使用缩进的语法使得代码非常易读”。",
"task_name": "文本纠错"
}
]
}
|
|||||||
| Qwen Max | alibaba | 93.3 | 93.3 | 78.3 | 80.2 | 78.9 | 86.9 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 2.737,
"cost_est": 0.004,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二叉树的序列化和反序列化。定义 class TreeNode 有 val, left, right 属性。实现两个函数：\n1. serialize(root) → str\n2. deserialize(data) → TreeNode\n要求能互相还原。只返回代码，不要解释。",
"elapsed": 2.524,
"cost_est": 0.004,
"expected": [
"def serialize",
"def deserialize",
"TreeNode",
"None"
],
"response": "```python\nclass TreeNode:\n def __init__(self, x):\n self.val = x\n self.left = None\n self.right = None\n\ndef serialize(root):\n if not root:\n return 'None,'\n return str(root.val) + ',' + serialize(root.left) + serialize(root.right)\n\ndef deserialize(data):\n def buildTree(nodes):\n val = next(nodes)\n if val == 'None':\n return None\n node = TreeNode(int(val))\n node.left = buildTree(nodes)\n node.right = buildTree(nodes)\n return node\n \n data_list = data.split(',')[:-1] # 去掉最后一个空字符串\n it = iter(data_list)\n return buildTree(it)\n```",
"task_name": "二叉树序列化"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 1.879,
"cost_est": 0.004,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下研究论文摘要和正文。\n\n【论文标题】SparseFlash: 面向超长序列的稀疏注意力加速方法\n\n【摘要】\n\nTransformer架构在处理超长序列时面临注意力计算的二次方复杂度瓶颈。本文提出SparseFlash，一种结合动态稀疏模式和硬件感知优化的注意力加速方法。SparseFlash通过两阶段策略实现加速：第一阶段使用轻量级评分网络预测每个query token最相关的key token子集；第二阶段仅在选中的token对之间计算完整注意力。实验表明，在128K序列长度下，SparseFlash相比标准FlashAttention-2实现了4.7倍加速，同时在下游任务上的性能损失不超过0.3%。\n\n【1. 引言】\n\n大型语言模型处理长文档、代码仓库和多轮对话时，需要支持超长上下文窗口。当前主流模型已将上下文长度扩展到100K-1M token，但标准自注意力机制的O(n²)计算复杂度和内存消耗成为严重的效率瓶颈。以128K序列为例，标准注意力需要约128GB的中间存储，即使使用FlashAttention-2优化，单次前向传播仍需约2.4秒（A100 GPU）。\n\n现有的稀疏注意力方法（如Longformer的滑动窗口、BigBird的随机+全局模式）采用固定的稀疏模式，无法自适应地捕获不同输入的注意力分布特征。我们的核心观察是：在实际的长文本处理中，超过90%的注意力权重集中在不到15%的token对上。这为动态稀疏化提供了充分的空间。\n\n【2. 方法】\n\n2.1 轻量级评分网络\n\n我们设计了一个参数量仅为主模型0.5%的评分网络S(q, K)，它接收query向量q和所有key向量的压缩表示，输出每个key position的重要性分数。评分网络使用2层MLP结构，通过对key序列进行分块平均池化（块大小=64）来降低计算量。在128K序列长度下，评分阶段的计算开销仅占总注意力计算的3.2%。\n\n2.2 Top-K选择与注意力计算\n\n基于评分结果，我们为每个query token选择得分最高的K个key token（实验中K设为序列长度的10-20%）。随后仅在选中的(query, key)对之间计算完整的缩放点积注意力。为保持局部连续性，我们始终保留query位置前后256个token的局部窗口。\n\n2.3 硬件感知优化\n\n我们将稀疏注意力计算与FlashAttention的分块策略结合，确保所有内存访问都在GPU的SRAM中完成。具体而言，我们对选中的token索引进行排序和分组，使得同一计算块内的内存访问具有良好的局部性。\n\n【3. 实验结果】\n\n我们在三个基准上评估SparseFlash：（1）长文档QA（NarrativeQA, QuALITY）；（2）代码理解（LCC, RepoBench）；（3）多轮对话摘要（SummScreen）。\n\n主要发现：在128K序列长度下，SparseFlash相比FlashAttention-2实现了4.7倍的端到端加速（0.51秒 vs 2.4秒），峰值内存降低62%（48GB vs 128GB）。在下游任务准确率方面，SparseFlash的平均得分为89.1%，仅比完整注意力的89.4%低0.3个百分点。当序列长度增加到256K时，加速比进一步提升到7.2倍。\n\n消融实验表明，评分网络的准确率对最终性能至关重要：当评分网络的Top-K召回率低于85%时，下游任务性能开始显著下降。我们当前的评分网络在128K长度下的Top-K召回率为92%。\n\n请用中文回答：\n1. 这篇论文要解决什么问题？（一句话）\n2. 提出的方法叫什么？核心思路是什么？（两句话）\n3. 主要实验结论是什么？（一句话）",
"elapsed": 2.453,
"cost_est": 0.004,
"expected": [
"注意力",
"稀疏",
"效率",
"长序列"
],
"response": "1. 这篇论文要解决的问题是Transformer在处理超长序列时面临的注意力计算复杂度高和内存消耗大的问题。\n2. 提出的方法叫SparseFlash。其核心思路是通过一个轻量级评分网络预测每个query token最相关的key token子集，然后仅在这些选中的token对之间计算完整的注意力，以此来减少计算量和内存使用。\n3. 主要实验结论是在128K序列长度下，SparseFlash相比FlashAttention-2实现了4.7倍的端到端加速，同时在下游任务上的性能损失不超过0.3%。",
"task_name": "论文核心观点提取"
},
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 4.631,
"cost_est": 0.004,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "【立场A】的核心论点是需要立即实施严格的全球统一AI监管框架，以防止未来可能的社会危害。其论据包括：AI发展速度超过监管能力、欧盟AI法案力度不足、历史案例（如核能和社交媒体）表明先发展后治理的代价巨大、以及不能依赖科技公司的自我约束。逻辑漏洞在于，它假设了所有AI模型都存在同等程度的风险，而未考虑不同应用场景的具体风险差异；同时，暂停所有大规模AI模型训练可能导致技术停滞，影响潜在的正面应用。\n\n【立场B】主张不应过度监管AI，以免扼杀创新。其依据为：严格监管会导致人才与资本外流至监管宽松地区、中国等国家不会停止AI研究、开源社区证明去中心化技术进步难以被禁止、应关注具体应用场景而非基础技术研发。此立场的不足之处在于，它可能低估了缺乏有效监管下AI技术滥用所带来的潜在风险，并且过分强调行业自律的有效性，忽略了在某些情况下企业利益与公共利益之间的冲突。",
"task_name": "观点对比分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下是一份混合了有效信息和无关内容的日志。请只提取与「数据库性能问题」相关的条目，忽略所有其他内容。\n\n[2026-03-10 08:00:12] INFO: 用户张三登录系统\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:02:00] INFO: 定时任务「日报生成」开始执行\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:03:30] INFO: 用户李四上传文件 report.pdf (2.3MB)\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:05:00] INFO: 邮件发送成功，收件人: support@example.com\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:07:00] INFO: 缓存命中率: 94.2%\n[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:09:00] INFO: 前端部署完成 v2.3.1\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n请只列出与数据库性能问题相关的条目（保留原始时间戳和级别），并按严重程度排序，最后用一句话总结根因。",
"elapsed": 3.988,
"cost_est": 0.004,
"expected": [
"连接池",
"慢查询",
"主从延迟",
"超时"
],
"response": "[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n\n总结：数据库性能问题的根本原因在于高并发导致的资源争用以及部分查询缺乏优化。",
"task_name": "噪音过滤提取"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请将以下英文翻译为流畅的中文技术文档风格：\n\n\"Retrieval-Augmented Generation (RAG) combines the strengths of large language models with external knowledge retrieval. By grounding the model's responses in retrieved documents, RAG significantly reduces hallucinations and improves factual accuracy. The architecture consists of a retriever module that fetches relevant passages from a vector database, and a generator module that synthesizes the final response.\"",
"elapsed": 1.262,
"cost_est": 0.004,
"expected": [
"检索增强生成",
"幻觉",
"向量数据库",
"检索"
],
"response": "检索增强生成（RAG）结合了大型语言模型与外部知识检索的优势。通过将模型的回答基于检索到的文档，RAG显著减少了幻觉现象并提高了事实准确性。该架构由两个部分组成：一是检索模块，负责从向量数据库中获取相关段落；二是生成模块，负责合成最终的回答。",
"task_name": "英译中（技术文档）"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有5个人参加比赛，已知：\n1. A的名次比B好\n2. C是第3名\n3. D的名次比E好，但比A差\n4. B不是最后一名\n请推理出5个人的排名顺序（第1名到第5名），只回答排名结果。",
"elapsed": 0.46,
"cost_est": 0.004,
"expected": [
"A",
"D",
"C",
"B",
"E"
],
"response": "A, D, C, B, E",
"task_name": "逻辑推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请从以下文本中提取信息并以JSON格式返回，不要有任何其他内容：\n\n\"张三，男，1990年5月出生，现任杭州某科技公司高级工程师，精通Python和Go，有8年工作经验，期望薪资45-55万\/年。\"\n\n要求的JSON结构：{\"name\":\"\",\"gender\":\"\",\"birth_year\":0,\"title\":\"\",\"skills\":[],\"experience_years\":0,\"salary_range\":\"\"}",
"elapsed": 0.777,
"cost_est": 0.004,
"expected": [
"\"name\"",
"\"张三\"",
"\"skills\"",
"\"Python\"",
"\"Go\"",
"\"experience_years\""
],
"response": "{\"name\":\"张三\",\"gender\":\"男\",\"birth_year\":1990,\"title\":\"高级工程师\",\"skills\":[\"Python\",\"Go\"],\"experience_years\":8,\"salary_range\":\"45-55万\/年\"}",
"task_name": "JSON结构化输出"
}
]
}
|
|||||||
| GPT-4o | openai | 87.8 | 93.3 | 86.7 | 61.3 | 80.7 | 84.0 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 1.128,
"cost_est": 0.00625,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n return [\"FizzBuzz\" if i % 15 == 0 else \"Fizz\" if i % 3 == 0 else \"Buzz\" if i % 5 == 0 else i for i in range(1, n + 1)]\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二叉树的序列化和反序列化。定义 class TreeNode 有 val, left, right 属性。实现两个函数：\n1. serialize(root) → str\n2. deserialize(data) → TreeNode\n要求能互相还原。只返回代码，不要解释。",
"elapsed": 1.6,
"cost_est": 0.00625,
"expected": [
"def serialize",
"def deserialize",
"TreeNode",
"None"
],
"response": "```python\nimport json\n\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\ndef serialize(root):\n def helper(node):\n if not node:\n return None\n return [node.val, helper(node.left), helper(node.right)]\n \n return json.dumps(helper(root))\n\ndef deserialize(data):\n def helper(lst):\n if not lst:\n return None\n node = TreeNode(lst[0])\n node.left = helper(lst[1])\n node.right = helper(lst[2])\n return node\n \n return helper(json.loads(data))\n```",
"task_name": "二叉树序列化"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 1.865,
"cost_est": 0.00625,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "最终 `counter.value` 不一定等于 10000。原因是在多线程环境中，多个线程可能会同时读取、修改和写入 `counter.value`，导致竞态条件出现。要修正这个问题，可以使用 `threading.Lock` 来确保增量操作是原子的。\n\n以下是修正后的完整代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\n def increment(self, n):\n for _ in range(n):\n with self.lock:\n self.value += 1\n\ndef increment(counter, n):\n counter.increment(n)\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下技术报告，然后回答问题。\n\n【2026年全球AI基础设施发展报告（节选）】\n\n一、总体趋势\n\n2025年全球AI基础设施市场规模达到340亿美元，同比增长87%。这一增速远超此前分析师预测的55%，主要驱动力来自三个方面：大模型训练需求的持续爆发、推理部署规模的快速扩张、以及边缘AI芯片的加速落地。预计到2027年，市场规模将突破800亿美元。\n\n二、算力格局变化\n\nNVIDIA继续主导AI训练芯片市场，占据约72%的份额。但AMD凭借MI300X系列在推理市场取得重大突破，推理芯片市场份额从上年的8%跃升至19%。值得注意的是，Google的TPU v6在内部大规模部署后开始对外开放，其训练效率较TPU v5提升了2.3倍，成本降低了40%。\n\n在算力成本方面，过去15个月内，每PFLOPS的训练成本下降了约58%。这一趋势直接推动了中小型企业和研究机构进入大模型训练领域。数据显示，2025年参与10B以上参数模型训练的机构数量同比增长了3.2倍。\n\n三、模型性能与成本关系\n\n算力成本的大幅下降使得研究者能够进行更大规模、更长时间的训练实验。报告统计了42个主流开源模型的训练过程，发现在算力成本降低50%的条件下，平均训练时长增加了120%，而最终模型在MMLU等综合基准上的得分平均提升了12个百分点。这表明算力成本下降并非简单地降低开支，而是释放了研究者探索更优训练策略的空间。\n\n四、安全与合规\n\n随着各国AI监管法规的落地，AI基础设施的合规要求日益严格。92%的受访企业表示已设立专门的AI合规团队，较上年的67%有大幅提升。合规成本平均占AI基础设施总投入的8-12%。\n\n报告特别指出，数据本地化要求正在重塑全球AI算力的地理分布。欧盟GDPR的严格执行使得本地数据中心的需求激增，而亚太地区凭借相对灵活的政策环境和较低的能源成本，正在成为新的AI算力中心。\n\n问题：报告中提到了哪些具体的数字指标（百分比、金额、时间等）？请列出所有数字及其对应的含义，用编号列表格式。",
"elapsed": 2.449,
"cost_est": 0.00625,
"expected": [
"87%",
"340亿",
"2.3倍",
"15个月",
"92%"
],
"response": "1. 2025年全球AI基础设施市场规模达到340亿美元。\n2. 同比增长87%。\n3. 分析师此前预测的增长为55%。\n4. 预计到2027年市场规模将突破800亿美元。\n5. NVIDIA占据AI训练芯片市场约72%的份额。\n6. AMD在推理芯片市场份额从上年的8%跃升至19%。\n7. Google TPU v6训练效率较TPU v5提升2.3倍，成本降低40%。\n8. 过去15个月内，每PFLOPS的训练成本下降约58%。\n9. 2025年参与10B以上参数模型训练的机构数量同比增长3.2倍。\n10. 算力成本降低50%条件下，平均训练时长增加120%。\n11. 最终模型在MMLU等基准上的得分平均提升12个百分点。\n12. 92%的受访企业设立专门的AI合规团队。\n13. 上年67%的企业有AI合规团队。\n14. 合规成本平均占AI基础设施总投入的8-12%。",
"task_name": "关键数据提取"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请仔细阅读以下会议纪要。\n\n【项目例会纪要 — \"智能客服3.0\"升级项目】\n日期：2026年3月10日（周二）14:00-16:30\n地点：公司A座3楼会议室\n参会人：李总（产品VP）、王工（技术负责人）、赵经理（项目经理）、陈设计（UI负责人）、刘测（QA负责人）\n\n一、项目背景回顾（赵经理）\n\n赵经理首先回顾了项目背景：当前客服系统日均处理对话量约12万通，用户满意度评分78分（满分100），平均响应时间4.2秒。3.0版本的目标是将满意度提升到88分以上，响应时间控制在2秒以内。项目总预算为300万元，已使用约45万元。预计上线日期为4月20日。\n\n二、技术方案讨论（王工）\n\n王工提出将现有的单体架构拆分为微服务架构，核心改造包括三个部分：（1）对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务：向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断。\n\n王工估计技术改造需要6-8周，团队需要5名后端、2名前端、1名算法工程师。目前团队有4名后端可用，还需要从其他项目借调或外包1名后端开发。\n\n三、预算讨论（李总）\n\n李总对预算表示关注。他指出300万的总预算需要覆盖到6月份的运维期，不能全部用于开发。他建议将外包费用控制在50万以内。但随后李总又表示，如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。这与他之前在邮件中提到的\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入。\n\n四、设计与测试（陈设计、刘测）\n\n陈设计展示了新版UI原型，整体风格从拟物化转向扁平化，增加了暗色模式。刘测提出需要至少2周的回归测试时间，加上1周的压力测试。他担心按照当前排期，测试时间会被压缩到不足10天。赵经理回应说可以在开发阶段同步进行部分测试工作来缓解这个问题。\n\n五、风险与决议\n\n会议识别了三个主要风险：（1）人手不足可能导致延期；（2）大模型API调用成本不确定；（3）数据迁移可能影响线上服务。经讨论，最终确定以下决议：\n1. 采用王工提出的微服务方案，分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\n2. 赵经理本周内完成借调人员的协调\n3. 刘测编写完整的测试用例文档，3月17日前提交评审\n4. 下次例会时间：3月17日（周二）同一时间\n\n请回答以下三个问题：\n1. 王工提出的技术方案具体是什么？\n2. 李总对预算的态度是什么？\n3. 最终确定的上线日期是哪天？",
"elapsed": 2.459,
"cost_est": 0.00625,
"expected": [
"微服务",
"300万",
"4月20日"
],
"response": "1. 王工提出的技术方案是将现有的单体架构拆分为微服务架构，核心改造包括：（1）对话引擎微服务，基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务，向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务，智能分配人工客服，支持情绪识别和优先级判断。\n\n2. 李总对预算的态度是希望300万的总预算覆盖到6月份的运维期，开发阶段外包费用控制在50万以内。如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。\n\n3. 最终确定的上线日期是分两阶段：4月20日上线对话引擎，5月10日上线工单路由。",
"task_name": "会议纪要细节查找"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下是一份混合了有效信息和无关内容的日志。请只提取与「数据库性能问题」相关的条目，忽略所有其他内容。\n\n[2026-03-10 08:00:12] INFO: 用户张三登录系统\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:02:00] INFO: 定时任务「日报生成」开始执行\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:03:30] INFO: 用户李四上传文件 report.pdf (2.3MB)\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:05:00] INFO: 邮件发送成功，收件人: support@example.com\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:07:00] INFO: 缓存命中率: 94.2%\n[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:09:00] INFO: 前端部署完成 v2.3.1\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n请只列出与数据库性能问题相关的条目（保留原始时间戳和级别），并按严重程度排序，最后用一句话总结根因。",
"elapsed": 1.779,
"cost_est": 0.00625,
"expected": [
"连接池",
"慢查询",
"主从延迟",
"超时"
],
"response": "[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47 \n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒 \n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒) \n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000 \n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200 \n\n总结：数据库性能问题主要由于连接池资源耗尽、查询超时和慢查询未优化引起。",
"task_name": "噪音过滤提取"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下是某SaaS产品过去6个月的关键指标：\n\n| 月份 | MRR($) | 新增客户 | 流失客户 | NPS |\n|------|--------|----------|----------|-----|\n| 10月 | 52000 | 45 | 12 | 42 |\n| 11月 | 58000 | 52 | 15 | 40 |\n| 12月 | 55000 | 38 | 22 | 35 |\n| 1月 | 51000 | 30 | 25 | 31 |\n| 2月 | 48000 | 28 | 28 | 28 |\n| 3月 | 44000 | 25 | 32 | 25 |\n\n请分析这组数据，指出核心问题、可能原因和建议对策。用中文回答，300字以内。",
"elapsed": 2.98,
"cost_est": 0.00625,
"expected": [
"流失",
"MRR",
"NPS",
"下降"
],
"response": "从数据中可以看出，该SaaS产品的MRR（每月经常性收入）和NPS（净推荐值）在过去6个月中持续下降，同时流失客户数量不断增加。这表明该产品可能正在经历客户满意度和忠诚度下降的问题。\n\n核心问题：1）客户流失率高：流失客户数量从10月的12人增加到3月的32人。2）客户满意度下降：NPS从10月的42降至3月的25。\n\n可能原因：1）产品功能未能满足客户需求，导致客户不满。2）竞争对手产品更具吸引力。3）客户支持或服务未达到客户预期。\n\n建议对策：1）进行客户调研，获取反馈以改进产品功能和用户体验。2）分析竞争对手，找出自身差距并进行调整。3）提高客户服务水平，及时解决客户问题，增强客户满意度。4）建立客户忠诚计划，提供激励以减少客户流失。5）定期监测关键指标，及时调整策略。",
"task_name": "数据分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请对\"一家专注于AI代码审查的创业公司\"做SWOT分析。该公司有20人团队，产品已上线6个月，月收入$15万，主要客户是中型科技公司。竞争对手包括GitHub Copilot和大厂内部工具。请用结构化格式输出SWOT四个象限，每个象限3-4个要点。",
"elapsed": 2.275,
"cost_est": 0.00625,
"expected": [
"Strength",
"Weakness",
"Opportunit",
"Threat"
],
"response": "**Strengths:**\n1. 专注于AI代码审查，具备专业领域优势。\n2. 产品已上线6个月，具有一定市场验证。\n3. 月收入$15万，显示出良好的盈利能力。\n4. 团队规模适中，具备灵活性和快速响应能力。\n\n**Weaknesses:**\n1. 仅有20人团队，资源和扩展能力有限。\n2. 市场知名度相对于大公司较低。\n3. 产品可能缺乏与大公司产品的深度集成。\n\n**Opportunities:**\n1. 中型科技公司市场需求增长。\n2. AI技术持续发展，产品改进空间大。\n3. 与其他开发工具提供商合作的机会。\n\n**Threats:**\n1. 竞争对手如GitHub Copilot及大厂内部工具的强大市场影响力。\n2. 行业内技术快速变化带来的压力。\n3. 大公司可能进行价格竞争或推出更先进的解决方案。",
"task_name": "SWOT分析"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用一个10岁小学生能理解的方式，解释以下三个技术概念，每个概念用2-3句话：\n1. 分布式系统\n2. 机器学习\n3. 加密算法\n不要使用任何专业术语。",
"elapsed": 2.453,
"cost_est": 0.00625,
"expected": [
"分布式",
"机器学习",
"加密"
],
"response": "1. 分布式系统：就像一群小朋友一起完成一个大拼图，每个小朋友负责拼一部分。这样，大家一起合作，比一个人单独拼要快很多。\n\n2. 机器学习：就像教小狗学会新的动作。你给它示范很多次，它慢慢就学会了。电脑也能通过看很多例子来学会做事情。\n\n3. 加密算法：就像写秘密信的时候用特别的符号，只有了解密码的人才能看懂。这样可以保护你的信不被其他人偷看。",
"task_name": "术语解释（通俗化）"
}
]
}
|
|||||||
| DeepSeek V3 | deepseek | 75.6 | 80.0 | 78.3 | 100.0 | 91.4 | 83.1 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 66.7,
"prompt": "请用Python实现函数 length_of_lis(nums)，返回数组中最长严格递增子序列的长度。要求时间复杂度 O(n log n)。只返回函数代码，不要解释。",
"elapsed": 3.844,
"cost_est": 0.000685,
"expected": [
"def length_of_lis",
"bisect",
"len("
],
"response": "```python\ndef length_of_lis(nums):\n if not nums:\n return 0\n tails = []\n for num in nums:\n left, right = 0, len(tails)\n while left < right:\n mid = (left + right) \/\/ 2\n if tails[mid] < num:\n left = mid + 1\n else:\n right = mid\n if left == len(tails):\n tails.append(num)\n else:\n tails[left] = num\n return len(tails)\n```",
"task_name": "最长递增子序列"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码试图合并重叠区间，但有 bug。请找出所有 bug 并给出修正后的完整代码。\n\n```python\ndef merge_intervals(intervals):\n intervals.sort(key=lambda x: x[0])\n merged = [intervals[0]]\n for i in range(len(intervals)):\n current = intervals[i]\n last = merged[-1]\n if current[0] <= last[1]:\n last[1] = current[1]\n else:\n merged.append(current)\n return merged\n```\n\n提示：当 current 完全包含在 last 内时、以及空输入时，代码有问题。请返回修正后的完整函数代码和简要说明每个 bug。",
"elapsed": 6.482,
"cost_est": 0.000685,
"expected": [
"max(",
"if not intervals",
"range(1"
],
"response": "修正后的完整代码：\n```python\ndef merge_intervals(intervals):\n if not intervals:\n return []\n \n intervals.sort(key=lambda x: x[0])\n merged = [intervals[0]]\n \n for i in range(1, len(intervals)):\n current = intervals[i]\n last = merged[-1]\n if current[0] <= last[1]:\n last[1] = max(last[1], current[1])\n else:\n merged.append(current)\n \n return merged\n```\n\nBug说明：\n1. **空输入处理**：原代码未处理空列表输入，会导致 `merged = [intervals[0]]` 索引错误。\n2. **循环起始索引**：应从索引1开始遍历，避免第一个区间与自己比较。\n3. **区间完全包含**：当`current`完全在`last`内时，原代码错误地将`last[1]`更新为`current[1]`，应取两者的最大值。",
"task_name": "Debug：合并区间"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 4.509,
"cost_est": 0.000685,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "不一定等于10000。原因是多个线程同时读写共享变量 `counter.value` 时可能发生竞争条件，导致部分增加操作丢失。\n\n修正后的代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\ndef increment(counter, n):\n for _ in range(n):\n with counter.lock:\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下技术报告，然后回答问题。\n\n【2026年全球AI基础设施发展报告（节选）】\n\n一、总体趋势\n\n2025年全球AI基础设施市场规模达到340亿美元，同比增长87%。这一增速远超此前分析师预测的55%，主要驱动力来自三个方面：大模型训练需求的持续爆发、推理部署规模的快速扩张、以及边缘AI芯片的加速落地。预计到2027年，市场规模将突破800亿美元。\n\n二、算力格局变化\n\nNVIDIA继续主导AI训练芯片市场，占据约72%的份额。但AMD凭借MI300X系列在推理市场取得重大突破，推理芯片市场份额从上年的8%跃升至19%。值得注意的是，Google的TPU v6在内部大规模部署后开始对外开放，其训练效率较TPU v5提升了2.3倍，成本降低了40%。\n\n在算力成本方面，过去15个月内，每PFLOPS的训练成本下降了约58%。这一趋势直接推动了中小型企业和研究机构进入大模型训练领域。数据显示，2025年参与10B以上参数模型训练的机构数量同比增长了3.2倍。\n\n三、模型性能与成本关系\n\n算力成本的大幅下降使得研究者能够进行更大规模、更长时间的训练实验。报告统计了42个主流开源模型的训练过程，发现在算力成本降低50%的条件下，平均训练时长增加了120%，而最终模型在MMLU等综合基准上的得分平均提升了12个百分点。这表明算力成本下降并非简单地降低开支，而是释放了研究者探索更优训练策略的空间。\n\n四、安全与合规\n\n随着各国AI监管法规的落地，AI基础设施的合规要求日益严格。92%的受访企业表示已设立专门的AI合规团队，较上年的67%有大幅提升。合规成本平均占AI基础设施总投入的8-12%。\n\n报告特别指出，数据本地化要求正在重塑全球AI算力的地理分布。欧盟GDPR的严格执行使得本地数据中心的需求激增，而亚太地区凭借相对灵活的政策环境和较低的能源成本，正在成为新的AI算力中心。\n\n问题：报告中提到了哪些具体的数字指标（百分比、金额、时间等）？请列出所有数字及其对应的含义，用编号列表格式。",
"elapsed": 8.284,
"cost_est": 0.000685,
"expected": [
"87%",
"340亿",
"2.3倍",
"15个月",
"92%"
],
"response": "1. 340亿美元 - 2025年全球AI基础设施市场规模 \n2. 87% - 2025年市场规模同比增长率 \n3. 55% - 分析师此前预测的市场增速 \n4. 800亿美元 - 预计2027年市场规模 \n5. 72% - NVIDIA在AI训练芯片市场的份额 \n6. 8% - AMD推理芯片市场份额（上年） \n7. 19% - AMD推理芯片市场份额（当前） \n8. 2.3倍 - Google TPU v6较TPU v5的训练效率提升 \n9. 40% - Google TPU v6较TPU v5的成本降低 \n10. 58% - 过去15个月内每PFLOPS训练成本的下降幅度 \n11. 3.2倍 - 2025年参与10B以上参数模型训练的机构数量同比增长 \n12. 50% - 算力成本降低条件（模型性能与成本关系分析） \n13. 120% - 算力成本降低50%条件下平均训练时长的增加 \n14. 12个百分点 - 算力成本降低50%条件下模型在MMLU等基准得分的平均提升 \n15. 92% - 已设立专门AI合规团队的受访企业比例 \n16. 67% - 上年已设立专门AI合规团队的受访企业比例 \n17. 8-12% - 合规成本平均占AI基础设施总投入的比例",
"task_name": "关键数据提取"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下会议纪要，找出其中的矛盾或不一致之处。\n\n【项目例会纪要 — \"智能客服3.0\"升级项目】\n日期：2026年3月10日（周二）14:00-16:30\n地点：公司A座3楼会议室\n参会人：李总（产品VP）、王工（技术负责人）、赵经理（项目经理）、陈设计（UI负责人）、刘测（QA负责人）\n\n一、项目背景回顾（赵经理）\n\n赵经理首先回顾了项目背景：当前客服系统日均处理对话量约12万通，用户满意度评分78分（满分100），平均响应时间4.2秒。3.0版本的目标是将满意度提升到88分以上，响应时间控制在2秒以内。项目总预算为300万元，已使用约45万元。预计上线日期为4月20日。\n\n二、技术方案讨论（王工）\n\n王工提出将现有的单体架构拆分为微服务架构，核心改造包括三个部分：（1）对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务：向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断。\n\n王工估计技术改造需要6-8周，团队需要5名后端、2名前端、1名算法工程师。目前团队有4名后端可用，还需要从其他项目借调或外包1名后端开发。\n\n三、预算讨论（李总）\n\n李总对预算表示关注。他指出300万的总预算需要覆盖到6月份的运维期，不能全部用于开发。他建议将外包费用控制在50万以内。但随后李总又表示，如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。这与他之前在邮件中提到的\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入。\n\n四、设计与测试（陈设计、刘测）\n\n陈设计展示了新版UI原型，整体风格从拟物化转向扁平化，增加了暗色模式。刘测提出需要至少2周的回归测试时间，加上1周的压力测试。他担心按照当前排期，测试时间会被压缩到不足10天。赵经理回应说可以在开发阶段同步进行部分测试工作来缓解这个问题。\n\n五、风险与决议\n\n会议识别了三个主要风险：（1）人手不足可能导致延期；（2）大模型API调用成本不确定；（3）数据迁移可能影响线上服务。经讨论，最终确定以下决议：\n1. 采用王工提出的微服务方案，分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\n2. 赵经理本周内完成借调人员的协调\n3. 刘测编写完整的测试用例文档，3月17日前提交评审\n4. 下次例会时间：3月17日（周二）同一时间\n\n请列出所有你发现的矛盾点，说明在哪两处存在冲突。",
"elapsed": 5.066,
"cost_est": 0.000685,
"expected": [
"矛盾",
"不一致",
"冲突"
],
"response": "1. **预算表述矛盾**：李总在会议中表示“可以考虑追加100万预算”，但与他之前在邮件中提到的“严格控制在300万总预算内，不接受任何追加”的说法存在冲突。\n\n2. **上线时间矛盾**：项目背景回顾中预计上线日期为4月20日，但决议中确定“4月20日上线对话引擎，5月10日上线工单路由”，表明完整上线时间晚于原定日期，存在不一致。\n\n3. **测试时间矛盾**：刘测提出需要至少3周（2周回归测试+1周压力测试）的测试时间，但赵经理提到测试时间可能被压缩到不足10天，而当前排期未明确解决此冲突。",
"task_name": "矛盾检测"
},
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 4.492,
"cost_est": 0.000685,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "立场A核心论点：AI发展过快，需立即严格监管以防不可逆危害。论据：历史教训（核能、社交媒体）、现有监管不足、企业不可信。逻辑漏洞：可能高估短期风险，低估全球协同监管难度，且“暂停训练”可能不切实际。\n\n立场B核心论点：过度监管扼杀创新，应注重应用层治理。论据：发展窗口期重要性、监管差异导致人才资本外流、开源社区难以禁止。逻辑漏洞：可能低估系统性风险，过度依赖行业自律，且忽视基础技术本身可能带来的广泛冲击。",
"task_name": "观点对比分析"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请将以下英文翻译为流畅的中文技术文档风格：\n\n\"Retrieval-Augmented Generation (RAG) combines the strengths of large language models with external knowledge retrieval. By grounding the model's responses in retrieved documents, RAG significantly reduces hallucinations and improves factual accuracy. The architecture consists of a retriever module that fetches relevant passages from a vector database, and a generator module that synthesizes the final response.\"",
"elapsed": 2.764,
"cost_est": 0.000685,
"expected": [
"检索增强生成",
"幻觉",
"向量数据库",
"检索"
],
"response": "检索增强生成（RAG）技术融合了大语言模型与外部知识检索的优势。通过将模型生成的回答建立在检索文档的基础上，RAG能显著减少信息幻觉并提升事实准确性。其架构包含两个核心模块：检索模块负责从向量数据库中获取相关文本段落，生成模块则负责综合信息并生成最终回答。",
"task_name": "英译中（技术文档）"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请对\"一家专注于AI代码审查的创业公司\"做SWOT分析。该公司有20人团队，产品已上线6个月，月收入$15万，主要客户是中型科技公司。竞争对手包括GitHub Copilot和大厂内部工具。请用结构化格式输出SWOT四个象限，每个象限3-4个要点。",
"elapsed": 10.625,
"cost_est": 0.000685,
"expected": [
"Strength",
"Weakness",
"Opportunit",
"Threat"
],
"response": "**优势 (Strengths)**\n1. 产品聚焦：专注于AI代码审查细分领域，功能深度可能优于通用工具。\n2. 市场验证：产品上线仅6个月即实现月收入15万美元，表明产品市场契合度初步得到验证。\n3. 团队敏捷：20人规模创业公司，决策与迭代速度快，能快速响应客户需求。\n\n**劣势 (Weaknesses)**\n1. 资源有限：与GitHub（微软）等大型竞争对手相比，资金、品牌与研发资源严重不足。\n2. 客户基础薄弱：主要依赖中型科技公司，客户群较窄，抗风险能力较弱。\n3. 市场知名度低：作为新创公司，品牌影响力和市场信任度有待建立。\n\n**机会 (Opportunities)**\n1. 市场需求增长：企业对代码质量与开发效率要求提升，AI辅助开发工具市场持续扩大。\n2. 差异化竞争：针对通用工具未满足的深度审查、定制化或合规需求，建立专业壁垒。\n3. 合作与集成：通过与其他开发平台或工具集成，快速拓展客户触达渠道。\n\n**威胁 (Threats)**\n1. 巨头竞争：面临GitHub Copilot等既有强大对手的直接竞争，以及大厂可能将类似功能免费捆绑的风险。\n2. 技术快速迭代：AI技术日新月异，若不能持续保持技术领先，优势可能被迅速赶超。\n3. 经济不确定性：宏观经济压力可能导致企业（尤其是中型客户）削减在开发工具上的预算。",
"task_name": "SWOT分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请找出以下段落中的所有错误（事实错误、逻辑错误、语法错误），列出每个错误并给出修正：\n\n\"Python是一种编译型语言，由James Gosling在1989年发明。Python 3.0发布于2012年，完全向后兼容Python 2。Python使用大括号{}来定义代码块，这使得代码非常易读。目前Python最新版本是2.7，广泛用于Web开发和数据科学。\"",
"elapsed": 7.047,
"cost_est": 0.000685,
"expected": [
"解释型",
"Guido",
"2008",
"缩进"
],
"response": "1. 事实错误：Python不是编译型语言，而是解释型语言。修正：将“编译型语言”改为“解释型语言”。\n2. 事实错误：Python不是由James Gosling发明的，而是由Guido van Rossum发明的。修正：将“James Gosling”改为“Guido van Rossum”。\n3. 事实错误：Python 3.0发布于2008年，不是2012年。修正：将“2012年”改为“2008年”。\n4. 事实错误：Python 3.0不完全向后兼容Python 2。修正：将“完全向后兼容Python 2”改为“不完全向后兼容Python 2”。\n5. 事实错误：Python不使用大括号{}来定义代码块，而是使用缩进。修正：将“使用大括号{}来定义代码块”改为“使用缩进来定义代码块”。\n6. 事实错误：目前Python最新版本不是2.7（2.7已过时），而是3.x系列（如3.12或更高）。修正：将“最新版本是2.7”改为“最新版本是3.x系列（如3.12）”。",
"task_name": "文本纠错"
}
]
}
|
|||||||
| Claude Sonnet 4.6 | anthropic | 86.7 | 91.7 | 93.3 | 46.5 | 78.7 | 81.7 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.594,
"cost_est": 0.009,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n \n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 4.125,
"cost_est": 0.009,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i-1] == word2[j-1]:\n dp[i][j] = dp[i-1][j-1]\n else:\n dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码试图合并重叠区间，但有 bug。请找出所有 bug 并给出修正后的完整代码。\n\n```python\ndef merge_intervals(intervals):\n intervals.sort(key=lambda x: x[0])\n merged = [intervals[0]]\n for i in range(len(intervals)):\n current = intervals[i]\n last = merged[-1]\n if current[0] <= last[1]:\n last[1] = current[1]\n else:\n merged.append(current)\n return merged\n```\n\n提示：当 current 完全包含在 last 内时、以及空输入时，代码有问题。请返回修正后的完整函数代码和简要说明每个 bug。",
"elapsed": 9.644,
"cost_est": 0.009,
"expected": [
"max(",
"if not intervals",
"range(1"
],
"response": "这段代码存在以下几个 bug：\n\n1. **空输入处理**：当 `intervals` 为空列表时，`intervals[0]` 会抛出 IndexError\n2. **循环起始错误**：循环应该从索引 1 开始，因为 `intervals[0]` 已经加入 merged\n3. **区间合并错误**：当 current 完全被 last 包含时，应该使用 `max(last[1], current[1])`\n\n修正后的代码：\n\n```python\ndef merge_intervals(intervals):\n if not intervals:\n return []\n \n intervals.sort(key=lambda x: x[0])\n merged = [intervals[0]]\n \n for i in range(1, len(intervals)):\n current = intervals[i]\n last = merged[-1]\n if current[0] <= last[1]:\n last[1] = max(last[1], current[1])\n else:\n merged.append(current)\n \n return merged\n```\n\n**Bug 说明**：\n1. 添加了空输入检查，避免访问空列表的第一个元素\n2. 循环从索引 1 开始，避免重复处理第一个区间\n3. 使用 `max(last[1], current[1])` 确保合并后的区间右边界是两个区间右边界的最大值，正确处理当前区间完全被包含的情况",
"task_name": "Debug：合并区间"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请仔细阅读以下会议纪要。\n\n【项目例会纪要 — \"智能客服3.0\"升级项目】\n日期：2026年3月10日（周二）14:00-16:30\n地点：公司A座3楼会议室\n参会人：李总（产品VP）、王工（技术负责人）、赵经理（项目经理）、陈设计（UI负责人）、刘测（QA负责人）\n\n一、项目背景回顾（赵经理）\n\n赵经理首先回顾了项目背景：当前客服系统日均处理对话量约12万通，用户满意度评分78分（满分100），平均响应时间4.2秒。3.0版本的目标是将满意度提升到88分以上，响应时间控制在2秒以内。项目总预算为300万元，已使用约45万元。预计上线日期为4月20日。\n\n二、技术方案讨论（王工）\n\n王工提出将现有的单体架构拆分为微服务架构，核心改造包括三个部分：（1）对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务：向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断。\n\n王工估计技术改造需要6-8周，团队需要5名后端、2名前端、1名算法工程师。目前团队有4名后端可用，还需要从其他项目借调或外包1名后端开发。\n\n三、预算讨论（李总）\n\n李总对预算表示关注。他指出300万的总预算需要覆盖到6月份的运维期，不能全部用于开发。他建议将外包费用控制在50万以内。但随后李总又表示，如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。这与他之前在邮件中提到的\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入。\n\n四、设计与测试（陈设计、刘测）\n\n陈设计展示了新版UI原型，整体风格从拟物化转向扁平化，增加了暗色模式。刘测提出需要至少2周的回归测试时间，加上1周的压力测试。他担心按照当前排期，测试时间会被压缩到不足10天。赵经理回应说可以在开发阶段同步进行部分测试工作来缓解这个问题。\n\n五、风险与决议\n\n会议识别了三个主要风险：（1）人手不足可能导致延期；（2）大模型API调用成本不确定；（3）数据迁移可能影响线上服务。经讨论，最终确定以下决议：\n1. 采用王工提出的微服务方案，分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\n2. 赵经理本周内完成借调人员的协调\n3. 刘测编写完整的测试用例文档，3月17日前提交评审\n4. 下次例会时间：3月17日（周二）同一时间\n\n请回答以下三个问题：\n1. 王工提出的技术方案具体是什么？\n2. 李总对预算的态度是什么？\n3. 最终确定的上线日期是哪天？",
"elapsed": 6.726,
"cost_est": 0.009,
"expected": [
"微服务",
"300万",
"4月20日"
],
"response": "1. 王工提出的技术方案是将现有单体架构拆分为微服务架构，包括三个核心部分：\n - 对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别\n - 知识库微服务：向量检索 + RAG架构，支持实时知识更新\n - 工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断\n\n2. 李总对预算的态度存在矛盾：\n - 会议中表示300万总预算需要覆盖到6月份的运维期，建议外包费用控制在50万以内\n - 同时又表示如果技术方案能确保月运营成本降低30%以上，可以考虑追加100万预算\n - 这与他之前邮件中\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入\n\n3. 最终确定分两阶段上线：\n - 4月20日上线对话引擎\n - 5月10日上线工单路由",
"task_name": "会议纪要细节查找"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下会议纪要，找出其中的矛盾或不一致之处。\n\n【项目例会纪要 — \"智能客服3.0\"升级项目】\n日期：2026年3月10日（周二）14:00-16:30\n地点：公司A座3楼会议室\n参会人：李总（产品VP）、王工（技术负责人）、赵经理（项目经理）、陈设计（UI负责人）、刘测（QA负责人）\n\n一、项目背景回顾（赵经理）\n\n赵经理首先回顾了项目背景：当前客服系统日均处理对话量约12万通，用户满意度评分78分（满分100），平均响应时间4.2秒。3.0版本的目标是将满意度提升到88分以上，响应时间控制在2秒以内。项目总预算为300万元，已使用约45万元。预计上线日期为4月20日。\n\n二、技术方案讨论（王工）\n\n王工提出将现有的单体架构拆分为微服务架构，核心改造包括三个部分：（1）对话引擎微服务：基于大模型的多轮对话能力，支持上下文记忆和意图识别；（2）知识库微服务：向量检索 + RAG架构，支持实时知识更新；（3）工单路由微服务：智能分配人工客服，支持情绪识别和优先级判断。\n\n王工估计技术改造需要6-8周，团队需要5名后端、2名前端、1名算法工程师。目前团队有4名后端可用，还需要从其他项目借调或外包1名后端开发。\n\n三、预算讨论（李总）\n\n李总对预算表示关注。他指出300万的总预算需要覆盖到6月份的运维期，不能全部用于开发。他建议将外包费用控制在50万以内。但随后李总又表示，如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算。这与他之前在邮件中提到的\"严格控制在300万总预算内，不接受任何追加\"的说法存在出入。\n\n四、设计与测试（陈设计、刘测）\n\n陈设计展示了新版UI原型，整体风格从拟物化转向扁平化，增加了暗色模式。刘测提出需要至少2周的回归测试时间，加上1周的压力测试。他担心按照当前排期，测试时间会被压缩到不足10天。赵经理回应说可以在开发阶段同步进行部分测试工作来缓解这个问题。\n\n五、风险与决议\n\n会议识别了三个主要风险：（1）人手不足可能导致延期；（2）大模型API调用成本不确定；（3）数据迁移可能影响线上服务。经讨论，最终确定以下决议：\n1. 采用王工提出的微服务方案，分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\n2. 赵经理本周内完成借调人员的协调\n3. 刘测编写完整的测试用例文档，3月17日前提交评审\n4. 下次例会时间：3月17日（周二）同一时间\n\n请列出所有你发现的矛盾点，说明在哪两处存在冲突。",
"elapsed": 9.771,
"cost_est": 0.009,
"expected": [
"矛盾",
"不一致",
"冲突"
],
"response": "我发现以下矛盾点：\n\n1. **预算政策的矛盾**\n - 李总在会议中表示\"如果技术方案能确保上线后月运营成本降低30%以上，可以考虑追加100万预算\"\n - 但纪要中提到他之前在邮件中说过\"严格控制在300万总预算内，不接受任何追加\"\n\n2. **测试时间的矛盾**\n - 刘测要求\"至少2周的回归测试时间，加上1周的压力测试\"（共3周）\n - 但他担心\"测试时间会被压缩到不足10天\"，这意味着实际可用时间远少于需求\n\n3. **上线计划的矛盾**\n - 开头提到\"预计上线日期为4月20日\"（完整上线）\n - 但决议中却是\"分两阶段上线——4月20日上线对话引擎，5月10日上线工单路由\"\n\n4. **开发时间与上线时间的矛盾**\n - 王工估计\"技术改造需要6-8周\"\n - 从3月10日到4月20日只有约6周时间，如果按8周计算会延期到5月初\n - 这与4月20日的首阶段上线目标存在时间压力",
"task_name": "矛盾检测"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 11.535,
"cost_est": 0.009,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "立场A的核心论点是AI风险巨大需立即强监管。论据包括：AI发展速度超越监管能力、历史上技术失控案例（核能、社交媒体）、企业自律不可靠。逻辑漏洞：类比可能不恰当（AI与核能、社交媒体的风险性质不同）、\"五年内不可逆危害\"缺乏具体证据、全球统一监管在实践中难以实现。\n\n立场B的核心论点是过度监管阻碍创新和竞争力。论据包括：人才资本外流风险、国际竞争现实、开源社区难以管控、互联网宽松政策的成功先例。逻辑漏洞：忽视了AI与互联网的风险差异、\"行业自律\"的有效性存疑（尤其在利益驱动下）、未充分考虑AI失控的潜在灾难性后果。\n\n两种立场都有选择性使用证据的倾向，A偏重风险而轻视创新价值，B偏重发展而轻视安全隐患。实际上，AI监管需要在安全与创新之间寻找动态平衡，而非采取极端立场。",
"task_name": "观点对比分析"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "请用中文写一封商务邮件：你是项目经理，需要通知客户项目交付时间从3月30日延期到4月15日，原因是第三方API接口变更导致需要重新对接。语气专业、诚恳，提供补救方案。只返回邮件正文。",
"elapsed": 12.213,
"cost_est": 0.009,
"expected": [
"延期",
"4月15",
"API",
"方案"
],
"response": "尊敬的[客户名称]：\n\n您好！\n\n我谨代表项目团队向您通报一个重要事项。由于我们的第三方API接口供应商临时进行了重大技术升级，导致原有接口规范发生变更，我们需要重新进行技术对接和测试工作。经过审慎评估，项目交付时间需要从原定的3月30日调整至4月15日。\n\n对于此次延期给贵司带来的不便，我们深表歉意。为了尽可能降低延期对贵司的影响，我们制定了以下补救措施：\n\n1. 加派技术人员，确保在4月15日前高质量完成所有功能开发和测试；\n2. 从即日起，每周二、周五向贵司提供详细的进度报告，确保项目透明度；\n3. 提前交付已完成的模块供贵司先行测试和熟悉；\n4. 项目交付后，我们将免费提供额外一个月的技术支持服务。\n\n我们理解按时交付对贵司业务的重要性，团队将全力以赴确保新的交付日期。如您有任何疑问或需要进一步沟通，请随时与我联系。\n\n再次为延期带来的不便致以诚挚的歉意，感谢您的理解与支持。\n\n此致\n敬礼！\n\n[您的名字]\n项目经理\n[日期]",
"task_name": "商务邮件"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有5个人参加比赛，已知：\n1. A的名次比B好\n2. C是第3名\n3. D的名次比E好，但比A差\n4. B不是最后一名\n请推理出5个人的排名顺序（第1名到第5名），只回答排名结果。",
"elapsed": 1.926,
"cost_est": 0.009,
"expected": [
"A",
"D",
"C",
"B",
"E"
],
"response": "第1名：A\n第2名：D\n第3名：C\n第4名：B\n第5名：E",
"task_name": "逻辑推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "一个日活50万的社交App后端需要选择消息队列，候选方案是 Kafka 和 RabbitMQ。请从吞吐量、延迟、运维复杂度、生态系统、适用场景五个维度做对比，用表格形式输出，最后给出推荐和理由。",
"elapsed": 18.398,
"cost_est": 0.009,
"expected": [
"Kafka",
"RabbitMQ",
"吞吐",
"延迟"
],
"response": "| 维度 | Kafka | RabbitMQ |\n|------|-------|----------|\n| **吞吐量** | • 极高，可达百万级消息\/秒<br>• 批量处理，顺序写入<br>• 水平扩展能力强 | • 中等，约10万级消息\/秒<br>• 单条消息处理<br>• 垂直扩展为主 |\n| **延迟** | • 毫秒级延迟（通常2-10ms）<br>• 批量发送可能增加延迟<br>• 不适合极低延迟场景 | • 微秒级延迟（通常<1ms）<br>• 实时性更好<br>• 适合低延迟场景 |\n| **运维复杂度** | • 较高<br>• 需要ZooKeeper\/Kraft<br>• 集群配置复杂<br>• 需要专业运维知识 | • 较低<br>• 开箱即用<br>• 管理界面友好<br>• 运维相对简单 |\n| **生态系统** | • 大数据生态丰富<br>• Spark\/Flink\/Storm集成<br>• Confluent平台支持<br>• 监控工具完善 | • AMQP标准协议<br>• 多语言客户端支持<br>• Spring集成良好<br>• 插件系统丰富 |\n| **适用场景** | • 日志收集分析<br>• 用户行为追踪<br>• 实时数据流处理<br>• 事件溯源 | • 任务队列<br>• 实时通知推送<br>• RPC通信<br>• 工作流编排 |\n\n## 推荐方案：RabbitMQ\n\n**推荐理由：**\n\n1. **规模匹配**：日活50万的社交App属于中等规模，RabbitMQ的性能完全满足需求，无需Kafka级别的吞吐量\n\n2. **社交场景契合**：\n - 实时消息推送需要低延迟，RabbitMQ更合适\n - 点对点聊天、群聊等场景，RabbitMQ的路由模式更灵活\n - 消息可靠性要求高，RabbitMQ的ACK机制更完善\n\n3. **运维成本**：团队可能没有专门的大数据运维人员，RabbitMQ更易上手和维护\n\n4. **开发效率**：RabbitMQ与常用Web框架集成更好，开发效率更高\n\n5. **成本效益**：当前规模下，RabbitMQ的资源消耗更少，性价比更高",
"task_name": "技术选型对比"
}
]
}
|
|||||||
| Claude Opus 4.6 | anthropic | 93.3 | 100.0 | 93.3 | 10.6 | 83.4 | 81.1 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.903,
"cost_est": 0.045,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n cleaned = ''.join(char.lower() for char in s if char.isalnum())\n return cleaned == cleaned[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.98,
"cost_est": 0.045,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 3.829,
"cost_est": 0.045,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i-1] == word2[j-1]:\n dp[i][j] = dp[i-1][j-1]\n else:\n dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请仔细阅读以下技术报告。\n\n【2026年全球AI基础设施发展报告（节选）】\n\n一、总体趋势\n\n2025年全球AI基础设施市场规模达到340亿美元，同比增长87%。这一增速远超此前分析师预测的55%，主要驱动力来自三个方面：大模型训练需求的持续爆发、推理部署规模的快速扩张、以及边缘AI芯片的加速落地。预计到2027年，市场规模将突破800亿美元。\n\n二、算力格局变化\n\nNVIDIA继续主导AI训练芯片市场，占据约72%的份额。但AMD凭借MI300X系列在推理市场取得重大突破，推理芯片市场份额从上年的8%跃升至19%。值得注意的是，Google的TPU v6在内部大规模部署后开始对外开放，其训练效率较TPU v5提升了2.3倍，成本降低了40%。\n\n在算力成本方面，过去15个月内，每PFLOPS的训练成本下降了约58%。这一趋势直接推动了中小型企业和研究机构进入大模型训练领域。数据显示，2025年参与10B以上参数模型训练的机构数量同比增长了3.2倍。\n\n三、模型性能与成本关系\n\n算力成本的大幅下降使得研究者能够进行更大规模、更长时间的训练实验。报告统计了42个主流开源模型的训练过程，发现在算力成本降低50%的条件下，平均训练时长增加了120%，而最终模型在MMLU等综合基准上的得分平均提升了12个百分点。这表明算力成本下降并非简单地降低开支，而是释放了研究者探索更优训练策略的空间。\n\n四、安全与合规\n\n随着各国AI监管法规的落地，AI基础设施的合规要求日益严格。92%的受访企业表示已设立专门的AI合规团队，较上年的67%有大幅提升。合规成本平均占AI基础设施总投入的8-12%。\n\n报告特别指出，数据本地化要求正在重塑全球AI算力的地理分布。欧盟GDPR的严格执行使得本地数据中心的需求激增，而亚太地区凭借相对灵活的政策环境和较低的能源成本，正在成为新的AI算力中心。\n\n问题：报告中「算力成本下降」和「模型性能提升」之间存在什么因果关系？请结合报告中至少两个段落的内容进行分析，200字以内。",
"elapsed": 6.191,
"cost_est": 0.045,
"expected": [
"算力",
"成本",
"性能",
"训练"
],
"response": "根据报告，算力成本下降与模型性能提升之间存在间接因果关系。\n\n首先，第二段指出过去15个月内每PFLOPS训练成本下降58%，使更多机构能够参与大模型训练，参与10B以上参数模型训练的机构数量增长3.2倍。\n\n其次，第三段明确说明，在算力成本降低50%的条件下，研究者将平均训练时长增加了120%，最终模型在综合基准上的得分平均提升了12个百分点。\n\n因此，算力成本下降并非直接提升模型性能，而是通过降低训练门槛和释放研究空间，让研究者能够进行更长时间、更大规模的训练实验，探索更优的训练策略，从而间接促进了模型性能的提升。",
"task_name": "因果关系推理"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请仔细阅读以下研究论文摘要和正文。\n\n【论文标题】SparseFlash: 面向超长序列的稀疏注意力加速方法\n\n【摘要】\n\nTransformer架构在处理超长序列时面临注意力计算的二次方复杂度瓶颈。本文提出SparseFlash，一种结合动态稀疏模式和硬件感知优化的注意力加速方法。SparseFlash通过两阶段策略实现加速：第一阶段使用轻量级评分网络预测每个query token最相关的key token子集；第二阶段仅在选中的token对之间计算完整注意力。实验表明，在128K序列长度下，SparseFlash相比标准FlashAttention-2实现了4.7倍加速，同时在下游任务上的性能损失不超过0.3%。\n\n【1. 引言】\n\n大型语言模型处理长文档、代码仓库和多轮对话时，需要支持超长上下文窗口。当前主流模型已将上下文长度扩展到100K-1M token，但标准自注意力机制的O(n²)计算复杂度和内存消耗成为严重的效率瓶颈。以128K序列为例，标准注意力需要约128GB的中间存储，即使使用FlashAttention-2优化，单次前向传播仍需约2.4秒（A100 GPU）。\n\n现有的稀疏注意力方法（如Longformer的滑动窗口、BigBird的随机+全局模式）采用固定的稀疏模式，无法自适应地捕获不同输入的注意力分布特征。我们的核心观察是：在实际的长文本处理中，超过90%的注意力权重集中在不到15%的token对上。这为动态稀疏化提供了充分的空间。\n\n【2. 方法】\n\n2.1 轻量级评分网络\n\n我们设计了一个参数量仅为主模型0.5%的评分网络S(q, K)，它接收query向量q和所有key向量的压缩表示，输出每个key position的重要性分数。评分网络使用2层MLP结构，通过对key序列进行分块平均池化（块大小=64）来降低计算量。在128K序列长度下，评分阶段的计算开销仅占总注意力计算的3.2%。\n\n2.2 Top-K选择与注意力计算\n\n基于评分结果，我们为每个query token选择得分最高的K个key token（实验中K设为序列长度的10-20%）。随后仅在选中的(query, key)对之间计算完整的缩放点积注意力。为保持局部连续性，我们始终保留query位置前后256个token的局部窗口。\n\n2.3 硬件感知优化\n\n我们将稀疏注意力计算与FlashAttention的分块策略结合，确保所有内存访问都在GPU的SRAM中完成。具体而言，我们对选中的token索引进行排序和分组，使得同一计算块内的内存访问具有良好的局部性。\n\n【3. 实验结果】\n\n我们在三个基准上评估SparseFlash：（1）长文档QA（NarrativeQA, QuALITY）；（2）代码理解（LCC, RepoBench）；（3）多轮对话摘要（SummScreen）。\n\n主要发现：在128K序列长度下，SparseFlash相比FlashAttention-2实现了4.7倍的端到端加速（0.51秒 vs 2.4秒），峰值内存降低62%（48GB vs 128GB）。在下游任务准确率方面，SparseFlash的平均得分为89.1%，仅比完整注意力的89.4%低0.3个百分点。当序列长度增加到256K时，加速比进一步提升到7.2倍。\n\n消融实验表明，评分网络的准确率对最终性能至关重要：当评分网络的Top-K召回率低于85%时，下游任务性能开始显著下降。我们当前的评分网络在128K长度下的Top-K召回率为92%。\n\n请用中文回答：\n1. 这篇论文要解决什么问题？（一句话）\n2. 提出的方法叫什么？核心思路是什么？（两句话）\n3. 主要实验结论是什么？（一句话）",
"elapsed": 8.972,
"cost_est": 0.045,
"expected": [
"注意力",
"稀疏",
"效率",
"长序列"
],
"response": "1. 这篇论文要解决Transformer在处理超长序列时面临的注意力计算二次方复杂度瓶颈问题。\n\n2. 提出的方法叫SparseFlash，核心思路是使用轻量级评分网络预测每个query最相关的key子集，然后仅在选中的token对之间计算完整注意力。\n\n3. 在128K序列长度下，SparseFlash相比FlashAttention-2实现了4.7倍加速，同时下游任务性能损失仅0.3%。",
"task_name": "论文核心观点提取"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 11.533,
"cost_est": 0.045,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "立场A的核心论点是AI发展速度超过监管能力，需立即实施严格管控。论据包括：欧盟AI法案力度不足、核能和社交媒体的前车之鉴、不能依赖企业自律。逻辑漏洞：过于强调风险而忽视技术进步的益处；\"五年内造成不可逆危害\"缺乏具体证据；全球统一监管在实践中难以实现。\n\n立场B的核心论点是过度监管会扼杀创新，应采取灵活治理。论据包括：人才资本会流向宽松地区、中国等国不会停止发展、开源社区证明禁令无效、互联网得益于早期宽松环境。逻辑漏洞：低估了AI潜在系统性风险；行业自律可能存在利益冲突；互联网类比可能不适用于AI的独特挑战。\n\n两种立场都有合理关切，但都存在极端化倾向。A过度悲观，可能阻碍有益创新；B过度乐观，可能忽视真实风险。实际上，平衡创新与安全需要更细致的分级监管方案。",
"task_name": "观点对比分析"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用中文写一封商务邮件：你是项目经理，需要通知客户项目交付时间从3月30日延期到4月15日，原因是第三方API接口变更导致需要重新对接。语气专业、诚恳，提供补救方案。只返回邮件正文。",
"elapsed": 10.907,
"cost_est": 0.045,
"expected": [
"延期",
"4月15",
"API",
"方案"
],
"response": "尊敬的客户：\n\n您好！\n\n我是负责贵公司项目的项目经理。现就项目交付时间调整事宜与您沟通。\n\n由于我们的第三方API接口供应商临时进行了重大技术升级，接口规范发生较大变更，导致我们需要重新进行系统对接和测试工作。经过团队评估，项目交付时间需要从原定的3月30日延期至4月15日。\n\n对于此次延期给贵公司带来的不便，我们深表歉意。为最大程度减少对贵公司业务的影响，我们制定了以下补救方案：\n\n1. 加派技术人员，确保在4月15日前高质量完成所有功能\n2. 提前交付已完成的核心功能模块，供贵公司先行使用\n3. 延期期间提供免费的技术支持服务\n4. 项目整体费用给予5%的优惠补偿\n\n我们将全力以赴确保项目质量，并在新的时间节点前顺利交付。如您有任何疑问或需要进一步沟通，请随时与我联系。\n\n再次为延期带来的不便致歉，感谢您的理解与支持。\n\n此致\n敬礼！\n\n项目经理：[您的姓名]\n[日期]",
"task_name": "商务邮件"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有5个人参加比赛，已知：\n1. A的名次比B好\n2. C是第3名\n3. D的名次比E好，但比A差\n4. B不是最后一名\n请推理出5个人的排名顺序（第1名到第5名），只回答排名结果。",
"elapsed": 6.698,
"cost_est": 0.045,
"expected": [
"A",
"D",
"C",
"B",
"E"
],
"response": "根据给定条件推理：\n\n从条件2知道C是第3名。\n\n从条件1和3可知：A > B 且 A > D > E\n\n从条件4知道B不是第5名，而D > E，所以E是第5名。\n\n因此B是第4名，D是第2名，A是第1名。\n\n排名顺序：A、D、C、B、E",
"task_name": "逻辑推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "一个日活50万的社交App后端需要选择消息队列，候选方案是 Kafka 和 RabbitMQ。请从吞吐量、延迟、运维复杂度、生态系统、适用场景五个维度做对比，用表格形式输出，最后给出推荐和理由。",
"elapsed": 16.677,
"cost_est": 0.045,
"expected": [
"Kafka",
"RabbitMQ",
"吞吐",
"延迟"
],
"response": "| 维度 | Kafka | RabbitMQ |\n|------|-------|----------|\n| **吞吐量** | • 极高，单机可达百万级TPS<br>• 批量处理，顺序写磁盘<br>• 水平扩展能力强 | • 中等，单机万级到十万级TPS<br>• 单条消息处理<br>• 垂直扩展为主 |\n| **延迟** | • 毫秒到秒级<br>• 批量发送导致延迟较高<br>• 不适合低延迟场景 | • 微秒到毫秒级<br>• 实时性好<br>• 适合低延迟场景 |\n| **运维复杂度** | • 高<br>• 需要ZooKeeper\/KRaft<br>• 集群管理复杂<br>• 参数调优较多 | • 中等<br>• 单机部署简单<br>• 集群管理相对简单<br>• 开箱即用 |\n| **生态系统** | • 丰富<br>• Kafka Streams、Connect<br>• 大数据生态集成好<br>• 社区活跃 | • 成熟<br>• 多语言客户端支持<br>• 插件体系完善<br>• 企业级特性丰富 |\n| **适用场景** | • 日志收集<br>• 流式处理<br>• 事件溯源<br>• 大数据管道 | • 任务队列<br>• RPC通信<br>• 实时通知<br>• 微服务解耦 |\n\n## 推荐方案：RabbitMQ\n\n**推荐理由：**\n\n1. **业务匹配度高**：社交App的核心需求是实时消息推送、通知、聊天等，需要低延迟，RabbitMQ的毫秒级延迟更适合\n\n2. **规模适中**：日活50万的体量，RabbitMQ的性能完全够用，不需要Kafka的超高吞吐量\n\n3. **运维成本低**：团队可以更快上手RabbitMQ，降低运维压力，专注业务开发\n\n4. **功能丰富**：RabbitMQ提供延迟队列、优先级队列、消息确认等特性，适合社交场景的复杂需求\n\n5. **扩展性足够**：如果未来增长到百万日活，RabbitMQ通过集群扩展仍可支撑",
"task_name": "技术选型对比"
}
]
}
|
|||||||
| GPT-o3 | openai | 86.7 | 86.7 | 85.0 | 17.1 | 80.1 | 75.0 |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现函数 length_of_lis(nums)，返回数组中最长严格递增子序列的长度。要求时间复杂度 O(n log n)。只返回函数代码，不要解释。",
"elapsed": 0.885,
"cost_est": 0.025,
"expected": [
"def length_of_lis",
"bisect",
"len("
],
"response": "```python\nfrom bisect import bisect_left\n\ndef length_of_lis(nums):\n if not nums:\n return 0\n\n lis = []\n for num in nums:\n pos = bisect_left(lis, num)\n if pos == len(lis):\n lis.append(num)\n else:\n lis[pos] = num\n\n return len(lis)\n```",
"task_name": "最长递增子序列"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 2.323,
"cost_est": 0.025,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n\n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1\n\n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 2.48,
"cost_est": 0.025,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "最终 `counter.value` 不一定等于 10000。这是因为在多线程环境中，多个线程可能会同时访问和修改 `counter.value`，导致竞态条件问题。\n\n修正方案是使用 `threading.Lock` 来确保对 `counter.value` 的操作是原子的。以下是修正后的完整代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\ndef increment(counter, n):\n for _ in range(n):\n with counter.lock:\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: \n t.start()\nfor t in threads: \n t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请仔细阅读以下技术报告。\n\n【2026年全球AI基础设施发展报告（节选）】\n\n一、总体趋势\n\n2025年全球AI基础设施市场规模达到340亿美元，同比增长87%。这一增速远超此前分析师预测的55%，主要驱动力来自三个方面：大模型训练需求的持续爆发、推理部署规模的快速扩张、以及边缘AI芯片的加速落地。预计到2027年，市场规模将突破800亿美元。\n\n二、算力格局变化\n\nNVIDIA继续主导AI训练芯片市场，占据约72%的份额。但AMD凭借MI300X系列在推理市场取得重大突破，推理芯片市场份额从上年的8%跃升至19%。值得注意的是，Google的TPU v6在内部大规模部署后开始对外开放，其训练效率较TPU v5提升了2.3倍，成本降低了40%。\n\n在算力成本方面，过去15个月内，每PFLOPS的训练成本下降了约58%。这一趋势直接推动了中小型企业和研究机构进入大模型训练领域。数据显示，2025年参与10B以上参数模型训练的机构数量同比增长了3.2倍。\n\n三、模型性能与成本关系\n\n算力成本的大幅下降使得研究者能够进行更大规模、更长时间的训练实验。报告统计了42个主流开源模型的训练过程，发现在算力成本降低50%的条件下，平均训练时长增加了120%，而最终模型在MMLU等综合基准上的得分平均提升了12个百分点。这表明算力成本下降并非简单地降低开支，而是释放了研究者探索更优训练策略的空间。\n\n四、安全与合规\n\n随着各国AI监管法规的落地，AI基础设施的合规要求日益严格。92%的受访企业表示已设立专门的AI合规团队，较上年的67%有大幅提升。合规成本平均占AI基础设施总投入的8-12%。\n\n报告特别指出，数据本地化要求正在重塑全球AI算力的地理分布。欧盟GDPR的严格执行使得本地数据中心的需求激增，而亚太地区凭借相对灵活的政策环境和较低的能源成本，正在成为新的AI算力中心。\n\n问题：报告中「算力成本下降」和「模型性能提升」之间存在什么因果关系？请结合报告中至少两个段落的内容进行分析，200字以内。",
"elapsed": 1.299,
"cost_est": 0.025,
"expected": [
"算力",
"成本",
"性能",
"训练"
],
"response": "报告中指出，算力成本的下降使得研究者能够进行更大规模和更长时间的训练实验（第三部分）。具体而言，过去15个月内每PFLOPS的训练成本下降了约58%（第二部分），这使得更多中小型企业和研究机构能参与大模型训练。降低的算力成本释放了研究者探索更优训练策略的空间，直接导致模型在综合基准上的得分平均提升了12个百分点。这表明，算力成本的下降不仅降低了开支，还促进了模型性能的提升，通过拓展训练规模和优化训练策略实现了更优的结果。",
"task_name": "因果关系推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 2.384,
"cost_est": 0.025,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "立场A的核心论点是AI需要严格监管以避免未来的社会危害。其主要论据包括AI发展速度超越监管能力、历史上先发展后治理带来的高昂代价（如核能、社交媒体），以及科技公司自我约束的不足。逻辑漏洞在于假定严格监管能有效预防所有潜在风险，而没有充分考虑实施全球统一监管的可行性和可能产生的负面影响，如抑制创新。\n\n立场B的核心论点是过度监管会阻碍AI创新。其主要论据包括严格监管会导致人才和资本外流、开源社区的去中心化特性，以及互联网早期发展受益于宽松政策。逻辑漏洞在于假设所有创新都能自我管理，忽视了AI技术可能带来的重大负面影响。此外，过于依赖行业自律可能低估了公司在经济利益驱动下的风险承担倾向。",
"task_name": "观点对比分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下是一份混合了有效信息和无关内容的日志。请只提取与「数据库性能问题」相关的条目，忽略所有其他内容。\n\n[2026-03-10 08:00:12] INFO: 用户张三登录系统\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:02:00] INFO: 定时任务「日报生成」开始执行\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:03:30] INFO: 用户李四上传文件 report.pdf (2.3MB)\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:05:00] INFO: 邮件发送成功，收件人: support@example.com\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:07:00] INFO: 缓存命中率: 94.2%\n[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:09:00] INFO: 前端部署完成 v2.3.1\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n请只列出与数据库性能问题相关的条目（保留原始时间戳和级别），并按严重程度排序，最后用一句话总结根因。",
"elapsed": 1.626,
"cost_est": 0.025,
"expected": [
"连接池",
"慢查询",
"主从延迟",
"超时"
],
"response": "[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47 \n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒) \n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒 \n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000 \n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200 \n\n根因总结：数据库连接池耗尽、慢查询无索引、主从延迟和高连接使用率共同导致性能问题。",
"task_name": "噪音过滤提取"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请将以下新闻压缩为50字以内的中文摘要，保留核心信息：\n\nOpenAI于2026年3月宣布推出GPT-5模型，该模型在推理能力、多模态理解和代码生成方面较GPT-4有显著提升。据OpenAI首席科学家介绍，GPT-5在MMLU测试中得分达到92.3%，超越了此前所有公开模型的成绩。新模型将首先向ChatGPT Plus用户开放，企业API预计在4月上线。分析人士指出，这将进一步加剧AI行业的竞争格局，特别是对Anthropic和Google构成直接压力。",
"elapsed": 1.361,
"cost_est": 0.025,
"expected": [
"GPT-5",
"OpenAI",
"推理",
"MMLU"
],
"response": "OpenAI于2026年3月推出GPT-5，推理、多模态理解和代码生成显著提升，MMLU测试得分92.3%。新模型先向ChatGPT Plus用户开放，企业API 4月上线，加剧AI行业竞争，影响Anthropic和Google。",
"task_name": "新闻摘要"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用一个10岁小学生能理解的方式，解释以下三个技术概念，每个概念用2-3句话：\n1. 分布式系统\n2. 机器学习\n3. 加密算法\n不要使用任何专业术语。",
"elapsed": 2.325,
"cost_est": 0.025,
"expected": [
"分布式",
"机器学习",
"加密"
],
"response": "1. 分布式系统：想象一群小朋友一起完成一个大拼图，每个人负责一小块，这样能更快完成。分布式系统就是把一个大任务分给很多电脑一起做，就像这些小朋友一样。\n\n2. 机器学习：它像一块聪明的橡皮泥，能从很多例子中学习怎么变成不同的形状。就像你从看很多次自行车骑行后，学会了骑车一样。\n\n3. 加密算法：就像你和朋友说悄悄话，用只有你们知道的暗号，这样别人听不懂。加密算法就是让信息变成只有特定的人才能看懂的“暗号”。",
"task_name": "术语解释（通俗化）"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请找出以下段落中的所有错误（事实错误、逻辑错误、语法错误），列出每个错误并给出修正：\n\n\"Python是一种编译型语言，由James Gosling在1989年发明。Python 3.0发布于2012年，完全向后兼容Python 2。Python使用大括号{}来定义代码块，这使得代码非常易读。目前Python最新版本是2.7，广泛用于Web开发和数据科学。\"",
"elapsed": 1.978,
"cost_est": 0.025,
"expected": [
"解释型",
"Guido",
"2008",
"缩进"
],
"response": "1. 错误：Python是一种编译型语言。\n 修正：Python是一种解释型语言。\n\n2. 错误：由James Gosling在1989年发明。\n 修正：Python由Guido van Rossum在1989年发明。\n\n3. 错误：Python 3.0发布于2012年。\n 修正：Python 3.0发布于2008年。\n\n4. 错误：完全向后兼容Python 2。\n 修正：Python 3.0并不完全向后兼容Python 2。\n\n5. 错误：Python使用大括号{}来定义代码块。\n 修正：Python使用缩进来定义代码块。\n\n6. 错误：目前Python最新版本是2.7。\n 修正：目前Python的最新版本是3.x（截至2023年）。\n\n7. 错误：广泛用于Web开发和数据科学。\n 修正：此句本身无错，但为了更准确，可以补充说明Python广泛用于Web开发、数据科学、自动化、人工智能等领域。",
"task_name": "文本纠错"
}
]
}
|
|||||||
| Gemini 2.5 Pro | 100.0 | 63.3 | 85.0 | 62.7 | 44.8 | 74.7 | |
查看 raw_results JSON{
"coding": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 14.824,
"cost_est": 0.005625,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n cleaned_s = \"\".join(filter(str.isalnum, s)).lower()\n return cleaned_s == cleaned_s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现函数 length_of_lis(nums)，返回数组中最长严格递增子序列的长度。要求时间复杂度 O(n log n)。只返回函数代码，不要解释。",
"elapsed": 14.214,
"cost_est": 0.005625,
"expected": [
"def length_of_lis",
"bisect",
"len("
],
"response": "```python\nimport bisect\n\ndef length_of_lis(nums):\n tails = []\n for num in nums:\n i = bisect.bisect_left(tails, num)\n if i == len(tails):\n tails.append(num)\n else:\n tails[i] = num\n return len(tails)\n```",
"task_name": "最长递增子序列"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二叉树的序列化和反序列化。定义 class TreeNode 有 val, left, right 属性。实现两个函数：\n1. serialize(root) → str\n2. deserialize(data) → TreeNode\n要求能互相还原。只返回代码，不要解释。",
"elapsed": 15.218,
"cost_est": 0.005625,
"expected": [
"def serialize",
"def deserialize",
"TreeNode",
"None"
],
"response": "```python\nimport collections\n\nclass TreeNode:\n \"\"\"\n Definition for a binary tree node.\n \"\"\"\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\ndef serialize(root: TreeNode) -> str:\n \"\"\"\n Encodes a tree to a single string using pre-order traversal.\n \n :param root: The root of the binary tree.\n :return: A string representation of the tree.\n \"\"\"\n if not root:\n return \"#\"\n \n res = []\n \n def preorder(node):\n if not node:\n res.append(\"#\")\n return\n res.append(str(node.val))\n preorder(node.left)\n preorder(node.right)\n \n preorder(root)\n return \",\".join(res)\n\ndef deserialize(data: str) -> TreeNode:\n \"\"\"\n Decodes your encoded data to tree.\n \n :param data: A string representation of the tree.\n :return: The root of the decoded binary tree.\n \"\"\"\n if not data or data == \"#\":\n return None\n \n vals = collections.deque(data.split(','))\n \n def build():\n val = vals.popleft()\n if val == \"#\":\n return None\n \n node = TreeNode(int(val))\n node.left = build()\n node.right = build()\n return node\n \n return build()\n```",
"task_name": "二叉树序列化"
}
],
"longctx": [
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请仔细阅读以下技术报告。\n\n【2026年全球AI基础设施发展报告（节选）】\n\n一、总体趋势\n\n2025年全球AI基础设施市场规模达到340亿美元，同比增长87%。这一增速远超此前分析师预测的55%，主要驱动力来自三个方面：大模型训练需求的持续爆发、推理部署规模的快速扩张、以及边缘AI芯片的加速落地。预计到2027年，市场规模将突破800亿美元。\n\n二、算力格局变化\n\nNVIDIA继续主导AI训练芯片市场，占据约72%的份额。但AMD凭借MI300X系列在推理市场取得重大突破，推理芯片市场份额从上年的8%跃升至19%。值得注意的是，Google的TPU v6在内部大规模部署后开始对外开放，其训练效率较TPU v5提升了2.3倍，成本降低了40%。\n\n在算力成本方面，过去15个月内，每PFLOPS的训练成本下降了约58%。这一趋势直接推动了中小型企业和研究机构进入大模型训练领域。数据显示，2025年参与10B以上参数模型训练的机构数量同比增长了3.2倍。\n\n三、模型性能与成本关系\n\n算力成本的大幅下降使得研究者能够进行更大规模、更长时间的训练实验。报告统计了42个主流开源模型的训练过程，发现在算力成本降低50%的条件下，平均训练时长增加了120%，而最终模型在MMLU等综合基准上的得分平均提升了12个百分点。这表明算力成本下降并非简单地降低开支，而是释放了研究者探索更优训练策略的空间。\n\n四、安全与合规\n\n随着各国AI监管法规的落地，AI基础设施的合规要求日益严格。92%的受访企业表示已设立专门的AI合规团队，较上年的67%有大幅提升。合规成本平均占AI基础设施总投入的8-12%。\n\n报告特别指出，数据本地化要求正在重塑全球AI算力的地理分布。欧盟GDPR的严格执行使得本地数据中心的需求激增，而亚太地区凭借相对灵活的政策环境和较低的能源成本，正在成为新的AI算力中心。\n\n问题：报告中「算力成本下降」和「模型性能提升」之间存在什么因果关系？请结合报告中至少两个段落的内容进行分析，200字以内。",
"elapsed": 14.779,
"cost_est": 0.005625,
"expected": [
"算力",
"成本",
"性能",
"训练"
],
"response": "报告揭示了间接的因果关系：算力成本下降并非简单地节约开支，而是通过释放研究潜力来提升模型性能。\n\n根据报告第二、三段内容，每PFLOPS训练成本在15个月内下降了58%。这使得研究者能投入更多资源进行更大规模、更长时间的训练实验（平均训练时长增加120%），进而探索更优的训练策略，最终使模型在MMLU等基准上的得分平均提升了12个百分点。",
"task_name": "因果关系推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "请阅读以下两段文字，它们分别代表对AI监管的两种不同立场。\n\n【立场A】人工智能的发展速度远超监管能力。如果不立即实施严格的全球统一监管框架，AI可能在未来五年内造成不可逆的社会危害。欧盟AI法案是正确的第一步，但力度远远不够。我们需要暂停所有超过一定规模的AI模型训练，直到安全评估体系完善。历史一再证明，先发展后治理的代价是巨大的——核能、社交媒体莫不如此。AI的潜在风险比这些都要大得多。我们不能把人类的命运赌在科技公司的自我约束上。\n\n【立场B】过度监管将扼杀创新。AI技术正处于关键的发展窗口期，严格的监管将使研究人才和资本流向监管宽松的地区。中国和其他国家不会因为西方的监管而停止AI发展。开源AI社区的蓬勃发展证明，去中心化的技术进步无法被简单禁止。我们应该关注的是具体应用场景的治理，而非限制基础技术的研发。行业自律加上针对性的法规，比一刀切的禁令更加务实有效。历史上，互联网的快速发展正是得益于早期的宽松政策环境。\n\n问题：请客观分析两种立场各自的核心论点、论据和逻辑漏洞，300字以内。",
"elapsed": 21.038,
"cost_est": 0.005625,
"expected": [
"监管",
"创新",
"安全",
"风险"
],
"response": "立场A（预防优先）：\n核心论点：AI风险迫在眉睫且巨大，必须立即实施严格的全球统一监管，甚至暂停大型模型研发。\n论据：以核能、社交媒体为鉴，警惕“先发展后治理”模式的巨大代价。\n逻辑漏洞：其全球暂停令的设想在地缘政治竞争现实中可行性低；对“不可逆危害”的界定较为模糊，历史类比的适用性也存疑。\n\n立场B（创新优先）：\n核心论点：过度监管会扼杀创新，应采取务实的、针对具体应用场景的治理方式，并结合行业自律。\n论据：以互联网早期发展为例，证明宽松环境有利创新；禁令无法阻止开源社区和国际竞争者的脚步。\n逻辑漏洞：过度信赖行业自律的历史有效性不足；针对具体应用的治理模式可能对基础模型带来的系统性、未知风险反应滞后。",
"task_name": "观点对比分析"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下是一份混合了有效信息和无关内容的日志。请只提取与「数据库性能问题」相关的条目，忽略所有其他内容。\n\n[2026-03-10 08:00:12] INFO: 用户张三登录系统\n[2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n[2026-03-10 08:02:00] INFO: 定时任务「日报生成」开始执行\n[2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n[2026-03-10 08:03:30] INFO: 用户李四上传文件 report.pdf (2.3MB)\n[2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n[2026-03-10 08:05:00] INFO: 邮件发送成功，收件人: support@example.com\n[2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n[2026-03-10 08:07:00] INFO: 缓存命中率: 94.2%\n[2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n[2026-03-10 08:09:00] INFO: 前端部署完成 v2.3.1\n[2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n\n请只列出与数据库性能问题相关的条目（保留原始时间戳和级别），并按严重程度排序，最后用一句话总结根因。",
"elapsed": 21.117,
"cost_est": 0.005625,
"expected": [
"连接池",
"慢查询",
"主从延迟",
"超时"
],
"response": "* [2026-03-10 08:08:45] CRITICAL: 数据库连接池耗尽，新请求排队等待，队列长度: 47\n* [2026-03-10 08:03:22] ERROR: 查询超时 - SELECT * FROM orders WHERE created_at > '2026-01-01' 执行时间: 32秒\n* [2026-03-10 08:06:33] ERROR: 数据库主从延迟达到12秒，超过告警阈值(5秒)\n* [2026-03-10 08:04:15] WARN: 慢查询告警 - JOIN操作涉及3张表，无索引命中，扫描行数: 2,340,000\n* [2026-03-10 08:10:12] WARN: 磁盘IO等待时间升高，await: 45ms (正常<10ms)\n* [2026-03-10 08:01:45] WARN: 数据库连接池使用率达到85%，当前活跃连接数170\/200\n\n根因总结：由于关键查询缺少索引导致慢查询和高磁盘IO，长时间占用连接，最终引发连接池耗尽和主从延迟。",
"task_name": "噪音过滤提取"
}
],
"knowledge": [
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请将以下英文翻译为流畅的中文技术文档风格：\n\n\"Retrieval-Augmented Generation (RAG) combines the strengths of large language models with external knowledge retrieval. By grounding the model's responses in retrieved documents, RAG significantly reduces hallucinations and improves factual accuracy. The architecture consists of a retriever module that fetches relevant passages from a vector database, and a generator module that synthesizes the final response.\"",
"elapsed": 32.587,
"cost_est": 0.005625,
"expected": [
"检索增强生成",
"幻觉",
"向量数据库",
"检索"
],
"response": "检索增强生成（RAG）结合了大语言模型与外部知识检索的优势。通过将模型的回答基于检索到的文档，RAG显著减少了幻觉并提高了事实准确性。该架构由一个检索器模块和一个生成器模块组成：检索器模块负责从向量数据库中获取相关段落，生成器模块则负责合成最终的回答。",
"task_name": "英译中（技术文档）"
},
{
"ok": true,
"judge": "contains_all",
"score": 10,
"prompt": "有5个人参加比赛，已知：\n1. A的名次比B好\n2. C是第3名\n3. D的名次比E好，但比A差\n4. B不是最后一名\n请推理出5个人的排名顺序（第1名到第5名），只回答排名结果。",
"elapsed": 62.783,
"cost_est": 0.005625,
"expected": [
"A",
"D",
"C",
"B",
"E"
],
"response": "",
"task_name": "逻辑推理"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下是某SaaS产品过去6个月的关键指标：\n\n| 月份 | MRR($) | 新增客户 | 流失客户 | NPS |\n|------|--------|----------|----------|-----|\n| 10月 | 52000 | 45 | 12 | 42 |\n| 11月 | 58000 | 52 | 15 | 40 |\n| 12月 | 55000 | 38 | 22 | 35 |\n| 1月 | 51000 | 30 | 25 | 31 |\n| 2月 | 48000 | 28 | 28 | 28 |\n| 3月 | 44000 | 25 | 32 | 25 |\n\n请分析这组数据，指出核心问题、可能原因和建议对策。用中文回答，300字以内。",
"elapsed": 17.434,
"cost_est": 0.005625,
"expected": [
"流失",
"MRR",
"NPS",
"下降"
],
"response": "**核心问题**：\n公司正陷入增长困境。客户获取能力减弱（新增客户↓），同时客户流失加剧（流失客户↑），导致月度经常性收入（MRR）自11月起持续下滑。净推荐值（NPS）的连续下降表明，客户满意度恶化是问题的根源。\n\n**可能原因**：\n1. **产品问题**：近期产品更新可能存在缺陷、移除了关键功能或导致体验下降。\n2. **服务质量**：客户支持或服务水平下降，无法有效解决客户问题。\n3. **外部竞争**：竞争对手推出了更有吸引力的产品或价格方案。\n\n**建议对策**：\n1. **诊断**：立即对流失客户和NPS低分用户进行访谈，深挖具体不满原因。\n2. **止损**：根据反馈，优先解决抱怨最多的产品缺陷或服务问题，稳定现有客户群。\n3. **恢复**：在问题得到控制后，重新审视并优化客户 onboarding 流程和市场营销信息，确保吸引合适的客户并设定正确预期。",
"task_name": "数据分析"
}
]
}
|
|||||||
#7 轻量评测 done 2026-03-16 00:02:29 2026-03-16 00:05:35 8 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| Qwen Max | alibaba | 100.0 | 100.0 | 100.0 | 84.8 | 100.0 | 97.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.653,
"cost_est": 0.004,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现函数 length_of_lis(nums)，返回数组中最长严格递增子序列的长度。要求时间复杂度 O(n log n)。只返回函数代码，不要解释。",
"elapsed": 1.249,
"cost_est": 0.004,
"expected": [
"def length_of_lis",
"bisect",
"len("
],
"response": "```python\ndef length_of_lis(nums):\n from bisect import bisect_left\n tails = []\n for num in nums:\n pos = bisect_left(tails, num)\n if pos == len(tails):\n tails.append(num)\n else:\n tails[pos] = num\n return len(tails)\n```",
"task_name": "最长递增子序列"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 1.79,
"cost_est": 0.004,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 50.5 | 100.0 | 92.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 2.647,
"cost_est": 0.009,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现函数 length_of_lis(nums)，返回数组中最长严格递增子序列的长度。要求时间复杂度 O(n log n)。只返回函数代码，不要解释。",
"elapsed": 3.061,
"cost_est": 0.009,
"expected": [
"def length_of_lis",
"bisect",
"len("
],
"response": "```python\ndef length_of_lis(nums):\n if not nums:\n return 0\n \n import bisect\n dp = []\n \n for num in nums:\n pos = bisect.bisect_left(dp, num)\n if pos == len(dp):\n dp.append(num)\n else:\n dp[pos] = num\n \n return len(dp)\n```",
"task_name": "最长递增子序列"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 3.378,
"cost_est": 0.009,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
}
]
|
|||||||
| DeepSeek V3 | deepseek | 93.3 | 93.3 | 93.3 | 100.0 | 81.1 | 92.5 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 3.631,
"cost_est": 0.000685,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = left + (right - left) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 2.031,
"cost_est": 0.000685,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n cleaned = re.sub(r'[^a-zA-Z0-9]', '', s).lower()\n return cleaned == cleaned[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 permute_unique(nums)，返回一个可能包含重复数字的列表的所有不重复全排列。例如 [1,1,2] 应返回 [[1,1,2],[1,2,1],[2,1,1]]。只返回函数代码。",
"elapsed": 3.828,
"cost_est": 0.000685,
"expected": [
"def permute_unique",
"sort",
"backtrack"
],
"response": "```python\ndef permute_unique(nums):\n def backtrack(path, counter):\n if len(path) == len(nums):\n res.append(path[:])\n return\n for num in list(counter.keys()):\n if counter[num] > 0:\n path.append(num)\n counter[num] -= 1\n backtrack(path, counter)\n path.pop()\n counter[num] += 1\n\n from collections import Counter\n res = []\n backtrack([], Counter(nums))\n return res\n```",
"task_name": "全排列（去重）"
}
]
|
|||||||
| DeepSeek R1 | deepseek | 86.7 | 86.7 | 86.7 | 99.6 | 81.1 | 87.8 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 6.477,
"cost_est": 0.00137,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 4.308,
"cost_est": 0.00137,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n self.cache.move_to_end(key)\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 4.691,
"cost_est": 0.00137,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "不一定等于10000。原因是多个线程同时读写共享变量 `counter.value` 时可能发生竞争条件，导致部分增加操作丢失。\n\n修正后的完整代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\ndef increment(counter, n):\n for _ in range(n):\n with counter.lock:\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
]
|
|||||||
| Gemini 2.5 Pro | 93.3 | 93.3 | 93.3 | 68.0 | 81.1 | 87.7 | |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 12.964,
"cost_est": 0.005625,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizzbuzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 23.124,
"cost_est": 0.005625,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n self.cache.move_to_end(key)\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 16.772,
"cost_est": 0.005625,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "不一定等于10000。\n\n原因是 `counter.value += 1` 并非原子操作。它包含三个步骤：读取 `counter.value` 的当前值，将该值加1，然后将新值写回 `counter.value`。在多线程环境下，一个线程可能在另一个线程完成这三个步骤之前读取了旧的值，导致更新丢失（即发生了竞态条件 Race Condition）。\n\n修正后的代码如下：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\ndef increment(counter, n):\n for _ in range(n):\n with counter.lock:\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
]
|
|||||||
| GPT-4o | openai | 86.7 | 86.7 | 86.7 | 60.0 | 81.1 | 81.9 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 2.338,
"cost_est": 0.00625,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n \n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1\n \n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二叉树的序列化和反序列化。定义 class TreeNode 有 val, left, right 属性。实现两个函数：\n1. serialize(root) → str\n2. deserialize(data) → TreeNode\n要求能互相还原。只返回代码，不要解释。",
"elapsed": 1.854,
"cost_est": 0.00625,
"expected": [
"def serialize",
"def deserialize",
"TreeNode",
"None"
],
"response": "```python\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\ndef serialize(root):\n def dfs(node):\n if not node:\n vals.append('#')\n return\n vals.append(str(node.val))\n dfs(node.left)\n dfs(node.right)\n\n vals = []\n dfs(root)\n return ' '.join(vals)\n\ndef deserialize(data):\n def dfs():\n val = next(vals)\n if val == '#':\n return None\n node = TreeNode(int(val))\n node.left = dfs()\n node.right = dfs()\n return node\n\n vals = iter(data.split())\n return dfs()\n```",
"task_name": "二叉树序列化"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 1.747,
"cost_est": 0.00625,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "最终 `counter.value` 不一定等于 10000，因为多个线程同时访问和修改 `counter.value` 可能导致竞态条件问题。以下是修正后的代码，使用 `threading.Lock` 来确保线程安全：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\n def increment(self, n):\n for _ in range(n):\n with self.lock:\n self.value += 1\n\ndef increment(counter, n):\n counter.increment(n)\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 93.3 | 93.3 | 93.3 | 10.3 | 81.1 | 79.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二叉树的序列化和反序列化。定义 class TreeNode 有 val, left, right 属性。实现两个函数：\n1. serialize(root) → str\n2. deserialize(data) → TreeNode\n要求能互相还原。只返回代码，不要解释。",
"elapsed": 4.053,
"cost_est": 0.045,
"expected": [
"def serialize",
"def deserialize",
"TreeNode",
"None"
],
"response": "```python\nclass TreeNode:\n def __init__(self, val=0, left=None, right=None):\n self.val = val\n self.left = left\n self.right = right\n\ndef serialize(root):\n def preorder(node):\n if not node:\n vals.append(\"None\")\n return\n vals.append(str(node.val))\n preorder(node.left)\n preorder(node.right)\n \n vals = []\n preorder(root)\n return ','.join(vals)\n\ndef deserialize(data):\n def build():\n val = next(vals)\n if val == \"None\":\n return None\n node = TreeNode(int(val))\n node.left = build()\n node.right = build()\n return node\n \n vals = iter(data.split(','))\n return build()\n```",
"task_name": "二叉树序列化"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码实现LRU缓存，但 get 操作不会更新访问顺序，导致最近访问的元素可能被错误淘汰。请修复代码，使 get 操作也能将元素移到最近使用的位置。要求使用 OrderedDict。只返回修正后的完整类代码。\n\n```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"elapsed": 3.824,
"cost_est": 0.045,
"expected": [
"move_to_end",
"OrderedDict"
],
"response": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n def __init__(self, capacity):\n self.cache = OrderedDict()\n self.capacity = capacity\n \n def get(self, key):\n if key in self.cache:\n self.cache.move_to_end(key)\n return self.cache[key]\n return -1\n \n def put(self, key, value):\n if key in self.cache:\n del self.cache[key]\n elif len(self.cache) >= self.capacity:\n self.cache.popitem(last=False)\n self.cache[key] = value\n```",
"task_name": "Debug：LRU缓存"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 5.19,
"cost_est": 0.045,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "不一定等于10000。\n\n原因：`counter.value += 1` 不是原子操作，它实际上包含三个步骤：读取当前值、加1、写回结果。多个线程同时执行时可能发生竞态条件，导致某些增量操作丢失。\n\n修正后的代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\ndef increment(counter, n):\n for _ in range(n):\n with counter.lock:\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
]
|
|||||||
| GPT-o3 | openai | 86.7 | 86.7 | 86.7 | 17.2 | 81.1 | 75.4 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.652,
"cost_est": 0.025,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "请用Python实现函数 min_distance(word1, word2)，计算将 word1 转换为 word2 所需的最少操作数（插入、删除、替换各算一次操作）。只返回函数代码。",
"elapsed": 1.899,
"cost_est": 0.025,
"expected": [
"def min_distance",
"dp",
"replace",
"insert"
],
"response": "```python\ndef min_distance(word1, word2):\n m, n = len(word1), len(word2)\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n \n for i in range(m + 1):\n dp[i][0] = i\n for j in range(n + 1):\n dp[0][j] = j\n\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if word1[i - 1] == word2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1]\n else:\n dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])\n\n return dp[m][n]\n```",
"task_name": "编辑距离"
},
{
"ok": true,
"judge": "contains_any",
"score": 80,
"prompt": "以下Python代码使用多线程对一个计数器累加10000次，每次+1。请问最终 counter.value 一定等于10000吗？如果不一定，请解释原因并给出修正方案（使用 threading.Lock）。返回修正后的完整代码。\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n\ndef increment(counter, n):\n for _ in range(n):\n counter.value += 1\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"elapsed": 2.111,
"cost_est": 0.025,
"expected": [
"Lock",
"acquire",
"release"
],
"response": "最终 `counter.value` 不一定等于 10000，因为 `counter.value += 1` 操作不是原子的，在多线程环境中可能导致竞态条件。为了解决这个问题，可以使用 `threading.Lock` 来确保对 `counter.value` 的增操作是线程安全的。以下是修正后的代码：\n\n```python\nimport threading\n\nclass Counter:\n def __init__(self):\n self.value = 0\n self.lock = threading.Lock()\n\n def increment(self, n):\n for _ in range(n):\n with self.lock:\n self.value += 1\n\ndef increment(counter, n):\n counter.increment(n)\n\ncounter = Counter()\nthreads = [threading.Thread(target=increment, args=(counter, 5000)) for _ in range(2)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nprint(counter.value)\n```",
"task_name": "并发竞态分析"
}
]
|
|||||||
#6 轻量评测 done 2026-03-15 23:50:08 2026-03-15 23:51:52 7 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| DeepSeek R1 | deepseek | 100.0 | 100.0 | 100.0 | 99.9 | 100.0 | 100.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 4.314,
"cost_est": 0.00137,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = left + (right - left) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 2.395,
"cost_est": 0.00137,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n s = re.sub(r'[^a-zA-Z0-9]', '', s.lower())\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.673,
"cost_est": 0.00137,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4]\n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| DeepSeek V3 | deepseek | 94.4 | 94.4 | 94.4 | 100.0 | 84.3 | 93.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 3.809,
"cost_est": 0.000685,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 2.337,
"cost_est": 0.000685,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n s = re.sub(r'[^a-zA-Z0-9]', '', s.lower())\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.733,
"cost_est": 0.000685,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4]\n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 50.5 | 100.0 | 92.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 3.163,
"cost_est": 0.009,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n \n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 1.85,
"cost_est": 0.009,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) as total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.734,
"cost_est": 0.009,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
}
]
|
|||||||
| Qwen Max | alibaba | 94.4 | 94.4 | 94.4 | 82.7 | 84.3 | 91.1 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 1.035,
"cost_est": 0.004,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n return ['FizzBuzz' if i % 15 == 0 else 'Buzz' if i % 5 == 0 else 'Fizz' if i % 3 == 0 else str(i) for i in range(1, n+1)]\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 1.397,
"cost_est": 0.004,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.651,
"cost_est": 0.004,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| GPT-4o | openai | 94.4 | 94.4 | 94.4 | 63.8 | 84.3 | 88.3 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.087,
"cost_est": 0.00625,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n return ['FizzBuzz' if i % 15 == 0 else 'Fizz' if i % 3 == 0 else 'Buzz' if i % 5 == 0 else i for i in range(1, n+1)]\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.764,
"cost_est": 0.00625,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.712,
"cost_est": 0.00625,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_spent\nFROM orders\nGROUP BY user_id\nORDER BY total_spent DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 11.1 | 100.0 | 86.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.609,
"cost_est": 0.045,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizzbuzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.48,
"cost_est": 0.045,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n \n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 2.31,
"cost_est": 0.045,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
}
]
|
|||||||
| GPT-o3 | openai | 94.4 | 94.4 | 94.4 | 18.7 | 84.3 | 81.5 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.131,
"cost_est": 0.025,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n return ['FizzBuzz' if i % 15 == 0 else 'Fizz' if i % 3 == 0 else 'Buzz' if i % 5 == 0 else i for i in range(1, n + 1)]\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.572,
"cost_est": 0.025,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n s = re.sub(r'[^a-zA-Z0-9]', '', s).lower()\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 1.296,
"cost_est": 0.025,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
#5 轻量评测 done 2026-03-15 23:42:21 2026-03-15 23:43:29 5 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| Qwen Max | alibaba | 100.0 | 100.0 | 100.0 | 84.8 | 100.0 | 97.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 1.267,
"cost_est": 0.004,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.723,
"cost_est": 0.004,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n import re\n s = s.lower()\n s = re.sub('[^a-z0-9]', '', s)\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.524,
"cost_est": 0.004,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4]\n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| GPT-4o | openai | 100.0 | 100.0 | 100.0 | 66.4 | 100.0 | 95.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.274,
"cost_est": 0.00625,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = left + (right - left) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.509,
"cost_est": 0.00625,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n s = re.sub(r'[^a-zA-Z0-9]', '', s).lower()\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.807,
"cost_est": 0.00625,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 50.5 | 100.0 | 92.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.538,
"cost_est": 0.009,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizzbuzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.512,
"cost_est": 0.009,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.871,
"cost_est": 0.009,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n cleaned = ''.join(c.lower() for c in s if c.isalnum())\n return cleaned == cleaned[::-1]\n```",
"task_name": "回文判断"
}
]
|
|||||||
| GPT-o3 | openai | 100.0 | 100.0 | 100.0 | 19.7 | 100.0 | 88.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.999,
"cost_est": 0.025,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\nimport re\n\ndef is_palindrome(s):\n s = re.sub(r'[^a-zA-Z0-9]', '', s).lower()\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 1.026,
"cost_est": 0.025,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.757,
"cost_est": 0.025,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4]\n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 11.1 | 100.0 | 86.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.51,
"cost_est": 0.045,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizzbuzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.983,
"cost_est": 0.045,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n s = ''.join(c.lower() for c in s if c.isalnum())\n return s == s[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 1.766,
"cost_est": 0.045,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) as total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
#4 轻量评测 done 2026-03-15 23:21:42 2026-03-15 23:23:26 8 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| Claude Sonnet 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 50.5 | 100.0 | 92.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 2.452,
"cost_est": 0.009,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizzbuzz(n):\n result = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n result.append(\"FizzBuzz\")\n elif i % 3 == 0:\n result.append(\"Fizz\")\n elif i % 5 == 0:\n result.append(\"Buzz\")\n else:\n result.append(i)\n return result\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 5.008,
"cost_est": 0.009,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.766,
"cost_est": 0.009,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
}
]
|
|||||||
| GPT-4o | openai | 94.4 | 94.4 | 94.4 | 63.8 | 84.3 | 88.3 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83.3,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 1.147,
"cost_est": 0.00625,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "```python\ndef fizz_buzz(n):\n return [\"FizzBuzz\" if i % 15 == 0 else \"Fizz\" if i % 3 == 0 else \"Buzz\" if i % 5 == 0 else i for i in range(1, n + 1)]\n```",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 1.922,
"cost_est": 0.00625,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.678,
"cost_est": 0.00625,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n filtered_chars = [c.lower() for c in s if c.isalnum()]\n return filtered_chars == filtered_chars[::-1]\n```",
"task_name": "回文判断"
}
]
|
|||||||
| GPT-o3 | openai | 100.0 | 100.0 | 100.0 | 19.7 | 100.0 | 88.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.956,
"cost_est": 0.025,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 1.53,
"cost_est": 0.025,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n filtered_chars = [char.lower() for char in s if char.isalnum()]\n return filtered_chars == filtered_chars[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.839,
"cost_est": 0.025,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4]\n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 11.1 | 100.0 | 86.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 5.465,
"cost_est": 0.045,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n \n while left <= right:\n mid = (left + right) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 3.689,
"cost_est": 0.045,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "```python\ndef is_palindrome(s):\n cleaned = ''.join(char.lower() for char in s if char.isalnum())\n return cleaned == cleaned[::-1]\n```",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 2.31,
"cost_est": 0.045,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) as total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| DeepSeek R1 | deepseek | 0.0 | 0.0 | 0.0 | 0.0 | 100.0 | 15.0 |
查看 raw_results JSON[
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0,
"cost_est": 0.00137,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "",
"task_name": "FizzBuzz"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0,
"cost_est": 0.00137,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "",
"task_name": "二分查找"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0,
"cost_est": 0.00137,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "",
"task_name": "代码输出预测"
}
]
|
|||||||
| DeepSeek V3 | deepseek | 0.0 | 0.0 | 0.0 | 0.0 | 100.0 | 15.0 |
查看 raw_results JSON[
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0,
"cost_est": 0.000685,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "",
"task_name": "二分查找"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0,
"cost_est": 0.000685,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "",
"task_name": "回文判断"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0,
"cost_est": 0.000685,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Gemini 2.5 Pro | 0.0 | 0.0 | 0.0 | 0.0 | 100.0 | 15.0 | |
查看 raw_results JSON[
{
"ok": false,
"error": "models\/gemini-2.5-pro-preview-05-06 is not found for API version v1beta, or is not supported for generateContent. Call ListModels to see the list of available models and their supported methods.",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.968,
"cost_est": 0.005625,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "",
"task_name": "FizzBuzz"
},
{
"ok": false,
"error": "models\/gemini-2.5-pro-preview-05-06 is not found for API version v1beta, or is not supported for generateContent. Call ListModels to see the list of available models and their supported methods.",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.927,
"cost_est": 0.005625,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "",
"task_name": "回文判断"
},
{
"ok": false,
"error": "models\/gemini-2.5-pro-preview-05-06 is not found for API version v1beta, or is not supported for generateContent. Call ListModels to see the list of available models and their supported methods.",
"judge": "contains_all",
"score": 0,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.932,
"cost_est": 0.005625,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "",
"task_name": "代码输出预测"
}
]
|
|||||||
| Qwen Max | alibaba | 0.0 | 0.0 | 0.0 | 0.0 | 100.0 | 15.0 |
查看 raw_results JSON[
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0,
"cost_est": 0.004,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "",
"task_name": "FizzBuzz"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0,
"cost_est": 0.004,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "",
"task_name": "回文判断"
},
{
"ok": false,
"error": "DeepSeek API Key未配置",
"judge": "contains_all",
"score": 0,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0,
"cost_est": 0.004,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "",
"task_name": "代码输出预测"
}
]
|
|||||||
#3 轻量评测 done 2026-03-15 23:20:56 2026-03-15 23:21:27 2 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| GPT-4o | openai | 100.0 | 100.0 | 100.0 | 66.4 | 100.0 | 95.0 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.708,
"cost_est": 0.00625,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n while left <= right:\n mid = left + (right - left) \/\/ 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 1.609,
"cost_est": 0.00625,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.778,
"cost_est": 0.00625,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[2, 3, 4] \n[5, 4, 3, 2, 1]",
"task_name": "代码输出预测"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 100.0 | 100.0 | 100.0 | 50.5 | 100.0 | 92.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 2.843,
"cost_est": 0.009,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "```python\ndef binary_search(arr, target):\n left, right = 0, len(arr) - 1\n \n while left <= right:\n mid = (left + right) \/\/ 2\n \n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n \n return -1\n```",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 2.235,
"cost_est": 0.009,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "```sql\nSELECT user_id, SUM(amount) AS total_amount\nFROM orders\nGROUP BY user_id\nORDER BY total_amount DESC\nLIMIT 10;\n```",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 100,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 1.712,
"cost_est": 0.009,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "```\n[2, 3, 4]\n[5, 4, 3, 2, 1]\n```",
"task_name": "代码输出预测"
}
]
|
|||||||
#2 轻量评测 done 2026-03-15 23:11:11 2026-03-15 23:11:13 8 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| GPT-4o | openai | 85.7 | 85.7 | 85.7 | 59.5 | 84.5 | 81.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 95,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 76,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
},
{
"ok": true,
"judge": "contains_all",
"score": 86,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "代码输出预测"
}
]
|
|||||||
| DeepSeek V3 | deepseek | 77.7 | 77.7 | 77.7 | 100.0 | 80.4 | 81.5 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 77,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 66,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 90,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "代码输出预测"
}
]
|
|||||||
| DeepSeek R1 | deepseek | 73.7 | 73.7 | 73.7 | 99.1 | 94.3 | 80.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 77,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 70,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 74,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Gemini 2.5 Pro | 80.3 | 80.3 | 80.3 | 61.3 | 91.0 | 79.1 | |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 83,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 84,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 74,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Qwen Max | alibaba | 75.7 | 75.7 | 75.7 | 73.8 | 96.6 | 78.6 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 78,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 74,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 75,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 85.0 | 85.0 | 85.0 | 9.4 | 78.6 | 72.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 70,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 91,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 94,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 69.3 | 69.3 | 69.3 | 36.7 | 84.6 | 66.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 80,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 62,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 66,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| GPT-o3 | openai | 71.3 | 71.3 | 71.3 | 14.2 | 85.7 | 64.9 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 69,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 81,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 64,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "代码输出预测"
}
]
|
|||||||
#1 轻量评测 done 2026-03-15 23:04:56 2026-03-15 23:04:59 8 模型
| 模型 | 厂商 | 编程 | 知识 | 长上下文 | 性价比 | 稳定性 | 综合 |
|---|---|---|---|---|---|---|---|
| DeepSeek R1 | deepseek | 86.7 | 86.7 | 86.7 | 99.6 | 88.2 | 88.9 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 95,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 83,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 82,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "代码输出预测"
}
]
|
|||||||
| Gemini 2.5 Pro | 85.3 | 85.3 | 85.3 | 64.0 | 86.8 | 82.3 | |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 94,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 78,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 84,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Qwen Max | alibaba | 80.7 | 80.7 | 80.7 | 76.5 | 92.5 | 81.8 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 78,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 78,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 86,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| GPT-4o | openai | 85.7 | 85.7 | 85.7 | 59.5 | 79.3 | 80.8 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 93,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 71,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 93,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| DeepSeek V3 | deepseek | 68.3 | 68.3 | 68.3 | 100.0 | 83.0 | 75.3 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 65,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 60,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 80,
"prompt": "以下Python代码的输出是什么？请只回答输出结果。\n\n```python\nx = [1, 2, 3, 4, 5]\nprint(x[1:4])\nprint(x[::-1])\n```",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"[2, 3, 4]",
"[5, 4, 3, 2, 1]"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "代码输出预测"
}
]
|
|||||||
| GPT-o3 | openai | 84.0 | 84.0 | 84.0 | 16.6 | 78.4 | 73.1 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 94,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 89,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 69,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
}
]
|
|||||||
| Claude Sonnet 4.6 | anthropic | 75.7 | 75.7 | 75.7 | 39.7 | 83.6 | 71.5 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 68,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 87,
"prompt": "请用Python写一个函数 is_palindrome(s)，判断字符串是否是回文（忽略大小写和非字母数字字符）。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def is_palindrome",
"lower",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "回文判断"
},
{
"ok": true,
"judge": "contains_all",
"score": 72,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||
| Claude Opus 4.6 | anthropic | 68.0 | 68.0 | 68.0 | 7.5 | 92.9 | 62.7 |
查看 raw_results JSON[
{
"ok": true,
"judge": "contains_all",
"score": 66,
"prompt": "请用Python写一个FizzBuzz函数：输入整数n，返回1到n的列表，其中3的倍数替换为\"Fizz\"，5的倍数替换为\"Buzz\"，同时是3和5的倍数替换为\"FizzBuzz\"。只返回函数代码，不要解释。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def fizzbuzz",
"FizzBuzz",
"Fizz",
"Buzz",
"% 3",
"% 5"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "FizzBuzz"
},
{
"ok": true,
"judge": "contains_all",
"score": 73,
"prompt": "请用Python实现二分查找函数 binary_search(arr, target)，找到返回索引，找不到返回-1。只返回函数代码。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"def binary_search",
"mid",
"left",
"right",
"return"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "二分查找"
},
{
"ok": true,
"judge": "contains_all",
"score": 65,
"prompt": "有一张 orders 表，字段为 id, user_id, amount, created_at。请写一条SQL查询：找出每个用户的总消费金额，按金额降序排列，只返回前10名。只返回SQL语句。",
"elapsed": 0.1,
"cost_est": 0,
"expected": [
"SELECT",
"SUM",
"GROUP BY",
"ORDER BY",
"LIMIT"
],
"response": "[DRY RUN] 模拟回答：这是一个模拟的 AI 响应",
"task_name": "SQL聚合查询"
}
]
|
|||||||