refactor(前端): shared / utils 不再 import oj 和 admin 下的任何东西

依赖方向原来是反的：顶栏、登录框、举手列表这些 shared 组件从 oj/ 里拿东西。
- 跨端的接口挪进 shared/api.ts（按 apps/web/CLAUDE.md 的分法）：学生端题目列表、
  出题人列表、这节课的题、待弹的成就
- 这节课的 store → shared/store/lesson.ts；头像 RankAvatar → shared/components
- 纯函数挪进 utils/：举手列表的错法归类 errorKind、它依赖的答案错误分类 wrongAnswer
  和 Python 报错翻译 pythonError、题目列表行的 toProblemRow
- 只有后台在用的出题人下拉 AuthorSelect 挪回 admin/components

纯搬家。首页、题目列表、题目页、排名、课堂看板、后台题目列表打开无报错，
顶栏题号框敲 1001 回车直达题目页。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

apps/web/src/utils/errorKind.ts

@@ -0,0 +1,107 @@
+import { classifyDiff, type DiffKind } from "utils/wrongAnswer"
+import { JUDGE_STATUS, SubmissionStatus } from "utils/constants"
+import type { ClassBoardCell } from "utils/types"
+
+/**
+ * 课堂看板：一道题错着的人「按错法归堆」（设计稿「课堂看板重设计」A+B）。老师讲错误时
+ * 要的是「这道题全班错在哪」：同一种错讲一遍就够，所以按最后一次提交归类，堆名要短，
+ * 一眼能读完 —— 长的中文解释在点开之后的弹层里（和提交详情同一份）。
+ *
+ * 依据是提交里存的 runtime_error / sample_check（判题机写的），和提交详情、题目页结果区同源。
+ */
+export type BoardLatest = NonNullable<ClassBoardCell["latest"]>
+
+export interface ErrorKind {
+  /** 归堆用：同一个 key 是同一种错 */
+  key: string
+  label: string
+  /** 报错指到的行，答案错误没有 */
+  line: number | null
+}
+
+const DIFF_LABEL: Record<DiffKind, string> = {
+  "no-output": "什么都没输出",
+  whitespace: "只差空格、换行",
+  punctuation: "中英文标点不对",
+  case: "大小写不对",
+  extra: "多输出了东西",
+  missing: "少输出了东西",
+  "number-format": "小数位数不对",
+  values: "算出来的数不对",
+  other: "输出和例子不一样",
+}
+
+/** runtime-diagnosis.ts 细分出来的 kind 里常见的几种；没列的按异常类型归 */
+const KIND_LABEL: Record<string, string> = {
+  "int-parse": "int() 转换失败",
+  "float-parse": "float() 转换失败",
+  unpack: "拆出来的个数对不上",
+  "unpack-number": "一个数拆给好几个变量",
+  "str-concat": "文字和数字用 + 连",
+  operand: "文字和数字一起算",
+  compare: "文字和数字比大小",
+  "not-int": "该给整数的地方不是整数",
+  "format-spec": "保留小数的格式写错",
+  "not-callable": "把不是函数的当函数用",
+  "func-value": "函数名后面忘了括号",
+  "none-value": "拿 None 接着用",
+  "map-value": "map() 的结果没转成列表",
+}
+
+const TYPE_LABEL: Record<string, string> = {
+  EOFError: "input() 用多了",
+  IndexError: "下标越界",
+  ZeroDivisionError: "除以 0",
+  KeyError: "字典里没有这个键",
+  RecursionError: "递归停不下来",
+  UnboundLocalError: "变量还没赋值就用",
+  ModuleNotFoundError: "导入了没有的模块",
+  ImportError: "导入了没有的模块",
+  ValueError: "值不符合要求",
+  TypeError: "类型不对",
+}
+
+/** C / C++ 只有信号：11 段错误、8 除零 */
+const SIGNAL_LABEL: Record<number, string> = {
+  11: "数组越界或指针出错",
+  8: "除以 0",
+}
+
+export function errorKind(latest: BoardLatest): ErrorKind {
+  const result = latest.result
+  if (result === SubmissionStatus.wrong_answer) {
+    const check = latest.sampleCheck
+    if (!check) return { key: "wa", label: "答案错误", line: null }
+    if (check.passed) return { key: "wa-hidden", label: "例子都对，错在没公开的测试点", line: null }
+    const diff = classifyDiff(check.expected ?? "", check.output ?? "")
+    return { key: `wa-${diff}`, label: DIFF_LABEL[diff], line: null }
+  }
+  if (result === SubmissionStatus.runtime_error) {
+    const rt = latest.runtimeError
+    const line = rt?.line ?? null
+    if (!rt) return { key: "re", label: "运行时出错", line }
+    if (rt.signal && SIGNAL_LABEL[rt.signal]) {
+      return { key: `re-signal-${rt.signal}`, label: SIGNAL_LABEL[rt.signal]!, line }
+    }
+    if (rt.type === "NameError") {
+      return rt.name
+        ? { key: `re-name-${rt.name}`, label: `「${rt.name}」没有定义`, line }
+        : { key: "re-name", label: "用了没定义的名字", line }
+    }
+    if (rt.kind && KIND_LABEL[rt.kind]) {
+      return { key: `re-${rt.kind}`, label: KIND_LABEL[rt.kind]!, line }
+    }
+    if (rt.type && TYPE_LABEL[rt.type]) {
+      return { key: `re-${rt.type}`, label: TYPE_LABEL[rt.type]!, line }
+    }
+    return { key: "re", label: "运行时出错", line }
+  }
+  if (result === SubmissionStatus.compile_error) {
+    return { key: "ce", label: "编译没通过", line: null }
+  }
+  return {
+    key: `r${result}`,
+    label: JUDGE_STATUS[result as keyof typeof JUDGE_STATUS]?.name ?? "没通过",
+    line: null,
+  }
+}

