想象你是一名编程竞赛选手，面前坐着一位特殊的“机器考生”。它没有老师，不查资料，桌上只有一本厚厚的习题书和无穷无尽的草稿纸。考试时它会做一件疯狂的事：同一道题，它先在草稿纸上写下成百上千份解法，然后翻到书后的答案页快速核对，把对不上的撕掉，把思路相近的归成一堆，最后精挑细选留下十来份提交上去。它能行吗？2022 年，这位名叫 AlphaCode 的机器考生真的走进了世界级编程竞赛的考场，并且交出了一份令人惊讶的答卷：在 10 场真实竞赛中，它的平均排名进入了前 54.7%，约等于一名中等偏上的人类选手。这宣告了一件大事——写代码这件事，机器开始从“补全你写了一半的话”进化到“自己解题”。

岗位关联

AlphaCode 是程序合成领域的分水岭：理解它，你就能看懂当前大模型写代码的底层逻辑，也能把“批量生成 + 验证筛选”这套方法迁移到自动化测试、Bug 修复等真实工程场景，是 AI 编程研究者绕不开的经典案例。

目录
  1. 可视化演示
  2. 系统概述：程序合成是什么
  3. 模型架构：机器考生的“大脑”
  4. 问题理解：先读懂题面
  5. 批量生成：百万份草稿
  6. 筛选提交：优中选优
  7. 竞技表现：成绩单
  8. 里程碑意义：AI 编程新范式
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态演示AlphaCode的核心机制，通过输入/处理/存储/输出四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

AlphaCode：子词分词 子词分词的核心动机与问题定义 BPE算法的频率驱动合并策略 核心机制可视化 AlphaCode整体架构与关键组件

系统概述：程序合成是什么

想象一位从不背书、却能现场推理的“机器考生”走进 Codeforces 考场。它不查题库，也不搜索答案，只掌握一项特殊技能——程序合成：只要给它一段问题的文字描述和几个输入输出样例，它就能当场写出解决问题的代码。AlphaCode 就是 DeepMind 训练出的这样一位考生，而“程序合成”是这门考试的唯一科目。

程序合成是计算机科学的老问题，但竞赛题把它推到了极限：题目刁钻、逻辑嵌套、解法不唯一，任何“背答案”的策略都会失效。AlphaCode 将目标设定为“竞赛级”——直接参加真实 Codeforces 竞赛，与数千名人类选手同场竞技，而不是在玩具语法题上刷分数。竞赛题成了衡量它“是否真的会写程序”的试金石。

2022 年 DeepMind 公开了 AlphaCode 的完整方案：它以 Transformer 大模型为大脑，先在 GitHub 海量代码上预训练，再用竞赛题库微调，最后在推理阶段提出一个新等式——程序合成 = 海量候选生成 + 验证筛选。这一定位后来成为 Codex、Copilot 等代码生成系统的共同范式。

换句话说，这位考生并非靠记忆夺冠，而是靠“把所有可能的解法都推导一遍，再找出能通过全部实例的那一个”。程序合成的核心不是“灵光一闪想出解法”，而是“在庞大的解空间中精确定位正确解”。

P∗=arg⁡max⁡P∈H∏i=1n1[P(xi)=yi]\displaystyle P^{\ast} = \arg\max_{P \in \mathcal{H}} \prod_{i=1}^{n} \mathbb{1}\left[P(x_i) = y_i\right]
  1. 目标程序$P^{\ast}$ 是我们要找的最优程序，也就是机器考生最终交出的答案。
    P∗=arg⁡max⁡P∈H\displaystyle P^{\ast} = \arg\max_{P \in \mathcal{H}}
  2. 搜索空间$P \in \mathcal{H}$ 表示在“所有可能的程序”这个大集合里搜索。
    P∈H\displaystyle P \in \mathcal{H}
  3. 验证条件$\mathbb{1}\left[P(x_i) = y_i\right]$ 是“程序在输入 $x_i$ 上输出 $y_i$ 则记 1、否则记 0”的指示函数。
    1[P(xi)=yi]\displaystyle \mathbb{1}\left[P(x_i) = y_i\right]
  4. 连乘全过$\prod_{i=1}^{n}$ 把所有样例的判定相乘，要求程序对每一条样例都得满分。
    ∏i=1n\displaystyle \prod_{i=1}^{n}

