本地化部署 Qwen3.8-Flash-Next 能不能打平云端 API?四轮 33 题程序化对比实录
大模型用云端 API 还是本地部署,争论了很久。支持云端的说”本地小模型能力差一截”,支持本地的说”数据在手、零 API 费”。空谈无益,我做了个对比实验:把一台本地工作站跑的 Qwen3.8(量化到 4 bit)和云端 GLM-5.3-flash 拉到同一张卷子上,四轮 33 道题,全部机器判卷,没有一道”感觉分”。
结果先说:33 题中 29 道可机器判分,本地全对,云端错 1 题——29:28。前三轮一直平手,第四轮拉到竞赛级难度、首次加入真实工具调用题,才分出这 1 题。速度上,通识和数学题本地快约 2~3 倍,代码题打平。这个难度区间内,电费换 API 费这笔账是成立的。
一、测试对象
| 本地 | 云端 | |
|---|---|---|
| 模型 | Qwen3.8-Flash-Next(NVFP4 量化版) | GLM-5.3-flash(带思考模式) |
| 引擎 | Strata 0.1.58(MoE 混合推理) | 智谱 Anthropic 兼容端点 |
| 硬件 | 单卡工作站 | 云端集群 |
| 实测速度 | 满显存约 55 tok/s | 整体约 60 tok/s(含思考) |
两款模型是 2026 年 8 月 26 日同日发布的”对手局”。第三方横评(DataCamp,见文末参考)的口径可作旁证:两者 API 标价几乎持平,重叠编程基准 GLM 略领先;而每 token 激活参数 Qwen 60 亿、GLM 180 亿——这 3 倍差距是硬件侧最清晰的分野,也是本地部署的讨论更常落在 Qwen 一侧的原因。
本地工作站的具体配置:
| 部件 | 配置 |
|---|---|
| GPU | NVIDIA L20(48 GB 显存) |
| CPU | Intel Core i7-13700(24 线程) |
| 内存 | 128 GB |
| 存储 | 2 TB NVMe 系统盘(模型热文件常驻) |
| CUDA | 驱动 580.178.04;引擎按 CUDA 13.0 工具链编译(用户态安装,与系统原有 12.8 共存) |
| 资源占用 | 显存 44.9/45 GB;引擎进程内存约 68 GB(冷专家与 KV 常驻主存);推理满载时 CPU 24 线程 80–99%、GPU 功耗 178–204 W |
| 上下文 | 本次实测 26 万 token(能否上 1M 见下文) |
两条配置说明:模型热文件放 NVMe 不是讲究,是必须——机械盘的随机读会把推理拖垮;CUDA 13.0 用户态安装(免 root、不污染系统)是因为 CUDA 13 放宽了内核形参空间上限,该引擎必须用 13 才能编译通过。另外这套 MoE(混合专家)架构推理时热专家进显存、冷专家走 CPU 算,所以 GPU 和 CPU 会同时吃满;26 万 token 的上下文窗口对本地部署来说相当奢侈。
下载地址(复现用):基座模型 Qwen/Qwen3.8-Flash-Next(125B 混合 MoE);本文用的 NVFP4 量化版 Maximilian228/Qwen3.8-Flash-Next-NVFP4-GPTQ-Strata(GPTQ 量化,官方数据与 Q8_0 的 top-token 一致率 93.6%);推理引擎 sergqwer/strata-nvfp4。
能不能上 1M 上下文? 机制上引擎按 --max-context 参数开放,没有写死的上限;但 KV 缓存——注意力机制为每个历史 token 保留的中间状态——显存占用随上下文线性增长,本次 26 万 token 配置下 48 GB 显存已接近吃满(44.9/45 GB),直接翻四倍到 1M 单卡放不下。可行的路子:引擎支持更激进的 KV 量化(如 --kv q4_0)和 KV 非驻留模式(不常驻显存、分页用主存,本机 128 GB 内存有承接空间)——理论上限可以更高,代价是速度。
二、方法:让机器当裁判
主观打分(“我觉得这个答案好”)不可复现,所以四轮所有计分题都设计成唯一答案或可执行验证:
- 数学题:对唯一数值答案(如”n! 末尾恰好有 100 个连续的零,求最小 n”);
- 代码题:把双方答案真的抓来执行,跑出题时埋好的隐藏测试集(含边界用例),通过才算对;
- 调错题:给一段埋了雷的函数,修完跑同一套测试;
- 约束题:逐条核对(字数上限、枚举值、日期推算、纯 JSON 输出);
- 工具调用题(第四轮新增):给双方挂同一套真实工具(查城市统计、查部门人数、跑 SQL),模型请求调用→框架真实执行→结果回喂→模型作答;本地走 OpenAI tool_calls 协议、云端走 Anthropic tool_use 协议,判分看工具是否真被正确调用以及答案是否来自真实返回值。
出题后先做的事是给判分器自证:用参考实现加暴力枚举把隐藏测试集全部预验一遍(还真抓出过判分器自己的三处 bug,故事放在文末插曲)。
判卷的是谁?是否无偏? 判卷的不是任何大模型,而是一套确定性的 Python 程序:数学题比对唯一参考答案、代码题把双方代码送进同一组隐藏测试集真实执行、约束题逐条核对。它没有任何”判卷模型”,因此不存在模型打分的偏袒问题——输出只取决于答案本身,同一把尺子量两边,任何人复跑同一套脚本会得到完全相同的分数。判卷环节的残余风险有两个:一是判分器自身缺陷(上卷前已自证预验、比分以复核后为准,详见文末插曲);二是题型设计出自 AI 助手之手,其服务端模型 GLM-5.3 与参评的 GLM-5.3-flash 同系——这一点无法用程序消除,见文末利益冲突声明。
三、四轮比分
| 轮次 | 题量 | 本地 | GLM | 本地耗时 | GLM 耗时 |
|---|---|---|---|---|---|
| 中等轮(常识/数学/代码/翻译/约束) | 12(可判分 8) | 8/8 | 8/8 | 58s | 172s |
| 难题轮(竞赛数学/经典算法/调错/多约束) | 7 | 7/7 | 7/7 | 67s | 128s |
| 代码专项(数据结构/重试器/调错/真实脚本改造/日志解析/限流器) | 6 | 6/6 | 6/6 | 110s | 105s |
| 第四轮:加难+工具(错排计数/丢番图/表达式求值器/性能/修树状数组 + 真实工具调用 3 题) | 8 | 8/8 | 7/8 | 71s | 104s |
| 合计 | 33(客观 29) | 29:28 本地小胜 | 306s | 508s |
第四轮 8 题整体跑了两次,两次比分一致(复现验证)。几道代表性的难题:
- n! 末尾恰好 100 个连续零,最小 n = 405;
- x² + y² = 2025 的正整数解按 x ≤ y 归并,恰好 1 组:(27, 36);
- 滑动窗口限流器里最阴的一题语义——”被拒绝的调用不占名额”,双方实现都正确;
- 第四轮的错排计数 C(10,3)×D(7) = 222480(错排——全排错的方式数),双方都算对;
- 同轮的手写表达式求值器(递归下降解析),本地全对,GLM 两次运行翻了同一个车——这一题就是全部 1 题分差的来源,详见下节。
四、几个有意思的细节
1. 云端爱”超纲发挥”。 GLM 答对之余常附赠延伸:指出 405–409 连续五个 n 的阶乘都恰好 100 个零、用”模 4 余 1 的素数”论证勾股三角形唯一。思考 token 烧得有价值,但也是它三轮烧掉约 2.6 万输出 token(其中思考文本约 6.8 万字符)的原因。
2. 本地是个话痨。 代码专项轮题面写明”只给代码”,本地仍输出大量解释,6 题写了 10,940 token;同一题面 GLM 只给 7,273 token,极简。啰嗦不影响判分,但影响你的等待时间。
3. 速度不是一条直线。 中等轮本地快 3 倍(58s 对 172s),难题轮快约 2 倍,到代码专项轮第一次打平甚至略慢(GLM 105s 对本地 110s);第四轮本地又拉开(71s 对 104s)。规律:题目越”套路”,本地纯吞吐优势越大;题目越需要思考,云端的思考时间会把差距抹平。
4. 调错题双方满分。 埋的两个雷——循环范围差一(off-by-one,漏掉区间端点)和”解析失败的行静默丢弃”(恰恰是生产事故的高发模式)——双方都精准定位并修复。这类题量化小模型已经做得很好。
5. 全部 1 题分差,来自 Python 闭包作用域的经典坑。 第四轮的手写表达式求值器(自己写一个支持一元负号、左结合、嵌套括号的递归下降解析器,10 个隐藏用例对照执行),GLM 的算法思路完全正确,但 6 处 pos += 1 忘写 nonlocal pos——Python 里内层函数想改外层变量必须先声明 nonlocal,否则会在内层静默新建同名局部变量——运行时直接 UnboundLocalError。两次独立运行,两次翻在同一个坑。这不是”不会写”,是”写长了忘了收尾”,教科书级经典坑,多大的模型都会踩。
6. 工具调用,双方全对。 第四轮 3 道真实工具题(查城市统计算人均 GDP、跨城市对比人口差、SQL 查最高销售额月份),双方各自走 OpenAI tool_calls 与 Anthropic tool_use 两种协议,但对接同一套工具执行器:全部一次调对、参数合法、答案基于真实返回值;需要连续查两个城市再作差的多步聚合,双方也都自己规划对了调用顺序。工具调用是 AI 助手类应用的地基,这道地基本地量化模型已经稳了。
插曲:判分器自己翻过的车
机器判卷听起来客观,但判分器也是程序,程序也会有缺陷,如实交代。判分器上线前要过一道”自证”——用参考实现和暴力枚举预先验证隐藏测试集本身,这一道还真拦下了三处问题:出题人凭”经典例题”记忆写错的最短窗口期望值(用暴力枚举重新裁决出正确答案)、异常对象转字符串自带引号导致的严格相等误判、压测题的假响应装置缺少真实响应对象的属性而误伤双方合规答案。第四轮上卷前自证又拦下四处出题人手误,最典型的一处:丢番图最小值手算记成 289,判分器内置的暴力全枚举算出真值是 290(|288|+|2|),按枚举结果纠正——暴力枚举比出题人可靠。另外中等轮初判本地 5:7,复盘发现本地 3 题是输出配额截断的假阴性(答案正确但被截断),放宽配额补跑后修正;云端也有 1 题被判分器的格式要求误伤,人工复核后修正——正文比分均为复核后结果。处理原则只有一条:判分器的任何修正都对称适用于双方,记录留档可复查(附录中每题都标注判分依据与复核标记)。
五、结论与边界
结论:在可程序判分的任务上(含真实工具调用),这台 48 GB 显存的本地机与云端旗舰 flash 级模型四轮合计 29:28,实质打平——唯一的 1 题分差来自云端翻在 Python 闭包作用域这个经典坑上,属于”失误”而非”能力差距”。如果你的使用场景是数学、代码、格式约束、工具调用这类有客观对错的活儿,本地部署可以直接选 Qwen3.8-Flash-Next:零 API 费、数据不出门,可判分能力又与云端 flash 打平;第三方横评也把”本地部署”的一票投给了它——每 token 激活参数只有 GLM 的三分之一,两家 API 标价却几乎持平(见参考)。
没测的部分:多模态能力(两家都是原生多模态模型,支持图像/视频输入,但本文 33 题全部是纯文本题,这项能力完全未测)、超长上下文(本地 26 万窗口理论占优但未测)、冷门知识面、开放式写作质量——这些要么需要专门设计测试,要么需要人当裁判,本文不下结论。
成本对账:云端前三轮 25,840 输出 token(第四轮工具题未单独计量);本地四轮只有电费。按 flash 档价格,这个量级单次不贵,但如果是日常高频使用,差距会滚大。
六、利益冲突声明
评测流程由 AI 编程助手设计并执行,而驱动该助手的服务端模型正是 GLM-5.3(与参评的 GLM-5.3-flash 同系)。缓解因素:全部判分是程序执行结果,不存在人为打分,原始记录完整存档可复查;无法缓解的因素:题型选择出自它手。知情权交给读者,结论请带着这条声明使用。
参考文档
- DataCamp:《GLM-5.3-Flash vs Qwen3.8-Flash-Next:编程、成本与可用性》(datacamp.com/zh/blog/glm-5-3-flash-vs-qwen3-8-flash-next,2026-08-31)——两款模型的参数规模、API 标价与公开基准的第三方对照;本文”每 token 激活 60 亿 vs 180 亿””API 标价几乎持平”两个口径引自此文。
术语表
- 量化(NVFP4):把模型权重从 16 bit 压缩到 4 bit 存储和计算,显存占用大降,精度损失可控。NVFP4 是 NVIDIA 定义的 4 bit 浮点格式。
- MoE(混合专家):模型内含大量”专家”子网络,每次推理只激活一小部分,可按冷热分层放进显存或内存。
- tok/s:每秒生成的 token(词元)数,衡量生成速度。
- 思考(thinking)token:推理模型先在内部”打草稿”再作答,草稿部分也消耗配额和时延。
- A/B 测试:同一输入分别喂给两个系统,横向比对输出。
- 隐藏测试集(执行判分):把模型的代码答案真实执行,跑出题时预留的测试用例(含边界)验证行为。
- off-by-one:循环或多取范围”差一”的经典编程错误。
- nonlocal:Python 关键字。内层函数想修改外层函数的变量必须先声明 nonlocal,否则会在内层静默新建同名局部变量,运行时报”变量未赋值就被使用”。
- 工具调用(tool calling):模型按需请求外部程序代劳(查数据、跑 SQL),拿到真实执行结果再继续作答;AI 助手类应用的地基能力。
- 错排(D(7)):把 7 个元素全部放错位置的排列方式数,组合数学经典计数。
- 递归下降解析器:一层层”读一个运算符再读下一个数”地直接把语法规则翻译成代码的解析器写法。
- 幂等:同一操作执行多次与执行一次效果相同,重复调用不会做坏。
- dry-run:演练模式,只走流程不真正写入,常用于上线前验证。
附录:33 题全清单、判分依据与双方答案节选
判卷全部为确定性程序(比对答案 / 执行隐藏测试 / 逐条核对),每题给出判分依据。节选为答案开头约 10 行(保留换行),完整原文在评测存档中。标记 ✔ = 判分通过,✔* = 经复核修正后通过(中等轮本地 3 题为输出配额截断假阴性、放宽配额补跑后通过;GLM 1 题为格式要求误伤、人工复核通过);“—不计分” = 开放题,无程序判分,不计入比分。第四轮 8 题整体两跑复现、比分一致;工具调用题的“工具调用记录”为评测框架真实执行并回喂的调用明细(本地走 OpenAI tool_calls 协议、云端走 Anthropic tool_use 协议,同一套工具执行器)。
中等轮(12 题)
q1_鸡兔同笼 · 本地 ✔ 5.5s · GLM ✔ 10.3s
题目:一个笼子里有鸡和兔共 35 个头、94 只脚。鸡和兔各有多少只?给出计算过程和最终答案。
判分依据:答案比对:鸡 23 / 兔 12,且需出现鸡兔字样
本地答案节选:
设鸡有 (x) 只,兔有 (y) 只。 根据题意: 1. 头的总数: [ x + y = 35 ] 2. 脚的总数:鸡有 2 只脚,兔有 4 只脚: …
GLM 答案节选:
# 鸡兔同笼问题 ## 已知条件 - 鸡和兔总头数:35 个 - 鸡和兔总脚数:94 只 - 每只鸡有 2 只脚,每只兔有 4 只脚 ## 方法一:方程法 设鸡有 $x$ 只,兔有 $y$ 只,可列方程组: …
q2_求和 · 本地 ✔ 1.6s · GLM ✔ 4.1s
题目:从 1 加到 100,总和是多少?给出一行算式。
判分依据:答案比对:5050
本地答案节选:
1 + 2 + ... + 100 = (1 + 100) × 100 ÷ 2 = 5050
GLM 答案节选:
**1 + 2 + 3 + ⋯ + 100 = (1 + 100) × 100 ÷ 2 = 5050** 这是等差数列求和公式:首项加末项,乘以项数,再除以 2(即 n(n+1)/2)。
q3_蒙提霍尔 · 本地 ✔ 3.7s · GLM ✔ 23.1s
题目:三扇门后一扇有车。你选了 1 号门,主持人(知道答案)打开了 3 号门是羊。你该换 2 号门吗?换门后中奖概率是多少?
判分依据:答案比对:概率 2/3(或 66.7%),且明确建议换门
本地答案节选:
应该换。换到 2 号门后中奖概率是 **2/3**。 原因:你最初选 1 号门时,中奖概率是 **1/3**,车在另外两扇门(2、3)中的概率合计是 **2/3**。主持人知道答案,并且打开了一个有羊的门(3 号),这不会改变“车在 2 或 3 中”的总概率 2/3;由于 3 号被排除,这 2/3 的概率就集中到了 2 号门上。 所以:**换门中奖概率 = 2/3,不换中奖概率 = 1/3。**
GLM 答案节选:
# 该换!换门后中奖概率是 **2/3** ## 核心直觉 **换门获胜的概率 = 你第一次选错的概率 = 2/3** 换门本质上是在赌“我一开始就选错了”。因为你第一次选中车的概率只有 1/3,所以大概率(2/3)你一开始就错了,主持人排除掉一个羊门后,车就在剩下的那扇门后面。 ## 概率分析 …
q4_回文函数 · 本地 ✔* 4.5s · GLM ✔ 8.6s
题目:写一个 Python 函数 is_palindrome(s),忽略大小写、空格和标点判断回文,并附 3 个测试用例。只给代码。
判分依据:exec 执行 + 3 用例:"A man, a plan, a canal: Panama"→True、"hello"→False、"上海自来水来自海上"→True
本地答案节选:
def is_palindrome(s):
cleaned = ''.join(ch.lower() for ch in s if ch.isalnum())
return cleaned == cleaned[::-1]
assert is_palindrome("A man, a plan, a canal: Panama") is True
assert is_palindrome("race a car") is False
assert is_palindrome("Was it a car or a cat I saw?") is True
GLM 答案节选:
```python
def is_palindrome(s):
cleaned = ''.join(c.lower() for c in s if c.isalnum())
return cleaned == cleaned[::-1]
# 测试用例
print(is_palindrome("A man, a plan, a canal: Panama")) # True
print(is_palindrome("Hello, World!")) # False
print(is_palindrome("No 'x' in Nixon")) # True
…
q5_SQL最高工资 · 本地 ✔* 3.0s · GLM ✔ 6.9s
题目:写一条 SQL:employees(id, name, dept, salary) 表中,查出每个部门工资最高的员工姓名和工资。只给 SQL。
判分依据:SQLite 内存库真实执行(4 行样例数据:甲乙同部门不同薪、丙丁技术部并列最高):须命中 {甲,丙,丁} 且排除乙
本地答案节选:
SELECT name, salary
FROM employees e
WHERE salary = (
SELECT MAX(salary)
FROM employees
WHERE dept = e.dept
);
GLM 答案节选:
```sql
SELECT name, salary
FROM (
SELECT name, salary,
RANK() OVER (PARTITION BY dept ORDER BY salary DESC) AS rk
FROM employees
) t
WHERE rk = 1;
```
q6_HTTPS握手 · 本地 —不计分 5.8s · GLM —不计分 23.0s
题目:简述 HTTPS/TLS 握手中客户端验证服务器证书的步骤。
判分依据:开放题,不计分(无程序判分)
本地答案节选:
HTTPS/TLS 握手中,客户端验证服务器证书通常包括以下步骤: 1. **接收证书链** 服务器在握手过程中发送自己的证书,以及可能的中间 CA 证书。 2. **验证证书链可信** 客户端检查证书是否由受信任的根 CA 签发,证书链是否完整、可追溯到本地信任库中的根证书。 3. **检查证书有效期** 验证证书是否在有效期内,即当前时间位于 `Not Before` 和 `Not After` 之间。 …
GLM 答案节选:
# TLS 握手中客户端验证服务器证书的步骤 客户端收到服务器发来的证书后,主要执行以下验证: 1. **解析证书** 解析 X.509 格式的证书,读取主体、颁发者、有效期、扩展字段等基本信息。 2. **验证证书链(信任链)** 证书通常由中间 CA 签发给站点,中间 CA 再由根 CA 签发。客户端逐级用上一级证书的公钥验证下一级证书的数字签名,构建出完整链:叶子证书 → 中间 CA → 根 CA。根证书必须是客户端本地信任库中预置的受信任证书。 …
q7_二战转折 · 本地 —不计分 3.7s · GLM —不计分 12.9s
题目:第二次世界大战的转折性战役通常认为是哪一场?用 150 字以内说明理由。
判分依据:开放题,不计分
本地答案节选:
通常认为是斯大林格勒战役。理由:此役德军精锐第6集团军被歼,东线德军由战略进攻转为战略防御;苏军开始掌握主动权,极大鼓舞盟军士气,并动摇轴心国阵营,因此被视为二战的重要转折点。
GLM 答案节选:
通常认为是**斯大林格勒战役**(1942—1943)。理由:德军精锐第六集团军约30万人被全歼,是纳粹德国首次战略性惨败;德军从此丧失苏德战场主动权,苏军开始战略反攻,轴心国由攻转守,整个战争态势逆转。(此外,太平洋战区多以中途岛海战、北非以阿拉曼战役为各自战区的转折。)
q8_现代诗 · 本地 —不计分 6.4s · GLM —不计分 29.4s
题目:以《秋天的车站》为题写一首现代诗,8-14 行。
判分依据:开放题,不计分
本地答案节选:
《秋天的车站》 风把站台吹成一条旧河 落叶在铁轨旁练习告别 列车尚未进站 汽笛先替我们沉默 长椅空着,像一句未说完的话 阳光斜过售票窗 把归期照得很薄 有人裹紧衣领 …
GLM 答案节选:
# 秋天的车站 落叶把站台铺成一封旧信, 风一遍遍地读,读出汽笛的回声。 候车的人把黄昏抱在怀里, 像抱着一束快要枯萎的花。 火车进站,碾碎铁轨上的薄霜, 有人下车,把故乡还给月台; 有人上车,带走一半的凉意 …
q9_复利200字 · 本地 ✔* 8.7s · GLM ✔ 15.6s
题目:面向高中生,用大约 200 字解释什么是复利。要求正好一段,不要分点。
判分依据:字数 120–320 且为单段(无分点)
本地答案节选:
复利是一种“利滚利”的计息方式:你存入一笔钱后,不仅本金会产生利息,已经得到的利息在下一期也会继续产生利息。比如每年利率10%,第一年100元变成110元,第二年不是只按100元算利息,而是按110元算,得到121元。时间越长,复利越明显,因为增长本身也会成为新的增长基础。它既能帮助储蓄和投资快速积累财富,也会让贷款和欠款越滚越大,所以理解复利,就是理解金钱随时间变化的力量。
GLM 答案节选:
复利就是俗称的“利滚利”:与单利只按本金计算利息不同,复利会把每期产生的利息并入本金,作为下一期计息的基数。举例来说,1000元本金,年利率10%,第一年利息为100元;第二年则按1100元计息,利息变成110元,如此滚动下去,越滚越快。用公式表示,复利终值等于本金乘以(1+利率)的n次方,增长是指数型的。这意味着只要时间足够长,即使利率不高,财富也会像滚雪球一样加速膨胀。正因如此,复利常被称为“世界第八大奇迹”,它告诉我们:越早开始、长期坚持,才是积累财富的关键。
q10_朝代倒序 · 本地 ✔ 4.7s · GLM ✔* 16.2s
题目:列出 5 个中国朝代,按时间从近到远排序,每个朝代用不超过 6 个字概括其特点,用编号列表。
判分依据:恰好 5 行编号列表,每行去标点 ≤14 字
本地答案节选:
1. 清朝:近代前夜 2. 明朝:君主专制 3. 元朝:疆域辽阔 4. 宋朝:重文轻武 5. 唐朝:开放繁荣
GLM 答案节选:
1. **清朝**(1644–1912):末代封建王朝 2. **明朝**(1368–1644):君主专制强化 3. **元朝**(1271–1368):疆域空前辽阔 4. **宋朝**(960–1279):经济文化繁荣 5. **唐朝**(618–907):开放包容盛世
q11_翻译 · 本地 —不计分 2.4s · GLM —不计分 13.9s
题目:把'千里之行,始于足下'翻译成英文,并用 60 字以内解释你的翻译取舍。
判分依据:开放题,不计分
本地答案节选:
A journey of a thousand miles begins with a single step. 取舍:保留“千里”意象,用“single step”对应“足下”,避免直译“foot”生硬。
GLM 答案节选:
**译文:** A journey of a thousand miles begins with a single step. **取舍说明(60字内):** 「千里」译为 a thousand miles 而非音译 li,符合英语习惯;「足下」不直译 under feet,改用 a single step,突出“从细微行动开始”的哲理,更自然传神。
q12_鲁迅 · 本地 ✔ 6.8s · GLM ✔ 7.8s
题目:鲁迅和周树人是什么关系?
判分依据:关键词:同一人/本名/笔名任一
本地答案节选:
鲁迅和周树人是**同一个人**。 “周树人”是他的本名(他原名周樟寿,后改名周树人
GLM 答案节选:
鲁迅和周树人其实是**同一个人**。 鲁迅(1881年—1936年)原名周樟寿,后改名周树人,字豫才,浙江绍兴人。“鲁迅”是他1918年在《新青年》杂志上发表中国现代文学史上第一篇白话小说《狂人日记》时开始使用的笔名,此后成为他最广为人知的名字。 鲁迅是中国现代文学的奠基人之一,代表作还有《呐喊》《彷徨》《阿Q正传》《朝花夕拾》等。他一生使用过一百四十多个笔名,“鲁迅”只是其中最著名的一个。 这个问题在网上常被当作一个“考题”或段子,用来调侃那些以为鲁迅和周树人是两个人的人,其实就是同一个人啦。😄
难题轮(7 题)
h1_阶乘百零 · 本地 ✔ 9.3s · GLM ✔ 15.1s
题目:求最小的正整数 n,使得 n! 的十进制表示末尾恰好有 100 个连续的 0。给出 n 和简短推导。
判分依据:唯一答案比对:405(复核确认结论行为真推理,非推导中偶然含该数)
本地答案节选:
最小的正整数是 **(n=405)**。
推导:
(n!) 末尾 0 的个数等于其中因子 (10=2cdot5) 的个数。由于因子 2 通常比因子 5 多,所以只需计算 (n!) 中因子 5 的个数:
[
Z(n)=leftlfloor frac n5 rightrfloor+leftlfloor frac n{25} rightrfloor+leftlfloor frac n{125} rightrfloor+leftlfloor frac n{625} rightrfloor+cdots
]
…
GLM 答案节选:
## 答案:n = 405
**推导:** n! 末尾 0 的个数由因子 5 的个数决定(因子 2 足够多):
$$Z(n)=leftlfloorfrac{n}{5}rightrfloor+leftlfloorfrac{n}{25}rightrfloor+leftlfloorfrac{n}{125}rightrfloor+cdots$$
由于 $Z(n)approx dfrac{n}{4}$,估计 $n$ 在 400 附近。
- $Z(400)=80+16+3=99$,还差 1 个;
- 由于 401–404 不含因子 5,$Z(404)=99$ 仍不足;
…
h2_排队 · 本地 ✔ 3.2s · GLM ✔ 5.1s
题目:5 个人排队照相,要求甲站在乙的前面(不必相邻)。共有多少种不同排法?给出算式。
判分依据:唯一答案比对:60(5!/2)
本地答案节选:
共有:
[
frac{5!}{2}=60
]
种不同排法。
也可以写成:
…
GLM 答案节选:
# 解答
**思路:** 甲在乙前面(不必相邻),只需从 5 个位置中选 2 个位置给甲、乙,甲站前面那个位置,其余 3 人任意排列。
**算式:**
$$C_5^2 times A_3^3 = 10 times 6 = 60 text{(种)}$$
**另一种简便算法(对称法):**
…
h3_平方和 · 本地 ✔ 17.1s · GLM ✔ 51.4s
题目:方程 x^2 + y^2 = 2025 的正整数解中,按 x <= y 归并后共有几组?给出解本身。
判分依据:比对:恰 1 组,且文本含解 (27,36)
本地答案节选:
共有 **1 组**。 正整数解按 (xle y) 归并后为: [ (x,y)=(27,36) ] 验证: …
GLM 答案节选:
## 答案:共 **1 组** **解:** (x, y) = (27, 36) **验证:** 27² + 36² = 729 + 1296 = 2025 ✓ ## 推导过程 **方法一:直接枚举** …
h4_括号 · 本地 ✔ 3.7s · GLM ✔ 3.4s
题目:实现 Python 函数 longest_valid_parentheses(s),返回 s 中最长有效(成对)括号子串的长度。只给代码,不要解释。
判分依据:exec + 9 用例:""→0、"(()"→2、")()())"→4、"()"→2、"()(())"→6、"((()))"→6、")("→0、"(()())"→6、"(())(()"→4
本地答案节选:
def longest_valid_parentheses(s: str) -> int:
max_len = 0
stack = [-1]
for i, ch in enumerate(s):
if ch == '(':
stack.append(i)
else:
stack.pop()
if not stack:
…
GLM 答案节选:
```python
def longest_valid_parentheses(s):
max_len = 0
stack = [-1]
for i, ch in enumerate(s):
if ch == '(':
stack.append(i)
else:
stack.pop()
if not stack:
…
h5_最小窗口 · 本地 ✔ 5.3s · GLM ✔ 7.4s
题目:实现 Python 函数 min_window(s, t),返回 s 中包含 t 全部字符(含重复数)的最小子串;不存在返回空串。只给代码。
判分依据:exec + 7 用例:ADOBECODEBANC/ABC→BANC、a/a→a、a/aa→空、ab/b→b、bba/ab→ba、空串/A→空、aaflslflsldkalsdkaa/asl→als(该期望值经暴力枚举验证)
本地答案节选:
from collections import Counter
def min_window(s: str, t: str) -> str:
if not s or not t:
return ""
need = Counter(t)
required = len(need)
window = Counter()
formed = 0
…
GLM 答案节选:
```python
from collections import Counter
def min_window(s, t):
if not s or not t or len(s) < len(t):
return ""
need = Counter(t)
missing = len(t)
…
h6_缺陷修复 · 本地 ✔ 20.3s · GLM ✔ 35.8s
题目:下面的函数有两个缺陷,与它的文档字符串承诺不符。修复它们,只返回完整修复后的代码。
“`python
import re
def summarize_events(lines):
"""把相邻重复的 EVENT 行合并为一条 'name x总次数';无法解析的行必须原样保留在原位置。"""
out = []
for ln in lines:
m = re.match(r'EVENT (w+) count=(d+)$', ln)
if m:
…
判分依据:exec + 4 测试:相邻计数合并(2+3→x5)、JUNK 行原样保留在原位、单事件 x4、空列表;缺陷代码经预检确认只挂前两条
本地答案节选:
```python
import re
def summarize_events(lines):
"""把相邻重复的 EVENT 行合并为一条 'name x总次数';无法解析的行必须原样保留在原位置。"""
out = []
last_name = None
last_count = 0
for ln in lines:
…
GLM 答案节选:
```python
import re
def summarize_events(lines):
"""把相邻重复的 EVENT 行合并为一条 'name x总次数';无法解析的行必须原样保留在原位置。"""
out = []
last_name = None # 记录上一条已合并条目对应的事件名,保证只合并真正相邻的行
total = 0
for ln in lines:
m = re.match(r'EVENT (w+) count=(d+)$', ln)
…
h7_约束JSON · 本地 ✔ 8.0s · GLM ✔ 9.3s
题目:只输出一个 JSON 对象,不要任何其他文字。字段要求:summary(项目风险摘要,不超过 30 个字);risks(恰好 3 个字符串,每个不超过 10 个字,内容围绕'数据迁移');owner(只能取 '张工' '李工' '王工' 之一);due(今天周六 2026-11-14,跳过周六日后第 10 个工作日的日期,格式 YYYY-MM-DD)。
判分依据:JSON 解析 + 5 约束逐条核对:summary ≤30 字、risks 恰 3 条各 ≤10 字、owner ∈ {张工,李工,王工}、due = 2026-11-27(周六 11-14 起跳过周末的第 10 个工作日,脚本独立推算验证)
本地答案节选:
{
"summary": "数据迁移存在完整性与停机风险",
"risks": [
"数据丢失",
"迁移超时",
"校验失败"
],
"owner": "张工",
"due": "2026-11-27"
}
GLM 答案节选:
{"summary":"数据迁移存在进度与质量风险","risks":["迁移数据映射错误","迁移期间业务中断","迁移后数据校验缺失"],"owner":"张工","due":"2026-11-27"}
代码专项轮(6 题)
c1_LRU加TTL · 本地 ✔ 25.7s · GLM ✔ 16.3s
题目:实现 Python 类 LRUCache,签名 LRUCache(capacity, ttl=None, now_fn=time.monotonic)。
语义:容量为 capacity 的 LRU 缓存(最近最少使用淘汰);ttl 不为 None 时,条目距写入超过 ttl 秒视为过期,get 对过期条目返回 None 并将其从缓存剔除;get 命中会把该条目提升为最近使用;put 已存在的 key 覆盖值并刷新时间,不触发淘汰;now_fn 只允许通过构造参数注入,内部不得直接调 time.monotonic。g…
判分依据:exec + 5 组场景:容量淘汰+get 提升、无 get 时淘汰最旧、覆盖已存在 key 刷新且不触发淘汰、TTL 过期返回 None 并剔除、TTL 内正常;时钟经 now_fn 注入(避开整秒边界)
本地答案节选:
import time
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity, ttl=None, now_fn=time.monotonic):
self.capacity = capacity
self.ttl = ttl
self._now_fn = now_fn
self._cache = OrderedDict()
…
GLM 答案节选:
```python
import time
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity, ttl=None, now_fn=time.monotonic):
if capacity <= 0:
raise ValueError("capacity must be positive")
self._capacity = capacity
…
c2_retry装饰器 · 本地 ✔ 10.8s · GLM ✔ 8.0s
题目:实现装饰器工厂 retry(times=3, delay=0.5, sleep_fn=time.sleep),装饰后的函数失败(抛异常)时自动重试:最多调用被装饰函数 times 次;每次失败后调用 sleep_fn(delay) 再重试,但最后一次失败后不再 sleep;全部失败时抛最后一次的异常对象。sleep_fn 只通过参数注入。只给代码。
判分依据:exec + 5 组:第 3 次成功(恰调 3 次、sleep 2 次)、永败抛最后一次异常且最后一次不 sleep、一次成功不 sleep、sleep 次数 = times-1 且参数正确、参数透传
本地答案节选:
```python
import functools
import time
def retry(times=3, delay=0.5, sleep_fn=time.sleep):
if times < 1:
raise ValueError("times must be >= 1")
def decorator(func):
…
GLM 答案节选:
```python
import time
from functools import wraps
def retry(times=3, delay=0.5, sleep_fn=time.sleep):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
last_exc = None
…
c3_调端口解析 · 本地 ✔ 25.0s · GLM ✔ 19.6s
题目:下面的函数有两个缺陷,与它的文档字符串承诺不符。修复它们,只返回完整修复后的代码。
“`python
def parse_ports(spec):
"""解析端口规格串,返回去重升序的端口 int 列表。
规则:
– 逗号分隔;片段可以是单端口 '8080' 或范围 '8000-8002'(含两端点)
– 空白片段、非数字片段、a>b 的范围一律跳过,不抛错
示例: '8000-8002, 8080, ' → [8000, 8001, 8002, 8080]
""…
判分依据:exec + 5 用例:8000-8002 含两端点、非数字片段跳过不抛错、空片段跳过、去重升序、a>b 范围跳过;缺陷版预检确认只挂前两条(off-by-one 漏端点、非法片段抛错)
本地答案节选:
```python
def parse_ports(spec):
"""解析端口规格串,返回去重升序的端口 int 列表。
规则:
- 逗号分隔;片段可以是单端口 '8080' 或范围 '8000-8002'(含两端点)
- 空白片段、非数字片段、a>b 的范围一律跳过,不抛错
示例: '8000-8002, 8080, ' → [8000, 8001, 8002, 8080]
"""
ports = set()
for part in spec.split(","):
…
GLM 答案节选:
```python
def parse_ports(spec):
"""解析端口规格串,返回去重升序的端口 int 列表。
规则:
- 逗号分隔;片段可以是单端口 '8080' 或范围 '8000-8002'(含两端点)
- 空白片段、非数字片段、a>b 的范围一律跳过,不抛错
示例: '8000-8002, 8080, ' → [8000, 8001, 8002, 8080]
"""
ports = set()
for part in spec.split(","):
…
c4_改造bench · 本地 ✔ 14.7s · GLM ✔ 45.5s
题目:这是我们在用的压测脚本 bench_speed.py:
“`python
#!/usr/bin/env python3
# bench_speed.py — 测 Strata 服务解码速度:3 轮固定请求,取 token/s 均值
import json, sys, time
import requests
PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 8082
ROUNDS = int(sys.argv[2]) if len(sys.argv) > 2 …
判分依据:exec + 3 组:注入 fake post 3 轮校验 total_tokens=1152/ok_rounds=3、tok_per_s 为有限正数、HTTP 500 时抛 RuntimeError 且消息含状态码
本地答案节选:
```python
import time
import requests
PROMPT = (
"请用中文详细介绍分布式大模型推理引擎的工作原理,包括专家并行、KV 缓存管理、"
"投机解码、量化格式等,每个主题至少写三段。"
)
…
GLM 答案节选:
```python
#!/usr/bin/env python3
# bench_speed.py — 测 Strata 服务解码速度:可测试函数版,3 轮固定请求,取 token/s 均值
import sys
import time
import requests
PROMPT = ("请用中文详细介绍分布式大模型推理引擎的工作原理,包括专家并行、KV 缓存管理、"
"投机解码、量化格式等,每个主题至少写三段。")
…
c5_GPU日志解析 · 本地 ✔ 8.5s · GLM ✔ 6.5s
题目:实现函数 max_gpu_mem(lines),lines 是服务日志行列表,形如:
'2026-11-14 09:12:01 INFO gpu_mem=44806 MiB gpu_util=97%'
返回显存数值最大的那一行的 (时间戳字符串, 显存int) 元组;没有任何 gpu_mem= 行时返回 None;最大值不唯一时取先出现的那行。只给代码。
判分依据:exec + 3 用例:取最大显存行 (时间戳, 44911)、无 gpu_mem 行→None、乱序日志取最大
本地答案节选:
import re
def max_gpu_mem(lines):
pattern = re.compile(r'gpu_mem=(d+)')
best = None
best_val = None
for line in lines:
m = pattern.search(line)
if not m:
…
GLM 答案节选:
```python
import re
def max_gpu_mem(lines):
pattern = re.compile(r'gpu_mem=(d+)')
ts_pattern = re.compile(r'^(d{4}-d{2}-d{2} d{2}:d{2}:d{2})')
best = None
for line in lines:
m = pattern.search(line)
if not m:
…
c6_滑动窗口限流 · 本地 ✔ 25.8s · GLM ✔ 8.9s
题目:实现 Python 类 RateLimiter,签名 RateLimiter(max_calls, window_s=60.0, now_fn=time.monotonic)。
语义:滑动窗口限流——任意长度 window_s 秒的时间窗口内,allow() 最多返回 max_calls 次 True;超出窗口的旧记录不再计入;allow() 返回 False 的被拒调用不占名额、不写入记录;now_fn 只通过构造参数注入。只给代码。
判分依据:exec + 3 组:3 次满/窗口滑出恢复、被拒不占名额(t=60.5 恢复点是关键区分:错误实现会因拒绝调用占名额而仍拒绝)、n=1 立即拒
本地答案节选:
import time
from collections import deque
from typing import Callable
class RateLimiter:
__slots__ = ("max_calls", "window_s", "_now_fn", "_calls")
def __init__(
self,
…
GLM 答案节选:
```python
import time
from collections import deque
class RateLimiter:
def __init__(self, max_calls, window_s=60.0, now_fn=time.monotonic):
self.max_calls = max_calls
self.window_s = window_s
self.now_fn = now_fn
…
第四轮:加难+工具(8 题)
d1_错排计数 · 本地 ✔ 6.1s · GLM ✔ 11.4s
题目:1 到 10 的排列中,恰有 3 个不动点(即恰有 3 个位置 i 满足 π(i)=i)的排列共有多少个?给出最终数值与简要推导。
判分依据:唯一答案比对:222480 = C(10,3)×D(7)(错排公式;判分器经小值递推+暴力枚举排列双重验证)
本地答案节选:
共有 **222480** 个。
推导:
1. 先从 10 个位置中选出恰好 3 个不动点:
[
binom{10}{3}=120
]
2. 剩下 7 个位置必须没有不动点,即做 7 个元素的错排:
…
GLM 答案节选:
**答案:222,480 个**
**推导:**
**第一步:选定不动点位置。**
从 10 个位置中选出恰好 3 个作为不动点(即 π(i)=i),共有
$$binom{10}{3} = 120$$
种选法。
…
d2_线性丢番图 · 本地 ✔ 27.0s · GLM ✔ 25.7s
题目:整数 x, y 满足 7x + 4y = 2024,且 |x| + |y| 最小。求这组 (x, y) 与最小值。给出最终结果与简要推导。
判分依据:比对:(x,y)=(288,2)、|x|+|y| 最小值 290(地面真值由全枚举暴力计算;出题人手算曾误记 289,自证纠正)
本地答案节选:
最终结果:
[
boxed{(x,y)=(288,2)},qquad boxed{|x|+|y|_{min}=290}
]
简要推导:
由题意:
…
GLM 答案节选:
**答案:(x, y) = (288, 2),最小值 |x| + |y| = 290**
**推导:**
**1. 求通解。** 由 7x + 4y = 2024,对 4 取模得 3x ≡ 0 (mod 4),故 x ≡ 0 (mod 4)。设 x = 4k(k 为整数),代入得:
$$y = frac{2024 - 7 cdot 4k}{4} = 506 - 7k$$
所以全部整数解为 (x, y) = (4k, 506 − 7k)。
…
d3_表达式求值器 · 本地 ✔ 15.9s · GLM ✘ 18.2s
题目:实现 Python 函数 evaluate(s):对字符串表达式求值,支持 + – * / 、圆括号与一元负号,运算符优先级与结合性与数学惯例一致(乘除先于加减,同级从左到右)。数字为非负整数,除法结果为数值(不取整)。不使用 eval。只给代码。
判分依据:exec + 10 用例对照 AST 白名单参考实现:含一元负号(2*-3+10)、左结合(2-2-2、8/4/2)、嵌套括号(3-(4-(5-6)))
本地答案节选:
```python
def evaluate(s):
i = 0
n = len(s)
def skip_whitespace():
nonlocal i
while i < n and s[i].isspace():
i += 1
…
GLM 答案节选:
```python
def evaluate(s: str):
pos = 0
n = len(s)
def skip_ws():
nonlocal pos
while pos < n and s[pos].isspace():
pos += 1
…
d4_LIS性能 · 本地 ✔ 4.0s · GLM ✔ 8.3s
题目:实现 Python 函数 lis(nums):返回最长严格递增子序列的长度,要求在 n=200,000 规模下 12 秒内完成(即必须优于 O(n^2))。只给代码。
判分依据:exec + 5 小用例正确性 + n=200,000 随机数组 12 秒时限(参考实现 0.02s,O(n²) 必超时)——考复杂度而非仅正确
本地答案节选:
```python
from bisect import bisect_left
def lis(nums):
tails = []
for x in nums:
i = bisect_left(tails, x)
if i == len(tails):
tails.append(x)
else:
…
GLM 答案节选:
```python
from bisect import bisect_left
def lis(nums):
tails = [] # tails[i] = 长度为 i+1 的递增子序列的最小结尾
for x in nums:
i = bisect_left(tails, x) # 严格递增:相等元素也替换
if i == len(tails):
tails.append(x)
else:
…
d5_修树状数组 · 本地 ✔ 7.7s · GLM ✔ 8.4s
题目:下面的树状数组实现有两个缺陷,与文档字符串承诺不符。修复它们,只返回完整修复后的代码。
“`python
class BIT:
"""树状数组,下标 1..n。add(i,d): 位置 i 加 d;ask(i): 返回 a[1]+…+a[i];range_sum(l,r): 返回 a[l]+…+a[r]。"""
def __init__(self, n):
self.n = n
self.t = [0] * (n + 1)
def add(self…
判分依据:exec + 300 步随机 add/ask/range_sum 对照暴力前缀和;埋雷版预检确认必挂、参考修复版通过(两雷:add 循环边界漏根、range_sum 差分 off-by-one)
本地答案节选:
```python
class BIT:
"""树状数组,下标 1..n。add(i,d): 位置 i 加 d;ask(i): 返回 a[1]+...+a[i];range_sum(l,r): 返回 a[l]+...+a[r]。"""
def __init__(self, n):
self.n = n
self.t = [0] * (n + 1)
def add(self, i, d):
while i <= self.n:
self.t[i] += d
…
GLM 答案节选:
```python
class BIT:
"""树状数组,下标 1..n。add(i,d): 位置 i 加 d;ask(i): 返回 a[1]+...+a[i];range_sum(l,r): 返回 a[l]+...+a[r]。"""
def __init__(self, n):
self.n = n
self.t = [0] * (n + 1)
def add(self, i, d):
while i <= self.n:
self.t[i] += d
i += i & -i
…
t1_单工具计算 · 本地 ✔ 4.5s · GLM ✔ 11.8s
题目:你可以调用工具 get_city_stats 查询城市统计。用工具查上海的人口与 GDP,计算上海的人均 GDP(单位:美元/人,取整)。只输出数值。
判分依据:工具真实执行判分:必须以 {city:上海} 成功调 get_city_stats,答案 28226/28227 均收(真值 28226.78,截断/四舍五入)
本地工具调用记录:get_city_stats({"city": "上海"}) → 成功 {"population_wan": 2487, "gdp_yi_usd": 7020}
GLM工具调用记录:get_city_stats({"city": "上海"}) → 成功 {"population_wan": 2487, "gdp_yi_usd": 7020}
本地答案节选:
28227
GLM 答案节选:
28227
t2_多工具聚合 · 本地 ✔ 3.4s · GLM ✔ 10.5s
题目:你可以调用工具 get_city_stats 查询城市统计。用工具分别查北京和广州的人口(万人),回答:哪座城市人口更多?多多少万人?
判分依据:分别成功查询北京与广州各一次,答案含「北京」与差值 315 万;调用失败或漏城即挂
本地工具调用记录:get_city_stats({"city": "北京"}) → 成功 {"population_wan": 2189, "gdp_yi_usd": 6300};get_city_stats({"city": "广州"}) → 成功 {"population_wan": 1874, "gdp_yi_usd": 4000}
GLM工具调用记录:get_city_stats({"city": "北京"}) → 成功 {"population_wan": 2189, "gdp_yi_usd": 6300};get_city_stats({"city": "广州"}) → 成功 {"population_wan": 1874, "gdp_yi_usd": 4000}
本地答案节选:
**北京**人口更多。 - 北京:2189 万人 - 广州:1874 万人 - 差值:2189 − 1874 = **315 万人** 即北京比广州多约 315 万人。
GLM 答案节选:
根据查询结果: - **北京**人口:2189 万人 - **广州**人口:1874 万人 **结论:北京人口更多**,比广州多 **315 万人**(2189 − 1874 = 315)。
t3_SQL工具 · 本地 ✔ 2.6s · GLM ✔ 9.3s
题目:你可以调用工具 run_sql 查询 sales(month, amount) 表(2024 年 1-4 月销售额)。用工具查出销售额最高的月份,只回答月份(格式 2024-MM)。
判分依据:以合法 SELECT 成功调 run_sql,答案 2024-04;工具侧已验证非 SELECT 与未知城市会被拒(错误处理路径真实存在)
本地工具调用记录:run_sql({"sql": "SELECT month FROM sales ORDER BY amount DESC LIMIT 1;"}) → 成功 {"rows": [["2024-04"]]}
GLM工具调用记录:run_sql({"sql": "SELECT month, amount FROM sales ORDER BY amount DESC LIMIT 1"}) → 成功 {"rows": [["2024-04", 180]]}
本地答案节选:
2024-04
GLM 答案节选:
2024-04