apps/web/src/utils/pythonError.ts

@@ -0,0 +1,358 @@
+/**
+ * 把 Python 的编译错误（`statistic_info.err_info`）翻成中文。
+ *
+ * 学生是中职生，英文报错等于没有报错。好在句式非常集中：2025 秋以来 2700 条
+ * Python 编译错误里，前 12 种句子占 91%、前 16 种占 97%，所以这里是一张规则表，
+ * 不是通用翻译。第二名「invalid character」（22%）几乎全是中文标点，另有一键修复，
+ * 见 chinesePunctuation.ts。
+ *
+ * 判题机给的原文有两种形状：
+ *
+ *     File "/judger/run/<随机目录>/solution.py", line 7
+ *         print("{:.0f}"."{:.2f}".format(x))
+ *                        ^^^^^^^^
+ *     SyntaxError: invalid syntax
+ *
+ *     Sorry: IndentationError: unexpected indent (solution.py, line 3)
+ *
+ * 第一种的代码行是 Python 去掉**行首空格**之后再垫 4 个空格打出来的，`^` 的列号
+ * 按去掉之后的算（traceback 的 `_format_syntax_error`，3.10 起如此）。
+ */
+
+export interface PythonErrorExplanation {
+  /** 出错的行，1 起 */
+  line: number | null
+  /** 判题机打出来的那一行代码（去掉了行首空格），用来和编辑器里的对位 */
+  sourceLine: string | null
+  /** `^` 在 sourceLine 里标的范围，[from, to) */
+  caret: { from: number; to: number } | null
+  /** 给学生看的中文说明，不含行号 */
+  message: string
+  /** 报错点名的那个中文标点；有它才出「一键换成英文」 */
+  punctuation: string | null
+}
+
+// 行首可能有空格：报错前面先打了一条 SyntaxWarning（比如 `3and`）时，File 那行是缩进的
+const WHERE_RE = /^\s*File "[^"]*", line (\d+)/m
+const SHORT_RE = /^Sorry: (\w+Error): (.*) \([^,()]*, line (\d+)\)\s*$/m
+
+/**
+ * 中文空格（U+3000）。写成常量而不是字面量：Oxfmt 会把字符串里的 `\u3000` 转义
+ * 还原成原字符，那样源码里就是一个看不见的空白。
+ */
+const IDEOGRAPHIC_SPACE = String.fromCharCode(0x3000)
+
+/** 中文标点 → 英文。「。」不在表里：它多半是句末多打的，换成「.」照样错，只能删 */
+export const PUNCTUATION_MAP: Record<string, string> = {
+  "（": "(",
+  "）": ")",
+  "，": ",",
+  "：": ":",
+  "；": ";",
+  "【": "[",
+  "】": "]",
+  "｛": "{",
+  "｝": "}",
+  "！": "!",
+  "？": "?",
+  "＝": "=",
+  "＋": "+",
+  "－": "-",
+  "＊": "*",
+  "／": "/",
+  "＜": "<",
+  "＞": ">",
+  "“": '"',
+  "”": '"',
+  "‘": "'",
+  "’": "'",
+  "＂": '"',
+  "＃": "#",
+  "×": "*",
+  "÷": "/",
+  [IDEOGRAPHIC_SPACE]: " ",
+}
+
+/**
+ * 标点的名字。说明里**只说名字、不拿字形对比**：「：」和「:」、「，」和「,」在正文字体里
+ * 几乎一样，「把「：」换成「:」」这句话学生看不出区别。「冒号是中文的，要换成英文的」
+ * 看得懂，要换哪一个由卡片里那行代码的标红来指。
+ */
+export const PUNCTUATION_NAMES: Record<string, string> = {
+  "（": "左括号",
+  "）": "右括号",
+  "，": "逗号",
+  "：": "冒号",
+  "；": "分号",
+  "【": "左方括号",
+  "】": "右方括号",
+  "｛": "左花括号",
+  "｝": "右花括号",
+  "！": "感叹号",
+  "？": "问号",
+  "＝": "等号",
+  "＋": "加号",
+  "－": "减号",
+  "＊": "星号",
+  "／": "斜杠",
+  "＜": "小于号",
+  "＞": "大于号",
+  "“": "引号",
+  "”": "引号",
+  "‘": "单引号",
+  "’": "单引号",
+  "＂": "引号",
+  "＃": "井号",
+  [IDEOGRAPHIC_SPACE]: "空格",
+}
+
+/**
+ * 规则除了报错原文，还能看出错的那一行（判题机打出来的，去掉了行首空格）。同一句报错
+ * 学生错法不同，要看那一行才分得开：`expected ':'` 九成是 `else a < 60:`，行尾明明有冒号；
+ * 「Maybe you meant '=='」只有 if / while 那行才是真想判断相等。返回 null 就接着往下找。
+ */
+type Rule = [RegExp, (match: RegExpMatchArray, source: string) => string | null]
+
+/** 去掉引号里的内容，只看代码本身的符号 */
+function stripStrings(source: string) {
+  return source.replace(/(["'])(?:\\.|(?!\1).)*\1/g, '""')
+}
+
+/** 括号外面的逗号：`if a > 9, a < 100:` 里有，`if x in (1, 2):` 里没有 */
+function hasTopLevelComma(source: string) {
+  let depth = 0
+  for (const ch of stripStrings(source)) {
+    if ("([{".includes(ch)) depth++
+    else if (")]}".includes(ch)) depth--
+    else if (ch === "," && depth === 0) return true
+  }
+  return false
+}
+
+const CONDITION_LINE = /^(if|elif|while)\b/
+
+const RULES: Rule[] = [
+  [
+    // u：emoji 是两个 UTF-16 单元，不带 u 的 (.) 对不上
+    /^invalid character '(.)'/u,
+    ([, char]) => {
+      // 数学符号不是「中文的」，是写法不对：代码里乘除用 * 和 /
+      if (char === "×") return "这里用了乘号「×」，代码里的乘法要写成星号「*」。"
+      if (char === "÷") return "这里用了除号「÷」，代码里的除法要写成斜杠「/」。"
+      if (char === "√")
+        return "代码里没有根号「√」：开平方写成 x ** 0.5，或者 import math 之后用 math.sqrt(x)。"
+      if (char === "²" || char === "³")
+        return `代码里没有上标的「${char}」：平方写成 x ** 2，立方写成 x ** 3。`
+      if (char === "≤") return "代码里没有「≤」：小于等于要写成小于号加等号 <=。"
+      if (char === "≥") return "代码里没有「≥」：大于等于要写成大于号加等号 >=。"
+      if (char === "≠") return "代码里没有「≠」：不等于要写成感叹号加等号 !=。"
+      if (char === "、")
+        return "代码里不用顿号「、」：几样东西之间要用英文逗号隔开。写代码的时候先切换到英文输入法。"
+      const name = PUNCTUATION_NAMES[char!]
+      if (name) {
+        return `这里的${name}是中文输入法打出来的，要换成英文的${name}。写代码的时候先切换到英文输入法。`
+      }
+      if (char === "。") return "这里多了一个中文句号「。」，代码里不用句号，删掉它。"
+      return `这里有一个不能出现在代码里的字符「${char}」，多半是中文输入法打出来的，删掉后用英文输入法重新打。`
+    },
+  ],
+  [
+    /^invalid non-printable character/,
+    () => "这里有一个看不见的特殊字符，多半是从别处复制过来的。把这一行删掉，自己重新打一遍。",
+  ],
+  [
+    /^expected ':'/,
+    (_, source) =>
+      /^else\b\s*[^\s:]/.test(source)
+        ? "else 后面不能写条件，它的意思是「上面的条件都不满足」。还要再判断一个条件，就用 elif 条件:。"
+        : "这一行末尾少了英文冒号「:」。if、elif、else、for、while、def 这些行的最后都要有冒号。",
+  ],
+  [
+    /^expected an indented block after '(\w+)' statement on line (\d+)/,
+    ([, keyword, owner]) =>
+      `这一行要往里缩进（按一下 Tab 键）：它是第 ${owner} 行那个 ${keyword} 要管的代码。`,
+  ],
+  [
+    /^expected an indented block/,
+    () => "这一行要往里缩进（按一下 Tab 键）：上一行以冒号结尾，它下面的代码都要缩进。",
+  ],
+  [
+    /^unexpected indent/,
+    () => "这一行前面多了空格。只有 if、for 这类以冒号结尾的行，它下面的代码才要往里缩进。",
+  ],
+  [
+    /^unindent does not match any outer indentation level/,
+    () =>
+      "这一行前面的空格数和上面对不齐。同一层的代码，前面的空格要一样多，建议统一用 Tab 键缩进。",
+  ],
+  [
+    /^inconsistent use of tabs and spaces/,
+    () => "这一行的缩进混用了 Tab 键和空格键，统一只用 Tab 键缩进。",
+  ],
+  [
+    /^invalid syntax\. Perhaps you forgot a comma\?/,
+    // 抽样一半以上是拼文字漏了 +：print(a+"是"a+"岁")
+    () =>
+      "这里的几样东西之间少了连接的符号：要分开输出，用英文逗号「,」隔开；要把文字拼在一起，用加号「+」。",
+  ],
+  [
+    /Maybe you meant '==' instead of '='|Maybe you meant '==' or ':=' instead of '='|perhaps you meant "=="/,
+    (_, source) => {
+      // 只有条件里才是真想判断相等；别的行是想赋值，写法错了
+      if (CONDITION_LINE.test(source))
+        return "判断「是不是相等」要用两个等号「==」。一个等号「=」的意思是「把右边的值存进左边的变量」。"
+      if (/^\w+\s*=[^=].*,\s*\w+\s*=[^=]/.test(stripStrings(source)))
+        return "一行里给几个变量赋值，要写成 a, b = 96, 92，或者分成几行，一行写一个。"
+      if (/^\w+\s*\(/.test(source))
+        return '括号里不能直接写等号「=」。要把等号显示出来，就把它放进引号里，比如 print(a, "+", b, "=", a + b)。'
+      return null
+    },
+  ],
+  [
+    /^cannot assign to /,
+    () =>
+      "等号「=」的左边只能是一个变量名，意思是「把右边算出来的值存进这个变量」。比如要写成 c = a + b，不能写成 a + b = c。",
+  ],
+  [
+    /^unterminated (triple-quoted )?(f-)?string literal/,
+    () => "这一行的引号没有配对。字符串要用一对英文引号括起来，开头一个、结尾一个。",
+  ],
+  [
+    /^'(.)' was never closed/,
+    ([, open]) => `这里的「${open}」没有配对的另一半。数一数左右括号是不是一样多。`,
+  ],
+  [/^unmatched '(.)'/, ([, close]) => `这里多了一个「${close}」，前面没有和它配对的括号。`],
+  [
+    /^closing parenthesis '(.)' does not match opening parenthesis '(.)'/,
+    ([, close, open]) => `括号配错了：「${open}」要用和它配对的括号来关，不能用「${close}」。`,
+  ],
+  [
+    /^Missing parentheses in call to '(\w+)'/,
+    ([, name]) => `${name} 后面要加括号，写成 ${name}(...)。`,
+  ],
+  [
+    /^invalid decimal literal/,
+    () => "数字后面紧跟着字母了。比如「2a」要写成「2*a」；变量名也不能用数字开头。",
+  ],
+  [
+    /^unexpected character after line continuation character/,
+    () => "这里的反斜杠「\\」用错了。除法要用「/」，「\\」只能出现在引号里面。",
+  ],
+  [
+    /^'(break|continue)' (not properly in|outside) loop/,
+    ([, keyword]) => `${keyword} 只能写在 for 或 while 循环里面（要缩进在循环的下面）。`,
+  ],
+  [
+    /^'return' outside function/,
+    () => "return 只能写在 def 定义的函数里面（要缩进在 def 的下面）。",
+  ],
+  [
+    /^f-string: (expecting '}'|single '}' is not allowed)/,
+    () => "f 字符串里的花括号「{ }」没有配对，每个「{」都要有一个「}」。",
+  ],
+  [
+    /^f-string: valid expression required/,
+    () => "f 字符串的花括号「{ }」里要写变量名或算式，不能空着。",
+  ],
+  [
+    /^leading zeros in decimal integer literals/,
+    () => "整数不能用 0 开头，比如「07」要写成「7」。",
+  ],
+  [
+    /^invalid syntax/,
+    (_, source) => {
+      if (/^elif\s*:/.test(source))
+        return "elif 后面要写条件，比如 elif a > 60:。不需要条件的话就用 else:。"
+      if (/^else\s+if\b/.test(source)) return "Python 里「否则如果」要写成 elif，不是 else if。"
+      if (/^(esle|eles|els|elese|esif|elsif|elseif|eilf|elfi)\b/.test(source))
+        return "这一行开头的关键字拼错了：「否则」是 else，「否则如果」是 elif。"
+      const code = stripStrings(source)
+      if (/=<|=>/.test(code)) return "小于等于要写成 <=，大于等于要写成 >=，等号放在后面。"
+      if (CONDITION_LINE.test(source) && hasTopLevelComma(source))
+        return "条件之间不能用逗号连：两个都要满足用 and，满足一个就行用 or，比如 if a > 9 and a < 100:。"
+      return null
+    },
+  ],
+  [
+    /^invalid syntax/,
+    () =>
+      "标出来的地方写法不对。对照教程检查这一行：括号、引号、冒号、运算符有没有写错、漏写或多写。",
+  ],
+]
+
+function translate(message: string, source: string) {
+  for (const [pattern, render] of RULES) {
+    const match = message.match(pattern)
+    const text = match && render(match, source)
+    if (text) return text
+  }
+  return null
+}
+
+/**
+ * 选了 Python 却交了 C 代码：全库 310 条，报错各式各样（多半是 invalid syntax），
+ * 挨个解释毫无意义，该说的只有一句
+ */
+function looksLikeC(code: string) {
+  if (/^\s*#\s*include\b|\bint\s+main\s*\(/m.test(code)) return true
+  // 只凭 printf 不算：Python 代码里把 print 手误成 printf 的不少
+  return /\b(printf|scanf)\s*\(|\bcout\s*<</.test(code) && !/\b(print|input)\s*\(/.test(code)
+}
+
+/**
+ * 翻不出来（判题机自己的报错、没见过的句式）就返回 null，界面照旧显示原文。
+ * `code` 是学生的代码，用来认出「交的其实是 C」
+ */
+export function explainPythonCompileError(
+  errInfo: string,
+  code = "",
+): PythonErrorExplanation | null {
+  const text = errInfo.trim()
+
+  const short = text.match(SHORT_RE)
+  if (short) {
+    const [, , detail, line] = short
+    const message = translate(detail!, "")
+    if (!message) return null
+    return {
+      line: Number(line),
+      sourceLine: null,
+      caret: null,
+      message,
+      punctuation: null,
+    }
+  }
+
+  const where = text.match(WHERE_RE)
+  const lines = text.split("\n")
+  const last = lines[lines.length - 1]!
+  const detail = last.replace(/^\w+Error: /, "")
+  if (detail === last) return null
+
+  let sourceLine: string | null = null
+  let caret: PythonErrorExplanation["caret"] = null
+  if (where) {
+    const index = lines.findIndex((line) => WHERE_RE.test(line))
+    const code = lines[index + 1]
+    const marks = lines[index + 2]
+    if (code?.startsWith("    ")) sourceLine = code.slice(4)
+    if (sourceLine !== null && marks?.startsWith("    ")) {
+      const from = marks.indexOf("^")
+      if (from >= 4) caret = { from: from - 4, to: marks.lastIndexOf("^") - 4 + 1 }
+    }
+  }
+
+  const message = looksLikeC(code)
+    ? "这是 C 语言的代码，可提交时选的语言是 Python。把语言换成 C 再交。"
+    : translate(detail, sourceLine?.trim() ?? "")
+  if (!message) return null
+
+  const char = detail.match(/^invalid character '(.)'/u)?.[1]
+  return {
+    line: where ? Number(where[1]) : null,
+    sourceLine,
+    caret,
+    message,
+    punctuation: char && PUNCTUATION_MAP[char] ? char : null,
+  }
+}

apps/web/src/utils/transforms.ts

@@ -0,0 +1,30 @@
+import { DIFFICULTY } from "utils/constants"
+import { getACRate } from "utils/functions"
+import type { ProblemRow, ProblemListItem } from "utils/types"
+
+// 把后端的列表项塑形成列表页需要的形状，与请求逻辑解耦。
+export function toProblemRow(result: ProblemListItem): ProblemRow {
+  return {
+    id: result.id,
+    _id: result._id,
+    title: result.title,
+    difficulty: result.difficulty ? DIFFICULTY[result.difficulty] : null,
+    tags: result.tags,
+    submissionCount: result.submissionNumber,
+    acRate: getACRate(result.acceptedNumber, result.submissionNumber),
+    // null / undefined 都表示「没做过」
+    status:
+      result.myStatus === null || result.myStatus === undefined
+        ? "not_test"
+        : result.myStatus === 0
+          ? "passed"
+          : "failed",
+    author: result.createdBy.username,
+    allowFlowchart: result.allowFlowchart,
+    showFlowchart: result.showFlowchart,
+    hasAstRules: result.hasAstRules,
+    isSql: result.isSql,
+    solvedUsers: result.solvedUsers,
+    triedUsers: result.triedUsers,
+  }
+}

apps/web/src/utils/wrongAnswer.ts

@@ -0,0 +1,192 @@
+import type { StatisticInfo } from "@oj2/contract"
+import { PUNCTUATION_MAP, PUNCTUATION_NAMES } from "utils/pythonError"
+
+/**
+ * 答案错误时，比较学生在**公开样例**上的输出和正确输出，归一类、给一句中文提示。
+ * 数据来自后端 judge/run.ts 的 checkSamples（`statistic_info.sample_check`）。
+ *
+ * 分类是拿 2025 秋以来 5055 条「样例上就错了」的答案错误定的：
+ * 格式和内容都不同 44%、数值不对 15%、没有输出 10%、多了文字 9%、只差空格换行 9%、
+ * 少了内容 5%、中英文标点 4%、数字写法（小数位数）2.5%、大小写 1%。
+ * 前几类之外的「几乎对了」合起来约三分之一，一句话就能改对。
+ *
+ * 样例是公开的，这里可以放心地把具体的值说出来（「正确输出是 84.10，你输出的是 84.1」）。
+ */
+export type SampleCheck = NonNullable<StatisticInfo["sample_check"]>
+
+export type DiffKind =
+  | "no-output"
+  | "whitespace"
+  | "punctuation"
+  | "case"
+  | "extra"
+  | "missing"
+  | "number-format"
+  | "values"
+  | "other"
+
+const NUMBER = /-?\d+(?:\.\d+)?/g
+
+function squash(text: string) {
+  return text.replace(/\s+/g, " ").trim()
+}
+
+function toEnglishPunctuation(text: string) {
+  return [...text].map((ch) => PUNCTUATION_MAP[ch] ?? ch).join("")
+}
+
+export function classifyDiff(expected: string, output: string): DiffKind {
+  const e = squash(expected)
+  const o = squash(output)
+  if (!o) return "no-output"
+  if (e === o) return "whitespace"
+  if (squash(toEnglishPunctuation(expected)) === squash(toEnglishPunctuation(output))) {
+    return "punctuation"
+  }
+  if (e.toLowerCase() === o.toLowerCase()) return "case"
+  // 数字先于「多了内容」判：007 里包含 7、3.0 里包含 3，先判包含就会把它们当成
+  // 「多打了说明文字」，给出完全不相干的建议
+  const en = e.match(NUMBER) ?? []
+  const on = o.match(NUMBER) ?? []
+  const sameShape = e.replace(NUMBER, "N") === o.replace(NUMBER, "N") && en.length === on.length
+  if (sameShape && en.length) {
+    const sameValues = en.every((value, i) => Math.abs(Number(value) - Number(on[i])) < 1e-9)
+    return sameValues ? "number-format" : "values"
+  }
+  if (e && o.includes(e)) return "extra"
+  if (o && e.includes(o)) return "missing"
+  return "other"
+}
+
+/** 第一处不一样的标点：[正确输出里的, 你输出的] */
+function firstPunctuationPair(expected: string, output: string) {
+  const e = [...squash(expected)]
+  const o = [...squash(output)]
+  for (let i = 0; i < Math.min(e.length, o.length); i++) {
+    if (e[i] !== o[i]) return [e[i]!, o[i]!] as const
+  }
+  return null
+}
+
+function punctuationHint(expected: string, output: string) {
+  const pair = firstPunctuationPair(expected, output)
+  if (pair) {
+    const [want, got] = pair
+    // 中文的那个才在名字表里
+    const name = PUNCTUATION_NAMES[got] ?? PUNCTUATION_NAMES[want]
+    if (name && PUNCTUATION_MAP[got] === want) {
+      return `内容对了，但标点不一样：正确输出用的是英文的${name}，你输出的是中文的${name}。输出里的标点要和题目完全一样。`
+    }
+    if (name && PUNCTUATION_MAP[want] === got) {
+      return `内容对了，但标点不一样：正确输出用的是中文的${name}，你输出的是英文的${name}。输出里的标点要和题目完全一样。`
+    }
+  }
+  return "内容对了，但标点不一样：输出里的标点要和题目完全一样，注意分清中文标点和英文标点。"
+}
+
+function numberFormatHint(expected: string, output: string, language: string) {
+  const en = squash(expected).match(NUMBER) ?? []
+  const on = squash(output).match(NUMBER) ?? []
+  const i = en.findIndex((value, k) => value !== on[k])
+  if (i < 0) return "数字的写法和正确输出不一样。"
+  const want = en[i]!
+  const got = on[i]!
+  const decimals = want.split(".")[1]?.length ?? 0
+  const head = `正确输出是 ${want}，你输出的是 ${got}。`
+  // 007 和 7：逆序数、取位数一类题的老毛病，跟小数没关系
+  if (/^-?0\d/.test(got)) {
+    const how = language === "Python" ? "用 int() 转成整数再输出" : "按整数（%d）输出"
+    return `${head}数字前面多了 0。要输出的是一个数，不是一串数字字符：${how}，前面的 0 就没了。`
+  }
+  if (decimals > 0) {
+    const how =
+      language === "Python"
+        ? `Python 可以写 f"{x:.${decimals}f}"`
+        : `C 语言可以写 printf("%.${decimals}f", x)`
+    return `${head}题目要求保留 ${decimals} 位小数，${how}。`
+  }
+  if (!got.includes(".")) return `${head}数字的写法和正确输出不一样。`
+  if (language === "Python") {
+    return `${head}这里要输出整数：Python 里 / 算出来的总是小数，整除要用 //，或者用 int() 转换。`
+  }
+  return `${head}这里要输出整数，不要带小数点：printf 用 %d 输出整数。`
+}
+
+/** Python 的 input("请输入……")：提示文字会被打印进输出，判题时必然对不上 */
+export function hasInputPrompt(code: string) {
+  return /\binput\(\s*[fr]?["'][^"'\n]*\S[^"'\n]*["']\s*\)/.test(code)
+}
+
+export function explainDiff(
+  kind: DiffKind,
+  check: SampleCheck,
+  code: string,
+  language: string,
+): string {
+  const expected = check.expected ?? ""
+  const output = check.output ?? ""
+  const printName = language === "Python" ? "print" : "printf"
+  switch (kind) {
+    case "no-output":
+      return `你的程序什么都没有输出。检查一下是不是忘了写 ${printName}，或者 ${printName} 写在了执行不到的地方（比如某个 if 的里面）。`
+    case "whitespace":
+      return "内容对了，只是空格或换行不一样。下面把空格画成了「·」、换行画成了「↵」，对照着看看哪一行多了或少了。"
+    case "punctuation":
+      return punctuationHint(expected, output)
+    case "case":
+      return "内容对了，只是字母的大小写不一样。输出要和题目的大小写完全一样。"
+    case "extra":
+      if (language === "Python" && hasInputPrompt(code)) {
+        return 'input() 括号里的提示文字也会被输出，判题时就对不上了。把 input("……") 里的文字删掉，只写 input()。'
+      }
+      return "你的输出比正确输出多了一些内容。题目要输出什么就只输出什么，不要加「请输入」「结果是」这类提示或说明文字。"
+    case "missing":
+      return "你的输出比正确输出少了一部分，对照看看漏了什么。"
+    case "number-format":
+      return numberFormatHint(expected, output, language)
+    case "values":
+      return "输出的格式对了，但算出来的数不对。拿这个例子的输入，自己一步一步算一遍，看看程序在哪一步和你想的不一样。"
+    case "other":
+      return otherHint(check)
+  }
+}
+
+/** 放进一句话里的值：太长的截断，免得一句提示撑满一屏 */
+function quote(text: string, max = 24) {
+  const flat = text.trim()
+  return `「${flat.length > max ? `${flat.slice(0, max)}…` : flat}」`
+}
+
+/**
+ * 「其他」：格式和内容都不一样（占样例错误的 44%）。原来只说「对照一下，找找从哪里开始
+ * 不一样」，对 D / E 这种整个值不同的情况没用 —— 学生看得出不一样，看不出为什么。
+ * 改成把具体的值说出来，再告诉他拿这个例子的输入去走一遍程序（设计文档第 6 节）。
+ */
+function otherHint(check: SampleCheck) {
+  const expected = (check.expected ?? "").replace(/\s+$/, "")
+  const output = (check.output ?? "").replace(/\s+$/, "")
+  const no = (check.index ?? 0) + 1
+  const input = (check.input ?? "").trim()
+  const walk =
+    input && !input.includes("\n") && input.length <= 24
+      ? `拿例子 ${no} 的输入${quote(input)}，一行一行走一遍你的程序，看它走进了哪个分支、算出了什么。`
+      : `拿例子 ${no} 的输入，一行一行走一遍你的程序，看它走进了哪个分支、算出了什么。`
+  if (!expected.includes("\n") && !output.includes("\n")) {
+    return `你的程序输出了${quote(output)}，正确的是${quote(expected)}。${walk}`
+  }
+  const line = firstDifferentLine(expected, output)
+  const want = expected.split("\n")[line] ?? ""
+  const got = output.split("\n")[line]
+  const gotText = got === undefined ? "什么都没有" : quote(got)
+  return `从第 ${line + 1} 行开始不一样：正确的是${quote(want)}，你输出的是${gotText}。${walk}`
+}
+
+/** 第一处不一样的行号，0 起；完全一样（只差结尾空白）时为 -1 */
+export function firstDifferentLine(expected: string, output: string) {
+  const e = expected.replace(/\s+$/, "").split("\n")
+  const o = output.replace(/\s+$/, "").split("\n")
+  for (let i = 0; i < Math.max(e.length, o.length); i++) {
+    if (e[i] !== o[i]) return i
+  }
+  return -1
+}