模型架构：机器考生的“大脑”

这位机器考生的大脑是一座“图书馆加自动写作机”的组合体，学名 Transformer。与早期逐字递推的循环网络不同，Transformer 能同时关注文本里任意远的两个词，极其适合代码这种“前一行决定后一千行”的长距离逻辑文本。AlphaCode 就以这种架构为骨干，构建了一个编码器-解码器系统。

AlphaCode 采用基于 Transformer 的编码器-解码器架构：编码器负责把题目文本读成隐藏向量，解码器负责按概率逐词生成代码。整段代码的生成被建模成一个“自回归”过程——每生成一个新 token，都要以题目和已经写出的代码为条件。这也解释了它为什么能写出带嵌套循环、递归调用的复杂结构。

训练分两段进行。第一段是“预训练”：在 GitHub 的数十亿行开源代码上，学习编程语言的基本语法、惯用写法和逻辑结构，这一步让它“会说代码”。第二段是“微调”：在一个名为 CodeContests 的竞赛题库（包含约 1.3 万道真题及人类题解）上继续学习，这一步让它“会解竞赛题”。

所以这位考生不是“先想后写”，而是一边写一边想：每个词的选择都取决于题目和前面所有代码。图书馆式的预训练加上刷题班式的微调，共同构成了它能写会解的大脑。

Pθ(y∣x)=∏t=1TPθ(yt∣y<t,x)\displaystyle P_{\theta}(y \mid x) = \prod_{t=1}^{T} P_{\theta}(y_t \mid y_{<t}, x)
  1. 输入与输出$x$ 是题面与样例拼接成的 token 序列，$y$ 是要生成的完整代码；$P_{\theta}(y \mid x)$ 是“给定题目，写出这段代码”的概率。
    Pθ(y∣x)\displaystyle P_{\theta}(y \mid x)
  2. 逐 token 生成$y_t$ 是代码的第 $t$ 个 token，模型每次只预测“下一个词”。
    yt\displaystyle y_t
  3. 条件依赖$P_{\theta}(y_t \mid y_{<t}, x)$ 表示在已知题目 $x$ 和已写出的前 $t-1$ 个 token 时，下一个 token 出现的概率。
    Pθ(yt∣y<t,x)\displaystyle P_{\theta}(y_t \mid y_{<t}, x)
  4. 连乘成句把这些条件概率相乘，就得到整段代码的生成概率——代码越长，数学挑战越大。
    ∏t=1T\displaystyle \prod_{t=1}^{T}

问题理解：先读懂题面

考场上，机器考生拿到题目后的第一件事是“审题”。它不会像人类那样划重点，而是把题目描述、输入输出样例“一锅炖”，再额外加一道自编的“大输入样例”，一起塞给编码器处理。审题的质量，直接决定了后面草稿纸上的解法靠不靠谱。

这道“自编大样例”是 AlphaCode 的一个小巧思：竞赛题常常声称“数据规模可达 10 的 5 次方”，但公开样例通常很小。为了让模型在处理大规模输入时心里有数，AlphaCode 会在训练和推理时额外生成大规模输入，让模型提前“见过”大场面的数据格式，避免在真正的大数据上手足无措。

编码器把所有这些文本 token 映射成一组隐藏向量。这个向量就像一张“解题条件清单”：解码器每生成一个代码 token 都要回头参考它——写循环时回看数据范围，写输出时回看输出格式。这正是注意力机制在起作用：不是把整道题压缩成一句总结，而是随时可以“翻回去看原文”。

审题越细，草稿越好。人类考生读题靠眼睛，机器考生“读题”靠 token——它把整道题变成一个数学向量，然后在写答案时一遍遍回头核对。

