← 墨攻说

本地化部署 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 内存有承接空间)——理论上限可以更高,代价是速度。

二、方法:让机器当裁判

主观打分(“我觉得这个答案好”)不可复现,所以四轮所有计分题都设计成唯一答案或可执行验证:

出题后先做的事是给判分器自证:用参考实现加暴力枚举把隐藏测试集全部预验一遍(还真抓出过判分器自己的三处 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 题整体跑了两次,两次比分一致(复现验证)。几道代表性的难题:

四、几个有意思的细节

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 同系)。缓解因素:全部判分是程序执行结果,不存在人为打分,原始记录完整存档可复查;无法缓解的因素:题型选择出自它手。知情权交给读者,结论请带着这条声明使用。

参考文档

术语表

附录: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