Google: Gemma 4 26B A4B 在「实现拼写检查器」的评测结果
这是该 AI 模型在此测试用例上的详细评测结果。
基本信息
- 模型名称：Google: Gemma 4 26B A4B
- 用例名称：实现拼写检查器
- 测试类型：文本生成
- 评测维度：代码生成
系统提示词（System Prompt）
这是给 AI 模型的背景设定和角色指令：
你是一名资深算法工程师，擅长字符串处理与动态规划算法。 回答要求： 1. 使用 Python 语言实现，代码需可直接运行。 2. 核心算法（编辑距离）必须使用动态规划实现，不得调用第三方库。 3. 代码需包含清晰的注释，解释关键步骤的逻辑。 4. 提供至少 3 组测试用例验证正确性，输出结果需格式清晰。 5. 追求代码简洁性与正确性，优先保证逻辑准确。
用户提示词（User Prompt）
这是用户给 AI 模型的具体任务要求：
请使用 Python 实现一个简单的拼写检查器，具体要求如下： **功能要求：** 1. 实现 `levenshtein_distance(word1, word2)` 函数，使用动态规划计算两个单词之间的编辑距离（Levenshtein Distance）。 - 编辑操作包括：插入一个字符、删除一个字符、替换一个字符，每种操作代价均为 1。 2. 实现 `spell_check(word, dictionary)` 函数： - 若 `word` 存在于 `dictionary` 中，返回 `{「correct」: True, 「suggestions」: []}`。 - 若 `word` 不在 `dictionary` 中，从词典中找出编辑距离最小的单词作为建议，返回 `{「correct」: False, 「suggestions」: [最相似单词列表]}`。 - 若存在多个编辑距离相同的最小值单词，全部包含在 `suggestions` 列表中，并按字母顺序排列。 - 检查时忽略大小写（统一转为小写处理）。 **输入输出示例：**
评测结果
综合得分
该模型在此用例的得分为：90.3 分（满分 100 分），已通过
基础难度评测结果
- 得分：90.3 分
- 通过状态：已通过
模型生成产物
以下是该模型针对此任务的实际生成内容：
你好！我是资深算法工程师。针对你的需求，我采用**动态规划（Dynamic Programming）**算法实现了 Levenshtein 距离，并构建了一个高效的拼写检查逻辑。 在处理编辑距离时，我们通过构建一个二维矩阵 `dp` 来记录子问题的解，其中 `dp[i][j]` 表示 `word1` 的前 `i` 个字符与 `word2` 的前 `j` 个字符之间的最小编辑操作数。 以下是完整的 Python 代码实现： ```python from typing import List, Dict, Any class SpellChecker: """ 拼写检查器类，利用动态规划计算编辑距离并提供纠错建议。 """ def levenshtein_distance(self, word1: str, word2: str) -> int: """ 使用动态规划计算两个字符串之间的编辑距离 (Levenshtein Distance)。 时间复杂度: O(m * n), 空间复杂度: O(m * n)，其中 m, n 为字符串长度。 """ m, n = len(word1), len(word2) # 初始化 dp 矩阵，(m+1) x (n+1) # dp[i][j] 表示 word1[:i] 与 word2[:j] 的编辑距离 dp = [[0] * (n + 1) for _ in range(m + 1)] # 边界情况：当一个字符串为空时，编辑距离等于另一个字符串的长度（全部插入或删除） for i in range(m + 1): dp[i][0] = i for j in range(n + 1): dp[0][j] = j # 状态转移 for i in range(1, m + 1): for j in range(1, n + 1): if word1[i - 1] == word2[j - 1]: # 如果当前字符相等，不需要任何操作 dp[i][j] = dp[i - 1][j - 1] else: # 如果不相等，取三种操作中的最小值 + 1 # dp[i-1][j] -> 删除操作 # dp[i][j-1] -> 插入操作 # dp[i-1][j-1] -> 替换操作 dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) return dp[m][n] def spell_check(self, word: str, dictionary: List[str]) -> Dict[str, Any]: """ 拼写检查主函数。 """ # 统一转为小写处理，实现忽略大小写 target = word.lower() # 预处理词典，转为小写集合以提高查找效率 lower_dict = [w.lower() for w in dictionary] # 1. 检查单词是否已在词典中 if target in lower_dict: return {"correct": True, "suggestions": []} # 2. 若不在词典中，寻找编辑距离最小的单词 min_dist = float('inf') suggestions = [] for candidate in lower_dict: dist = self.levenshtein_distance(target, candidate) if dist apple (1), aple -> ample (1), aple -> apply (2) # 实际计算：aple vs apple=1, aple vs ample=1, aple vs apply=2. # 修正：aple vs apple (ins 'p'), aple vs ample (ins 'm'). }, { "name": "场景 3: 单词拼写错误（多个相似单词）", "word": "graffe", "dictionary": ["giraffe", "grape", "graph", "giraffe"], "expected": {"correct": False, "suggestions": ["giraffe"]} }, { "name": "场景 4: 完全不相关的单词", "word": "xyz", "dictionary": ["abc", "def", "ghi"], "expected": {"correct": False, "suggestions": ["abc", "def", "ghi"]} # 距离都会很大，但逻辑应返回距离最小的 } ]...
AI 评审点评
以下是 AI 评审对该模型输出的点评：
【GEMINI】这是一份高质量的算法实现。AI 不仅准确完成了核心的动态规划逻辑，还构建了结构清晰、易于测试的类。代码注释水平极高，能够帮助读者快速理解算法原理。尽管其编写的测试用例中有一个预期结果与逻辑描述略有出入，但核心代码逻辑严谨，完全符合任务描述的所有功能点。 【KIMI】整体而言，代码实现了题目要求的核心功能，拼写检查和纠错建议的逻辑正确。代码结构清晰，注释详细，可读性良好。但在异常输入处理和细节优化方面还有改进空间。
进阶难度评测结果
- 得分：100.0 分
- 通过状态：已通过
模型生成产物
以下是该模型针对此任务的实际生成内容：
你好！我是资深算法工程师。针对你的需求，我设计并实现了一个基于动态规划（Dynamic Programming）算法的拼写检查器。 ### 算法设计说明 1. **编辑距离 (Levenshtein Distance)**: 采用经典的二维动态规划方案。定义 $dp[i][j]$ 为 `word1` 前 $i$ 个字符与 `word2` 前 $j$ 个字符之间的最小编辑距离。 - 状态转移方程： - 若 $word1[i-1] == word2[j-1]$，则 $dp[i][j] = dp[i-1][j-1]$。 - 否则，$dp[i][j] = 1 + \min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])$（分别对应删除、插入、替换操作）。 - 时间复杂度为 $O(m \times n)$，其中 $m, n$ 分别为两个单词的长度。 2. **候选词排序逻辑**: 为了实现高效的排序，我使用了 Python 的元组排序特性。在 `suggest` 方法中，我们将候选词包装成 `(distance, -frequency, original_word)` 的元组。由于 Python 的排序是升序的，通过对词频取负数，可以巧妙地在一次排序中实现“距离升序、词频降序”的双重排序逻辑。 3. **大小写处理**: 为了保证“大小写不敏感”且“保留原始格式”，我在构造函数阶段建立了一个映射表 `_lookup_table`，将所有小写单词映射到其原始的（包含大小写）单词列表。这样在匹配时只需将输入转为小写，即可快速检索。 ### Python 实现 ```python from typing import Dict, List, Tuple, Optional class SpellChecker: """ 一个基于 Levenshtein Distance 算法的拼写检查器。 支持编辑距离计算、候选词检索及基于词频的智能建议。 """ def __init__(self, dictionary: Dict[str, int]): """ 初始化词典。 :param dictionary: 格式为 {单词: 词频} 的字典 """ if not isinstance(dictionary, dict): raise ValueError("Dictionary must be a dictionary.") self.original_dict = dictionary # 建立小写到原始单词及词频的映射，以实现大小写不敏感 # 考虑到同一个小写单词可能对应多个原始大小写形式，这里存储列表 self._lookup_table: Dict[str, List[Tuple[str, int]]] = {} for word, freq in dictionary.items(): lower_word = word.lower() if lower_word not in self._lookup_table: self._lookup_table[lower_word] = [] self._lookup_table[lower_word].append((word, freq)) def edit_distance(self, word1: str, word2: str) -> int: """ 使用动态规划计算两个单词之间的 Levenshtein Distance。 """ m, n = len(word1), len(word2) # 初始化 DP 矩阵 # dp[i][j] 表示 word1[:i] 和 word2[:j] 的编辑距离 dp = [[0] * (n + 1) for _ in range(m + 1)] for i in range(m + 1): dp[i][0] = i for j in range(n + 1): dp[0][j] = j for i in range(1, m + 1): for j in range(1, n + 1): if word1[i - 1] == word2[j - 1]: dp[i][j] = dp[i - 1][j - 1] else: dp[i][j] = 1 + min( dp[i - 1][j], # 删除 dp[i][j - 1], # 插入 dp[i - 1][j - 1] # 替换 ) return dp[m][n] def get_candidates(self, word: str, max_distance: int = 2) -> List[Tuple[str, int, int]]: """...
AI 评审点评
以下是 AI 评审对该模型输出的点评：
【GEMINI】这是一份非常优秀的算法实现。模型不仅准确完成了所有功能需求，还在工程实践上表现出色，如利用元组排序特性简化多级排序逻辑、通过预处理映射表优化性能等。代码结构清晰，注释到位，测试用例覆盖全面，完全符合资深算法工程师的角色设定。
困难难度评测结果
- 得分：95.5 分
- 通过状态：已通过
模型生成产物
以下是该模型针对此任务的实际生成内容：
这是一个高性能拼写检查系统的完整实现。 ### 1. 完整代码实现 ```python import math import re from collections import defaultdict, Counter from typing import List, Dict, Tuple, Set, Optional # ========================================== # 1. 键盘布局与加权编辑距离模块 # ========================================== class WeightedLevenshtein: """ 实现基于 QWERTY 键盘布局的加权编辑距离。 通过计算字符在键盘上的欧氏距离来动态分配替换代价。 """ # QWERTY 键盘坐标映射 KEYBOARD_LAYOUT = { 'q': (0, 0), 'w': (0, 1), 'e': (0, 2), 'r': (0, 3), 't': (0, 4), 'y': (0, 5), 'u': (0, 6), 'i': (0, 7), 'o': (0, 8), 'p': (0, 9), 'a': (1, 0), 's': (1, 1), 'd': (1, 2), 'f': (1, 3), 'g': (1, 4), 'h': (1, 5), 'j': (1, 6), 'k': (1, 7), 'l': (1, 8), 'z': (2, 0), 'x': (2, 1), 'c': (2, 2), 'v': (2, 3), 'b': (2, 4), 'n': (2, 5), 'm': (2, 6) } def __init__(self): self.insertion_cost = 1.0 self.deletion_cost = 1.0 def _get_substitution_cost(self, c1: str, c2: str) -> float: if c1 == c2: return 0.0 if c1 not in self.KEYBOARD_LAYOUT or c2 not in self.KEYBOARD_LAYOUT: return 1.0 # 非字母或不在布局中的字符按标准代价 pos1 = self.KEYBOARD_LAYOUT[c1] pos2 = self.KEYBOARD_LAYOUT[c2] # 计算欧氏距离并归一化 (假设最大距离约为 3.0) dist = math.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2) return min(1.0, 0.2 + (dist * 0.2)) # 邻近键代价在 0.2~0.8 之间 def compute(self, s1: str, s2: str) -> float: """ 使用动态规划计算加权编辑距离。 时间复杂度: O(M * N) """ m, n = len(s1), len(s2) dp = [[0.0] * (n + 1) for _ in range(m + 1)] for i in range(m + 1): dp[i][0] = i * self.deletion_cost for j in range(n + 1): dp[0][j] = j * self.insertion_cost for i in range(1, m + 1): for j in range(1, n + 1): if s1[i-1] == s2[j-1]: cost = 0.0 else: cost = self._get_substitution_cost(s1[i-1], s2[j-1]) dp[i][j] = min( dp[i-1][j] + self.deletion_cost, # Deletion dp[i][j-1] + self.insertion_cost, # Insertion dp[i-1][j-1] + cost # Substitution ) return dp[m][n] # ========================================== # 2. BK-Tree 高效词典模块 # ========================================== class BKTreeNode: def __init__(self, word: str): self.word = word self.children: Dict[int, BKTreeNode] = {}...
AI 评审点评
以下是 AI 评审对该模型输出的点评：
【GEMINI】这是一份极其优秀的算法实现方案。它不仅在技术上准确实现了 BK 树和加权编辑距离等复杂算法，还展现了深厚的工程设计能力。通过将物理键盘距离、上下文语义概率和统计词频结合，构建了一个多维度的评分体系，能够很好地解决拼写纠错中的手误和语义歧义问题。代码可读性强，文档完整，达到了资深算法工程师的产出水准。
相关链接
您可以通过以下链接查看更多相关内容：