h=Encoder(xdesc⊕xsample⊕xbig)\displaystyle h = \text{Encoder}\left(x_{\text{desc}} \oplus x_{\text{sample}} \oplus x_{\text{big}}\right)
  1. 三路拼接$x_{\text{desc}}$ 是题面描述，$x_{\text{sample}}$ 是输入输出样例，$x_{\text{big}}$ 是自编的大规模输入；$\oplus$ 表示把它们拼成一个 token 序列。
    xdesc⊕xsample⊕xbig\displaystyle x_{\text{desc}} \oplus x_{\text{sample}} \oplus x_{\text{big}}
  2. 编码器映射$\text{Encoder}$ 是 Transformer 编码器，把 token 序列变换成隐藏向量序列。
    Encoder(⋅)\displaystyle \text{Encoder}\left(\cdot\right)
  3. 条件向量$h$ 承载题目的全部信息，解码器生成代码时每一步都参考它。
    h\displaystyle h

批量生成：百万份草稿

审完题，超级考生开始打草稿。普通人写一份就交卷，它却给自己定下规矩：“先写一百万份再说”。AlphaCode 对每道题最多生成 100 万个候选程序——不追求单份精准，而追求海量覆盖。这看起来笨拙，却是它最核心的武器。

海量草稿怎么保证不千篇一律？靠的是“温度采样”。模型输出每个 token 时都会给出一个概率分布，温度参数 τ 控制这个分布的“性格”：τ 小，模型专挑高概率 token，输出稳定但容易千篇一律；τ 大，低概率 token 也有机会被选中，输出天马行空但富有变化。

AlphaCode 会用多个不同的 τ 值生成多批候选——低温批负责“稳妥常规”，高温批负责“奇思妙想”。这种多样化策略保证了最终提交的少量答案里，既有教科书式的常规解，也有剑走偏锋的冷门解，覆盖完全不同的解题路径。

温度就是草稿的“狂想度”旋钮。旋到合适位置，百万份草稿里既规规矩矩的套路解法，也有剑走偏锋的妙手。AlphaCode 的全部秘密，就在于它真的愿意写下那一百万份草稿。

pt=exp⁡(zt/τ)∑v∈Vexp⁡(zv/τ)\displaystyle p_t = \frac{\exp\left(z_t / \tau\right)}{\sum_{v \in V} \exp\left(z_v / \tau\right)}
  1. 打分向量$z_t$ 是模型内部对“第 $t$ 个位置该写哪个 token”的原始打分（logits）。
    zt\displaystyle z_t
  2. 温度缩放$z_t / \tau$ 把全体打分除以温度——τ 越大，各打分越接近，分布的“峰”越平缓。
    zt/τ\displaystyle z_t / \tau
  3. 归一化$\sum_{v \in V} \exp\left(z_v / \tau\right)$ 把所有候选 token 的得分求和，再除回去就得到合法的概率。
    ∑v∈Vexp⁡(zv/τ)\displaystyle \sum_{v \in V} \exp\left(z_v / \tau\right)
  4. 采样按 $p_t$ 随机抽取一个 token，完成一步生成；重复这个过程直到写出整段代码。
    pt\displaystyle p_t

筛选提交：优中选优

草稿写完了，残酷的筛选开始。第一步是“对着答案核对”：把每个候选程序在题目公开给出的输入输出样例上运行，能完全通过才留下。这一步通常淘汰掉九成以上的候选——机器考生撕掉了绝大部分草稿，脸上毫无表情。

留下的候选依然数量庞大，而且很多是“同一个思路换了件衣服”。如果全部提交，一旦这个思路在隐藏测试上失败，就会全军覆没。于是第二步“聚类去重”：用一组额外构造的“探针输入”运行每个候选，把输出结果完全相同的程序视为同一行为类，每类只保留一个代表——不同衣服但同一个灵魂的程序，只留一件。

