Claude Opus 4 7 在「实现正则表达式」的评测结果

这是该 AI 模型在此测试用例上的详细评测结果。

基本信息

  • 模型名称：Claude Opus 4 7
  • 用例名称：实现正则表达式
  • 测试类型：文本生成
  • 评测维度：代码生成

系统提示词（System Prompt）

这是给 AI 模型的背景设定和角色指令：

你是一名资深 Python 开发工程师，擅长字符串处理与算法设计。 回答要求： 1. 先简要分析匹配逻辑（字符对齐、'?' 的语义），再给出实现代码。 2. 代码风格符合 PEP 8，函数需包含清晰的 docstring 说明参数与返回值。 3. 对关键逻辑（如长度校验、'?' 匹配分支）添加行内注释，便于阅读。 4. 给出至少 3 个测试用例验证代码正确性，覆盖正常情况与边界情况。

用户提示词（User Prompt）

这是用户给 AI 模型的具体任务要求：

请用 Python 实现一个简单的字符串模式匹配函数，函数签名如下：

任务要求

AI 模型需要满足以下要求：

  1. 正确实现 '?' 匹配恰好一个任意字符、'*' 匹配零个或多个任意字符的语义，通过所有示例用例
  2. 正确处理边界情况：空字符串 s 或 p、模式全为 '*'、连续多个 '*'、'*' 与 '?' 混合
  3. 采用动态规划或贪心双指针等高效算法，时间复杂度不超过 O(m×n)，并在代码注释或说明中给出复杂度分析
  4. 代码结构清晰，符合 PEP 8 规范，关键逻辑（如 DP 转移方程或指针回溯逻辑）有必要注释
  5. 能正确处理连续多个 '*' 的情况（等价于单个 '*'），不因此产生错误或性能退化

评测结果

综合得分

该模型在此用例的得分为：94.5 分（满分 100 分），已通过

基础难度评测结果

  • 得分：94.5 分
  • 通过状态：已通过

模型生成产物

以下是该模型针对此任务的实际生成内容：

## 匹配逻辑分析 这是一个简化版的通配符匹配问题： - 需要逐字符对齐比较 `pattern` 和 `text` - `'?'` 可以匹配任意单个字符（包括特殊字符、数字、字母等） - 普通字符必须严格相等 - 长度必须一致才可能匹配成功 ## 实现代码 ```python def simple_match(pattern: str, text: str) -> bool: """ 简单字符串模式匹配函数。 匹配规则： - '?' 可以匹配任意单个字符 - 其他字符必须严格相等 - pattern 和 text 长度必须相同 Args: pattern: 模式字符串，可包含 '?' 通配符 text: 待匹配的文本字符串 Returns: bool: 匹配成功返回 True，否则返回 False Examples: >>> simple_match("a?c", "abc") True >>> simple_match("a?c", "adc") True >>> simple_match("a?c", "ab") False """ # 长度不同直接返回 False if len(pattern) != len(text): return False # 逐字符比较 for p_char, t_char in zip(pattern, text): # '?' 匹配任意字符，跳过 if p_char == '?': continue # 普通字符必须严格相等 if p_char != t_char: return False return True ``` ## 测试用例 ```python # 测试用例 1: 正常匹配 assert simple_match("a?c", "abc") == True assert simple_match("a?c", "adc") == True assert simple_match("???", "xyz") == True # 测试用例 2: 匹配失败 assert simple_match("a?c", "aec") == True # 注意：'?' 匹配 'e' assert simple_match("abc", "abd") == False assert simple_match("a?c", "ab") == False # 长度不同 # 测试用例 3: 边界情况 assert simple_match("", "") == True # 空字符串 assert simple_match("?", "a") == True # 单字符 assert simple_match("??", "ab") == True assert simple_match("a", "") == False # 长度不匹配 assert simple_match("?", "") == False # 测试用例 4: 特殊字符 assert simple_match("a?c", "a1c") == True # 数字 assert simple_match("a?c", "a@c") == True # 特殊符号 assert simple_match("a?c", "a c") == True # 空格 print("所有测试通过！") ``` 代码时间复杂度为 O(n)，空间复杂度为 O(1)，其中 n 为字符串长度。

AI 评审点评

以下是 AI 评审对该模型输出的点评：

【CLAUDE】这是一个高质量的实现方案。代码逻辑正确无误，完整实现了字符串模式匹配功能，测试覆盖全面。代码风格规范，注释清晰，文档完善，完全满足任务要求。算法效率最优（O(n) 时间复杂度），是一个可直接用于生产环境的实现。 【GEMINI】这是一份高质量的回答。模型不仅准确实现了核心算法逻辑，还提供了清晰的逻辑分析。代码编写规范，文档说明完整，测试用例丰富且覆盖了多种边界场景。尽管在测试用例的分类注释上有一处极小的笔误，但不影响整体代码的正确性与专业性。 【KIMI】整体上，代码实现了字符串模式匹配的基本功能，测试用例覆盖了主要场景。但在测试用例中存在一个错误，需要修正。代码风格良好，符合PEP 8规范。

