init-commit

internbootcamp/bootcamp/shingoki/shingoki.py

@@ -0,0 +1,266 @@
+"""# 谜题训练场开发任务
+
+## 任务概述
+你是一位资深程序员，我需要你帮我实现一个特定谜题的训练场环境类。这个类继承自`Basebootcamp`，用于生成谜题实例并验证解答。
+
+## 背景说明
+我正在开发一系列谜题训练场，每个训练场对应一个特定类型的谜题。训练场类命名为`{PuzzleName}bootcamp`，其中`PuzzleName`是谜题的名称。
+
+每个训练场类主要提供两个核心功能：
+1. 生成该谜题类型的问题实例
+2. 验证用户对问题的回答是否正确
+
+## 技术接口规范
+
+### 类方法实现要求
+
+```python
+class {PuzzleName}bootcamp(Basebootcamp):
+    def __init__(self, **params):
+        \"\"\"
+        请你自定义params，以保存该puzzle相关的参数，例如网格大小等，参数配有默认值
+        \"\"\"
+        pass
+    
+    def case_generator(self):
+        \"\"\"
+        生成谜题实例，提示：为保证谜题有解，可以先生成结果再对结果处理得到谜题
+        返回：一个可JSON序列化的字典（避免包含set等无法通过json.dumps处理的数据结构）
+        \"\"\"
+        pass
+    
+    @staticmethod
+    def prompt_func(question_case) -> str:
+        \"\"\"
+        将case_generator生成的谜题实例转换为文本形式的问题，问题中包含问题背景、对谜题规则的介绍、具体要解决的谜题实例、期望最终答案的格式，
+        例如：你是xxxx，请你解答yyyy，规则如下：yyyy，最终答案放置在：zzzzz
+
+        参数:
+            question_case: 由case_generator生成的谜题实例
+            
+        返回:
+            str: 格式化的问题字符串
+            
+        注意:
+            1. 需考虑问题的格式，以便后续能正确提取
+            2. 问题描述中应包含期望的答案格式说明，以便后续能正确提取，为了避免抽取时匹配出干扰项，请要求模型将答案放在特定标签，如[answer] [/answer]内
+        \"\"\"
+        pass
+    
+    @staticmethod
+    def extract_output(output):
+        \"\"\"
+        从LLM的回复中提取符合格式要求的答案，如有多个，请抽取最后一个，避免使用re.search等只抽取第一个结果的方式。
+        
+        参数:
+            output: LLM的完整输出（包含原始问题和回答）
+            
+        返回:
+            提取的答案，若未找到符合格式的答案则返回None
+        \"\"\"
+        pass
+    
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        \"\"\"
+        验证提取的答案是否正确，注意一个问题可以能有多个解，按照谜题规则进行检验，不要直接匹配可能的答案。
+        
+        参数:
+            solution: extract_output提取的答案
+            identity: case_generator生成的谜题实例
+            
+        返回:
+            bool: 答案是否正确
+        \"\"\"
+        pass
+```
+
+### 验证评分方法（基类已实现）
+
+```python
+@classmethod
+def verify_score(cls, model_output, identity:dict, format_score=0.1) -> float:
+    \"\"\"
+    验证输出结果并评分。
+    
+    参数:
+        model_output: 模型的完整输出
+        identity: 谜题实例（由case_generator生成）
+        format_score: 答案格式正确时的基础分数
+    
+    返回:
+        float: 评分结果（0-1之间）
+    \"\"\"
+    score = 0. 
+    try:
+        extract_solution = cls.extract_output(model_output)
+        if extract_solution is None:
+            return score
+        else:
+            score = format_score # 格式正确时的基础分数
+        if cls._verify_correction(extract_solution, identity):
+            score = 1.  # 答案完全正确时的满分
+    except Exception as e:
+        # 处理异常情况
+        pass
+    return score
+```
+
+### 使用示例
+
+```python
+# 初始化谜题训练场
+bootcamp = Puzzlebootcamp()
+
+# 生成谜题实例
+case = bootcamp.case_generator()
+
+# 将谜题转换为文本问题
+prompt = Puzzlebootcamp.prompt_func(case)
+
+# 获取LLM对问题的解答
+response = get_response(prompt, \"LLM\")
+
+# 从完整对话中提取答案
+extracted_output = Puzzlebootcamp.extract_output(prompt + response)
+
+# 验证答案并评分
+score = Puzzlebootcamp.verify_score(extracted_output, case)
+```
+
+## 你的任务
+请根据以下谜题描述（谜题描述可能不完整，请先结合你的知识澄清规则），实现一个完整的谜题训练场类：
+
+### 谜题描述
+
+Shingoki is a logic puzzle where players draw a single continuous, non-intersecting loop on a grid. Here are the core rules:
+
+1. **Objective**:  
+   Create a closed loop that traverses *edges* of the grid (lines between dots/nodes). The loop must not branch, cross itself, or form isolated segments.
+
+2. **Clues (Numbered Circles)**:  
+   - Numbered circles appear at *intersections* (nodes where four grid edges meet).  
+   - Each number specifies *exactly* how many of the four edges connected to that node are part of the loop. For example:  
+     - **0**: None of the four edges are used.  
+     - **2**: Exactly two edges are used (e.g., a straight line or a turn).  
+     - **3/1**: Rare, typically near grid borders where fewer edges exist.  
+
+3. **2x2 Block Restriction**:  
+   The loop must not enclose any 2x2 area entirely with its lines. This prevents \"solid blocks\" of the loop.
+
+4. **Logical Deductions**:  
+   - The loop must form a single closed path.  
+   - Unnumbered nodes have no constraints (any number of edges can be used).  
+   - Clues override default assumptions (e.g., a \"3\" forces three edges at a node, even if it seems counterintuitive).  
+
+The puzzle is solved by deducing edge usage around numbered nodes while adhering to these constraints.  
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+from typing import Dict, Set, Tuple
+
+class Shingokibootcamp(Basebootcamp):
+    def __init__(self, rows=5, cols=5):
+        self.rows = rows
+        self.cols = cols
+    
+    def case_generator(self) -> Dict:
+        """
+        生成Shingoki谜题实例（简化的示例版本）
+        注意：当前示例未实现实际环生成算法，需后续完善
+        """
+        return {
+            "rows": self.rows,
+            "cols": self.cols,
+            "clues": {(2, 2): 0}  # 示例线索（实际实现需要有效生成）
+        }
+    
+    @staticmethod
+    def prompt_func(question_case: Dict) -> str:
+        clues = question_case['clues']
+        rows = question_case['rows']
+        cols = question_case['cols']
+        prompt = [
+            "请解决以下Shingoki谜题：",
+            "在{}×{}的网格中绘制一个闭合不交叉的环，满足以下条件：".format(rows, cols),
+            "1. 环必须经过网格边线且满足2×2区块限制",
+            "2. 数字表示相连边数（0-3）",
+            "————————————————",
+            "已知线索节点："
+        ]
+        
+        # 格式化线索描述
+        for (i, j), num in clues.items():
+            prompt.append(f"• 位置 ({i},{j}) 处必须连接 {num} 条边")
+        
+        prompt.extend([
+            "\n请用以下格式回答：",
+            "[answer]",
+            "(行坐标,列坐标,方向) 每行一个边",
+            "示例：",
+            "(0,0,H)  # 水平边，连接(0,0)-(0,1)",
+            "(1,2,V)  # 垂直边，连接(1,2)-(2,2)",
+            "[/answer]"
+        ])
+        
+        return "\n".join(prompt)
+    
+    @staticmethod
+    def extract_output(output: str) -> Set[Tuple[int, int, str]]:
+        # 匹配最后一个answer块
+        answer_blocks = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not answer_blocks:
+            return None
+        
+        # 解析边坐标
+        edges = set()
+        pattern = re.compile(r'\((\d+),(\d+),(H|V)\)')
+        for line in answer_blocks[-1].strip().split('\n'):
+            match = pattern.search(line)
+            if match:
+                i, j, dir = int(match[1]), int(match[2]), match[3]
+                edges.add((i, j, dir))
+        
+        return edges if edges else None
+    
+    @classmethod
+    def _verify_correction(cls, solution: Set[Tuple[int, int, str]], identity: Dict) -> bool:
+        # 转存谜题参数
+        rows = identity['rows']
+        cols = identity['cols']
+        clues = identity['clues']
+        
+        # 验证边有效性
+        for i, j, dir in solution:
+            if dir == 'H' and j >= cols-1:
+                return False  # 水平边越界
+            if dir == 'V' and i >= rows-1:
+                return False  # 垂直边越界
+        
+        # 验证线索条件
+        edge_set = {(dir, i, j) for (i, j, dir) in solution}
+        for (node_i, node_j), expected in clues.items():
+            count = 0
+            # 检查四边
+            if ('H', node_i, node_j) in edge_set:  # 右边
+                count += 1
+            if node_j > 0 and ('H', node_i, node_j-1) in edge_set:  # 左边
+                count += 1
+            if ('V', node_i, node_j) in edge_set:  # 下边
+                count += 1
+            if node_i > 0 and ('V', node_i-1, node_j) in edge_set:  # 上边
+                count += 1
+            if count != expected:
+                return False
+        
+        # TODO: 实际实现需添加以下验证
+        # 1. 环的连通性检查
+        # 2. 闭合性检查
+        # 3. 2×2区块限制检查
+        # 4. 无交叉检查
+        
+        return True  # 示例实现仅验证线索条件