最终从各类中按模型打分挑出最有潜力的程序，最多提交 10 份。这 10 份对应 10 种不同的解题思路，在隐藏测试面前“东方不亮西方亮”。公开样例测试只是第一道筛子，聚类去重才是保证答案多样性的关键一步。

有人说 AlphaCode 的胜利是“算力碾压”，其实更是“工程筛法”的胜利：把不确定性交给海量生成，把确定性交给样例验证，把多样性交给聚类去重。交卷的 10 份答案，每一份都代表一条不同的解题道路。

Score(Pj)=∑s=1m1[Pj(xs)=ys]\displaystyle \text{Score}(P_j) = \sum_{s=1}^{m} \mathbb{1}\left[P_j(x_s) = y_s\right]
  1. 候选程序$P_j$ 是第 $j$ 份候选代码，即草稿堆里的某一张。
    Pj\displaystyle P_j
  2. 样例遍历$(x_s, y_s)$ 是第 $s$ 条公开样例的输入与期望输出；$m$ 是公开样例总数。
    (xs,ys),s=1,…,m\displaystyle (x_s, y_s), \quad s = 1, \dots, m
  3. 逐个判定$\mathbb{1}\left[P_j(x_s) = y_s\right]$ 在运行结果与期望一致时记 1，否则记 0。
    1[Pj(xs)=ys]\displaystyle \mathbb{1}\left[P_j(x_s) = y_s\right]
  4. 累加得分$\text{Score}(P_j)$ 是它通过的样例条数；竞赛筛选中只有满分者才有资格进入下一轮。
    ∑s=1m\displaystyle \sum_{s=1}^{m}

竞技表现：成绩单

交卷之后，成绩单揭晓。AlphaCode 注册了 10 个虚拟账号，混入 Codeforces 周赛与数千名人类选手同台竞技。战绩是：在 10 场竞赛中解决了约 34% 的题目，平均排名进入前 54.7%，约等于人类中等偏上的水平。它不是天才选手，却是第一个挤进考场中游的“机器考生”。

这个成绩放在 2022 年堪称分水岭。此前最强的代码生成模型只能做“填空式补全”，遇到需要从零设计算法的竞赛题立即崩溃。AlphaCode 是第一个在“需要全新算法设计”的竞赛中达到人类中等水平的系统——它写的不是"Hello World"，而是涉及动态规划、贪心、图论的完整解法。

详细数据也值得咀嚼：平均排名 54.7% 意味着大约有一半多的人类选手排在它后面；而 34% 的求解率则说明，它面对的大多数题目依然会答错。它更像一个认真刷题两三年的普通竞赛爱好者——看得懂题、写得出手、但距离红名顶级选手仍有很大差距。

这份成绩单的重点不是“天才”，而是“合格”。就像一场长跑比赛里，机器选手第一次稳稳跑进了中游方阵——不算快，但它全程自己看路、自己呼吸、自己冲线。

Percentile(α)=∣{h∈H:scoreh<scoreα}∣∣H∣×100%\displaystyle \text{Percentile}(\alpha) = \frac{\left|\left\{h \in H : \text{score}_h < \text{score}_{\alpha}\right\}\right|}{|H|} \times 100\%
  1. 选手集合$H$ 是当场比赛的全部人类选手，$h$ 是其中任意一位。
    H\displaystyle H
  2. 击败计数$\left\{h \in H : \text{score}_h < \text{score}_{\alpha}\right\}$ 表示“分数低于 AlphaCode 的选手集合”，用 $\left|\cdot\right|$ 数出人数。
    ∣{h∈H:scoreh<scoreα}∣\displaystyle \left|\left\{h \in H : \text{score}_h < \text{score}_{\alpha}\right\}\right|
  3. 归一化除以总人数 $|H|$，得到 AlphaCode 领先的选手比例。
    …∣H∣\displaystyle \frac{\ldots}{|H|}
  4. 百分比乘以 100% 得到百分位排名，54.7% 即中位偏上。
    ×100%\displaystyle \times 100\%