进阶难度评测结果

  • 得分：92.8 分
  • 通过状态：已通过

模型生成产物

以下是该模型针对此任务的实际生成内容：

## 匹配逻辑分析 **优先级与关键点：** - `?` 必须消耗恰好一个字符 - `*` 可以匹配 0 到任意多个字符，是灵活匹配的核心 - 连续多个 `*` 等价于单个 `*` - 需要处理回溯：当 `*` 后续匹配失败时，需要让 `*` 多消耗字符重新尝试 **算法选择：** 采用**动态规划**实现，清晰处理所有边界情况和回溯逻辑。 ## 实现代码 ```python def is_match(s: str, p: str) -> bool: """ 通配符匹配函数，支持 '?' 和 '*' 时间复杂度：O(m * n)，其中 m = len(s), n = len(p) 空间复杂度：O(m * n)，可优化至 O(n) 使用滚动数组 Args: s: 待匹配的字符串 p: 包含通配符的模式串 Returns: bool: 是否完全匹配 """ m, n = len(s), len(p) # dp[i][j] 表示 s[0:i] 与 p[0:j] 是否匹配 dp = [[False] * (n + 1) for _ in range(m + 1)] # 边界：空串与空模式匹配 dp[0][0] = True # 边界：空串与连续 '*' 开头的模式可以匹配 for j in range(1, n + 1): if p[j - 1] == '*': dp[0][j] = dp[0][j - 1] # 填充 DP 表 for i in range(1, m + 1): for j in range(1, n + 1): if p[j - 1] == '*': # '*' 可以匹配 0 个字符（dp[i][j-1]） # 或匹配至少 1 个字符（dp[i-1][j]，继续用当前 '*' 匹配） dp[i][j] = dp[i][j - 1] or dp[i - 1][j] elif p[j - 1] == '?' or p[j - 1] == s[i - 1]: # '?' 匹配任意单字符，或字面字符精确匹配 dp[i][j] = dp[i - 1][j - 1] # else: 字符不匹配，dp[i][j] 保持 False return dp[m][n] ``` ## 复杂度说明 **时间复杂度：O(m × n)** - 需要填充 (m+1) × (n+1) 的 DP 表，每个状态 O(1) 计算 **空间复杂度：O(m × n)** - 可优化至 O(n)：因为 `dp[i][j]` 只依赖 `dp[i-1][...]` 和 `dp[i][j-1]`，可用两行滚动数组 ## 测试验证 ```python # 基础测试 assert is_match("aa", "a") == False assert is_match("aa", "*") == True assert is_match("cb", "?a") == False assert is_match("adceb", "*a*b") == True assert is_match("acdcb", "a*c?b") == False # 边界测试 assert is_match("", "") == True assert is_match("", "*") == True assert is_match("", "?") == False assert is_match("abc", "***") == True assert is_match("abc", "*?*") == True # 连续 '*' 测试 assert is_match("abcdef", "a*b*c*d*e*f") == True assert is_match("", "******") == True print("所有测试通过 ✓") ``` 核心思路：`*` 匹配时有两种选择（匹配 0 个或继续匹配更多），DP 自动处理所有可能的分支，避免显式回溯。

AI 评审点评

以下是 AI 评审对该模型输出的点评：

【CLAUDE】候选输出提供了高质量的动态规划实现，逻辑正确、算法高效、代码规范。DP 状态转移方程准确，边界处理完善，复杂度分析清晰，注释详尽。能够正确处理所有示例用例和边界情况，包括连续多个「*」的场景。相比参考答案缺少贪心双指针的对比实现和完整可运行的测试套件，但单一 DP 实现已充分满足题目核心要求，整体表现优秀。 【GEMINI】该候选人给出的实现方案非常优秀。不仅逻辑严谨地解决了通配符匹配的核心难点（尤其是 '*' 的处理），而且在代码规范、复杂度分析以及边界情况的考量上都表现得非常专业。预分析、实现代码和测试用例的组织条理清晰，完全符合资深算法工程师的角色设定。 【KIMI】候选人的实现整体上是优秀的，逻辑正确，算法效率合理，代码质量高。正确处理了所有示例用例和边界情况，动态规划算法的选择也是合适的。代码结构清晰，注释得当。一些小的改进空间包括增加算法选择的解释和更详细的代码注释。

困难难度评测结果

  • 得分：87.7 分
  • 通过状态：已通过

模型生成产物

以下是该模型针对此任务的实际生成内容：