里程碑意义：AI 编程新范式

这位机器考生带给行业的震动，不在于击败了谁，而在于证明了一条路：AI 编程可以从“补全续写”迈向“独立解题”。它代表程序合成与验证的一次能力跃升，至今仍是代码智能领域被反复引用的里程碑案例。

对学术界，AlphaCode 提供了一个可量化的推理标尺：解决竞赛题需要理解题意、设计算法、处理边界、组织代码，而 AlphaCode 用百万候选与多层筛选证明，大规模预训练模型的“编程推理”能力可以被真实检验。它生成的代码中，有嵌套循环、哈希技巧、剪枝逻辑——这些不是从题解里抄来的，而是模型自己组合出来的。

对工程界，它确立了“生成—过滤—验证”的新范式：与其逼模型一次写对，不如让它写一千份，用测试过滤，用聚类保多样。这一范式被后续的代码大模型、自动化修复、测试生成工具广泛继承。对未来的展望也很清晰：更大规模的算力、更精细的验证器、更强的规划能力，将推动 AI 从“会做题”走向“会做对题”。

百万份草稿正是为了撬动 pass@k 这根杠杆：候选越多，正确候选存在的概率越大；提交越多样，至少一份命中的概率越大。AlphaCode 把“草稿纸的数量”变成了 AI 编程进步的关键变量。

pass@k=1−(n−ck)(nk)\displaystyle \text{pass@k} = 1 - \frac{\binom{n-c}{k}}{\binom{n}{k}}
  1. 三个基本量$n$ 是生成的候选总数，$c$ 是其中正确的个数，$k$ 是提交或尝试的次数。
    n,  c,  k\displaystyle n, \; c, \; k
  2. 失败选法$\binom{n-c}{k}$ 表示从“错误的候选”里选出 $k$ 个的组合数——这是全部选错的方案数。
    (n−ck)\displaystyle \binom{n-c}{k}
  3. 全部选法$\binom{n}{k}$ 表示从所有候选里选出 $k$ 个的组合数。
    (nk)\displaystyle \binom{n}{k}
  4. 取补集$1$ 减去“全选错”的概率，得到“至少提交对一份”的概率。
    1−……\displaystyle 1 - \frac{\ldots}{\ldots}

AI 应用场景

场景一：企业级代码补全与多方案推荐

阶段：代码生成与候选筛选

解决的问题：传统 IDE 补全只能续写相邻几个 token，遇到复杂业务函数就无能为力，开发者陷入“写错—报错—改写”的循环。借鉴 AlphaCode 的“生成—过滤—提交”范式，工具可同时生成多份实现候选，用编译器和仓库现有单元测试充当“公开样例”自动过滤，再按实现思路聚类去重，把少量多样方案推给开发者。

具体案例：某大型企业的内部 AI 编程助手在函数级补全时，同时生成 5 份候选实现，自动运行模块测试过滤后聚类保留 2 类（如“循环实现”与“内置函数实现”），开发者一键选用。相比逐行补全，任务完成率和代码接受率大幅提升。

场景二：自动化 Bug 修复与回归验证

阶段：程序合成与验证

解决的问题：传统 Bug 修复依赖人工定位、手写补丁、跑回归测试，链路长且容易引入新缺陷。AlphaCode 思路提供了新解法：让模型围绕报错生成大量候选补丁，用项目回归测试作为“样例过滤器”，通过后再用探针输入聚类去重，最终只向开发者提交少量高置信补丁。

具体案例：某公司的 CI 机器人检测到空指针异常后，自动调用代码大模型生成 60 个候选补丁，在 500 个回归用例上执行，保留全部通过的 8 个，按行为聚类为 2 类，自动生成 2 条带说明的 PR 供工程师审核，修复时间从 3 小时缩短到 20 分钟。

场景三：在线判题系统的智能出题与题解生成

阶段：问题理解与答案生成

解决的问题：OJ 平台的新题需要人工编写题面、标准解和隐藏测试数据，成本极高。AlphaCode 的问题理解与生成筛选能力可以用于：自动生成参考解、自动构造边缘测试、自动评估题目难度，把出题者从重复劳动中解放出来。

具体案例：某教育公司用 AlphaCode 思路搭建“解题机器人”：为一道新语法题生成 200 份参考实现，用公开样例过滤后聚类，自动挑选 3 份风格不同的题解；再根据候选程序在隐藏测试上的通过率自动估计题目难度，辅助教师选题。

Python 演示

python71 行
"""小型 AlphaCode 流水线: 批量生成 -> 样例过滤 -> 聚类提交""" from collections import defaultdictimport random  def run(prog, x):    """模拟执行程序: 求列表元素和, 个别候选会多算/漏算特定数字"""    if prog == "ok":        return sum(x)    if prog == "d7":        return sum(x) + (7 if 7 in x else 0)    if prog == "d9":        return sum(x) + (9 if 9 in x else 0)    if prog == "s3":        return sum(x) - (3 if 3 in x else 0)    if prog == "even":        return sum(v for v in x if v % 2 == 0)    return 0  # 公开样例: 仅两条, 模拟竞赛题给出的输入输出示例SAMPLES = [([1, 2, 3], 6), ([4, 5], 9)] # 探针输入: 聚类阶段使用, 用于区分不同候选程序的行为PROBES = [[7, 1], [9, 6], [3, 3]]  def make_candidates(n=300, seed=42):    """第一步: 批量生成 n 份候选程序(模拟模型采样)"""    rng = random.Random(seed)    names = ["ok", "d7", "d9", "s3", "even"]    return [{"id": i, "prog": rng.choice(names)} for i in range(n)]  def filter_by_samples(cands):    """第二步: 在全部公开样例上运行, 全部通过才保留"""    passed = []    for c in cands:        if all(run(c["prog"], x) == y for x, y in SAMPLES):            passed.append(c)    return passed  def cluster_and_submit(passed, top_n=10):    """第三步: 用探针计算行为指纹并聚类, 每类取代表提交"""    groups = defaultdict(list)    for c in passed:        trace = tuple(run(c["prog"], p) for p in PROBES)        groups[trace].append(c)    submitted = []    for trace, members in sorted(groups.items(), key=lambda kv: -len(kv[1])):        submitted.append(members[0])        if len(submitted) >= top_n:            break    return submitted  def main():    cands = make_candidates()    passed = filter_by_samples(cands)    submitted = cluster_and_submit(passed)    print("批量生成候选:", len(cands))    print("通过公开样例:", len(passed))    print("聚类后提交:", len(submitted))    for c in submitted:        print("  #%03d -> %s" % (c["id"], c["prog"]))  if __name__ == "__main__":    main()
目的：用一个小型可运行的模拟器，完整演示 AlphaCode“批量生成→样例过滤→聚类提交”的核心管线——它会把 300 份候选压缩到 3 种不同行为，并各派一名代表提交。
  1. SAMPLES = [([1, 2, 3], 6), ([4, 5], 9)]公开样例只有两条，象征竞赛题给出的示例，条件很宽，很多“隐藏 bug”能溜过去。
  2. PROBES = [[7, 1], [9, 6], [3, 3]]探针输入在聚类时才使用，用来暴露不同候选的行为差异。
  3. if prog == "d7":一类“貌似正确”的候选：见到 7 就重复计数，这就是“过了样例但另有心思”的程序。
  4. def make_candidates(n=300, seed=42):模拟模型一次性采样 300 份候选，对应 AlphaCode 的百万级生成。
  5. if all(run(c["prog"], x) == y for x, y in SAMPLES):第一道筛子：全部公开样例通过，对应“样例过滤”。
  6. trace = tuple(run(c["prog"], p) for p in PROBES)把候选在探针上的输出变成“行为指纹”。
  7. groups[trace].append(c)指纹相同的聚成一类，行为完全一致的互相去重。
  8. submitted.append(members[0])每类只派一个代表进入提交名单，保住多样性。