# 正则表达式匹配引擎实现 ## 算法分析 ### 匹配逻辑与优先级 1. **状态转移规则**： - 当前字符匹配：`s[i] == p[j]` 或 `p[j] == '.'` - `*` 的语义：匹配前一个元素 0 次或多次，需要向前看一位判断 - 优先级：`*` > `.` > 普通字符 2. **算法选型：动态规划** - **理由**： - 存在大量重叠子问题（相同的 `(i, j)` 状态会被重复计算） - 具有最优子结构（`dp[i][j]` 可由前序状态推导） - 避免递归回溯的指数级时间复杂度 - **备选方案**：递归回溯简洁但在最坏情况下时间复杂度为 O(2^(m+n)) ### 复杂度分析 - **时间复杂度**：O(m × n)，其中 m = len(s)，n = len(p) - **空间复杂度**：O(m × n)，DP 表存储 --- ## Part 1：基础实现 ```python def is_match(s: str, p: str) -> bool: """ 正则表达式匹配（支持 . 和 *） DP 状态定义： dp[i][j] 表示 s[:i] 与 p[:j] 是否匹配 状态转移： 1. p[j-1] 是普通字符或 '.'： dp[i][j] = dp[i-1][j-1] if s[i-1] == p[j-1] or p[j-1] == '.' 2. p[j-1] 是 '*'： - 匹配 0 次：dp[i][j] = dp[i][j-2] - 匹配 1+ 次：dp[i][j] = dp[i-1][j] if s[i-1] 匹配 p[j-2] """ m, n = len(s), len(p) # 初始化 DP 表 dp = [[False] * (n + 1) for _ in range(m + 1)] dp[0][0] = True # 空串匹配空模式 # 处理模式串以 x* 开头的情况（可匹配空串） for j in range(2, n + 1): if p[j - 1] == '*': dp[0][j] = dp[0][j - 2] # 填充 DP 表 for i in range(1, m + 1): for j in range(1, n + 1): if p[j - 1] == '*': # 情况 1：* 匹配 0 次前一个元素 dp[i][j] = dp[i][j - 2] # 情况 2：* 匹配 1+ 次（前提是当前字符匹配） if p[j - 2] == '.' or p[j - 2] == s[i - 1]: dp[i][j] = dp[i][j] or dp[i - 1][j] else: # 普通字符或 '.' 的匹配 if p[j - 1] == '.' or p[j - 1] == s[i - 1]: dp[i][j] = dp[i - 1][j - 1] return dp[m][n] # 测试用例 test_cases = [ ("aa", "a", False), ("aa", "a*", True), ("ab", ".*", True), ("aab", "c*a*b", True), ("mississippi", "mis*is*p*.", False), ("", ".*", True), ("a", "ab*", True), ] print("=== Part 1: 基础匹配测试 ===") for s, p, expected in test_cases: result = is_match(s, p) status = "✓" if result == expected else "✗" print(f"{status} is_match('{s}', '{p}') = {result} (期望: {expected})") ``` --- ## Part 2：进阶 - SimpleRegex 类 ### 设计说明 采用**两阶段架构**： 1. **模式解析阶段**：将正则字符串编译为内部表示（Token 列表） 2. **匹配执行阶段**：基于编译后的模式执行匹配 ```python import re from typing import List, Tuple class SimpleRegex: """ 简单正则表达式引擎 支持语法： - 普通字符：精确匹配 - '.'：匹配任意单字符 - '*'：匹配前一个元素 0 次或多次 - '[]'：字符集（如 [abc]、[a-z]、[^0-9]） """ def __init__(self, pattern: str): self.pattern = pattern...

AI 评审点评

以下是 AI 评审对该模型输出的点评：

【CLAUDE】该实现展示了扎实的算法功底和良好的工程素养。Part 1 的基础匹配逻辑正确且高效，Part 2 的类设计体现了编译原理中「词法分析-执行」的分层思想。复杂度分析准确，测试覆盖全面。主要改进空间在于：Part 2 初始化逻辑的边界处理需加强，字符集解析可增加更多异常校验，部分性能优化点（如预处理字符集展开结果）可落地实现。整体达到了高级工程师水平，代码可直接用于生产环境的轻量级正则引擎原型。 【GEMINI】该模型展现了资深工程师的思维，能够准确选择动态规划算法并给出详细的复杂度分析。Part 1 实现完美；Part 2 的架构设计非常优秀，但在处理 Token 化后的 DP 状态转移细节时出现了一处逻辑偏差（关于可选 Token 的跳过逻辑）。整体代码可读性极高，异常处理和测试验证部分非常专业。 【KIMI】整体而言，代码实现了题目要求的功能，逻辑正确，算法选择合理，代码质量良好。在正则匹配逻辑和算法效率方面表现优秀，代码质量方面虽有小瑕疵，但总体上是一份高质量的代码。

相关链接

您可以通过以下链接查看更多相关内容：

加载中...
100%