常见误区

误区AlphaCode 排名高，肯定是因为它背了题库，比赛时把题目拿去匹配相似的题解，再抄过来提交。

正解竞赛题几乎不可能在题库中撞见原题，AlphaCode 也没有任何检索步骤。它是端到端生成：把题目描述和样例直接输入模型，输出一串代码。这些代码是模型在推理时当场“想出来”的，与搜索引擎有本质区别。程序合成研究的目标正是“生成”而非“检索”。

为何常见：人们习惯把“AI 会做题”类比为记忆加搜索，而忽略了程序合成的生成性质，于是用应试教育的经验去解释 AlphaCode。

误区AlphaCode 大概像一个人类选手，看完题认真写出唯一一份最优解，检查一下就提交。

正解它实际为每道题生成多达 100 万个候选程序，用公开样例过滤掉约 90%，再聚类去重，最终最多提交 10 份。它不是“写一份认真交卷”，而是“写百万份、扔九成、交十份”。这道流水线是它最核心的设计，不是辅助手段。

为何常见：人类解题的“一份定稿”经验被下意识套用到 AI 身上，大家很难想象“靠数量取胜”也是一种高级策略。

误区只要候选代码在题目给的输入输出样例上全部通过，它就是正确答案，可以直接放心提交。

正解公开样例只是“弱验证”，覆盖极其有限。AlphaCode 有大量代码能通过几条公开样例，却在隐藏测试上失败——这正是它要聚类并提交多份答案的原因。通过公开样例只是第一道筛子，隐藏测试才是真正的判卷标准。

为何常见：新手刷题时常以“样例通过”为完成标志，忽视了测试覆盖的有限性，把“验证通过”等同于“程序正确”。

误区AlphaCode 排名前 54.7%，说明它在编程领域已经超过了一半以上的人类，AI 编程很快要取代程序员了。

正解54.7% 意味着它大约位于人类中位偏上，与“顶尖”还差得远；它在 10 场竞赛中只解决了约 34% 的题，大多数难题仍然做不出来。更重要的是，它只在竞赛编程这一封闭任务上有效，换到业务开发、系统设计等开放场景就会失效。它的意义是“到达了人类中位”，而不是“超越了人类”。

为何常见：媒体标题常把“前 54.7%”渲染成震撼数字，读者容易把“中等水平”误解为“顶尖水平”。

面试题

Q1. AlphaCode 在 Codeforces 竞赛中的平均排名大约是什么水平？

单选题 · easy

  • A.前 5% 的顶尖选手
  • B.前 54.7% 中位水平← 正确答案
  • C.击败全部参赛选手
  • D.远低于人类基础水平

答案：B。AlphaCode 在 10 场 Codeforces 竞赛中的平均排名为前 54.7%，约等于人类中位偏上水平。A 把它夸大成前 5% 的顶尖选手，与事实不符；C 说击败全部选手明显夸大；D 说远低于人类基准与中位成绩矛盾，故选 B。

Q2. AlphaCode 解题时最重要的输入是什么？

单选题 · easy

  • A.标准答案的查重数据库
  • B.题面描述和输入输出样例← 正确答案
  • C.人类选手的人工提示词
  • D.已经验证的高分提交代码

答案：B。AlphaCode 的任务输入是题目描述加少量输入输出样例，端到端生成代码，不查库、不需要人工提示词、也不依赖已有提交。A、C、D 都不是它的输入形式，故选 B。

Q3. AlphaCode 生成百万候选后，筛选环节做了哪些操作？

多选题 · mid

  • A.用公开样例运行并过滤← 正确答案
  • B.按行为指纹聚类去重← 正确答案
  • C.从每个聚类挑代表提交← 正确答案
  • D.用人类评审逐行人工检查

答案：ABC。AlphaCode 的筛选是全自动的：先让候选在公开样例上运行并过滤，再按程序在探针输入上的输出轨迹（行为指纹）聚类去重，最后从每类中挑代表提交最多 10 份。D 的人工评审不在其自动管线中，故选 A、B、C。

Q4. AlphaCode 底层模型的主干架构是什么？

单选题 · mid

  • A.循环神经网络 LSTM 结构
  • B.基于 Transformer 的编码器解码器← 正确答案
  • C.传统卷积神经网络 CNN
  • D.遗传算法的种群演化框架

答案：B。AlphaCode 使用基于 Transformer 的编码器-解码器架构，编码器读题、解码器逐 token 生成代码。LSTM（A）是早期序列模型，CNN（C）主要用于图像，遗传算法（D）属于符号搜索，都不是 AlphaCode 的主干，故选 B。

Q5. 为什么 AlphaCode 聚类后再挑选提交答案？

单选题 · mid

  • A.减少存储空间降低运行开销
  • B.避免行为相同的重复解同时覆灭← 正确答案
  • C.让提交的代码更加美观规范
  • D.聚类可以让代码运行更快

答案：B。同一思路的程序在隐藏测试上的命运往往相同——要么一起对，要么一起错。聚类去重保证最后提交的 10 份答案覆盖不同思路，从而提升“至少一份正确”的概率。它与存储、美观、运行速度无关，故选 B。

Q6. 温度参数 τ 增大时，采样分布会怎样变化？

单选题 · hard

  • A.分布更尖锐近似贪心解码
  • B.分布更平滑、生成更加多样← 正确答案
  • C.分布完全不受任何影响
  • D.分布先变尖后变平滑

答案：B。logits 先除以 τ 再做 softmax：τ 越大，打分越接近，概率分布越平滑，低概率 token 被选中的机会增大，生成更多样；τ 趋近 0 时趋近贪心解码。它影响的是“探索与利用”的平衡，故选 B。

Q7. 关于 AlphaCode 的训练过程，下列说法正确的是？

多选题 · mid

  • A.先在 GitHub 海量代码上预训练← 正确答案
  • B.再用竞赛题目与解法微调← 正确答案
  • C.全程没有使用任何人类代码
  • D.训练数据包含多种语言代码← 正确答案

答案：ABD。AlphaCode 先在 GitHub 开源的多种语言代码上预训练，学习编程基础；再在包含 Codeforces 等竞赛题解的数据集上微调，学习竞赛解题模式。C 错误，因为 GitHub 代码本身就是人类编写的数据，故选 A、B、D。

Q8. pass@k 指标描述的是：

单选题 · easy

  • A.模型的推理速度有多快
  • B.生成 k 个候选至少一个正确← 正确答案
  • C.代码编译通过的概率
  • D.程序运行时间的占比

答案：B。pass@k 衡量“生成 k 份代码时至少有一份通过隐藏测试”的概率，是 AlphaCode 这类“多候选生成”系统的核心评价指标。它不关心速度（A）、编译器行为（C）或运行时间（D），故选 B。

Q9. 若想显著提升 pass@k 的期望值，最有效的手段是？

单选题 · hard

  • A.降低温度只输出一个结果
  • B.增加候选数并保证单次成功率← 正确答案
  • C.尽量减少聚类分组的数量
  • D.让公开样例数量接近隐藏测试

答案：B。pass@k 随候选总数 n 和单次正确率上升而上升——海量生成加质量保障是直接杠杆。降低温度并只输出一个结果相当于放弃多候选优势；减少聚类或增多样例都不是直接手段，故选 B。

Q10. 已知模型生成了 10 个候选，其中有 3 个正确，若每次提交 2 个（k=2），pass@2 的精确值约为？

单选题 · extreme

  • A.约 0.40
  • B.约 0.53← 正确答案
  • C.约 0.60
  • D.约 0.72

答案：B。利用精确公式 pass@k = 1 − C(n−c,k)/C(n,k)，代入 n=10、c=3、k=2，得 1 − C(7,2)/C(10,2) = 1 − 21/45 ≈ 0.53，即随机提交 2 份候选时至少命中的概率。故选 B。