init-commit

internbootcamp/bootcamp/sudoku/sudoku.py

@@ -0,0 +1,374 @@
+"""# 谜题训练场开发任务
+
+## 任务概述
+你是一位资深程序员，我需要你帮我实现一个特定谜题的训练场环境类。这个类继承自`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)
+```
+
+## 你的任务
+请根据以下谜题描述（谜题描述可能不完整，请先结合你的知识澄清规则），实现一个完整的谜题训练场类：
+
+### 谜题描述
+
+Sudoku is a logic-based number placement puzzle played on a square grid divided into smaller subgrids (called \"regions\" or \"blocks\"). The rules are as follows:
+
+1. **Grid Structure**:  
+   - The puzzle grid is a square of size N×N, where N is a perfect square (e.g., 9×9, 16×16).  
+   - The grid is subdivided into N smaller rectangular regions, each of size √N×√N. For example, a 9×9 grid has nine 3×3 regions.
+
+2. **Number Placement**:  
+   - The grid is partially filled with numbers (or symbols) at the start.  
+   - The solver must fill every empty cell with a number from **1 to N** (or symbols equivalent in count to N).
+
+3. **Core Rules**:  
+   - **Row Constraint**: Each number must appear **exactly once** in every row.  
+   - **Column Constraint**: Each number must appear **exactly once** in every column.  
+   - **Region Constraint**: Each number must appear **exactly once** in every subgrid/region.  
+
+The puzzle is solved when all cells are filled while satisfying all three constraints. No arithmetic or guessing is required—only logical deduction.
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import math
+import random
+from typing import List, Optional
+
+class Sudokubootcamp(Basebootcamp):
+    def __init__(self, size: int = 9):
+        """
+        初始化数独训练场参数
+        
+        参数:
+            size: 数独尺寸（必须为完全平方数，默认9）
+        """
+        sqrt_n = math.isqrt(size)
+        if sqrt_n * sqrt_n != size:
+            raise ValueError("Size必须为完全平方数")
+        self.size = size
+        self.sqrt_n = sqrt_n
+    
+    def case_generator(self) -> dict:
+        """
+        生成数独谜题实例
+        
+        返回包含以下信息的字典:
+        - puzzle: 数独初始网格（0表示空格）
+        - size: 数独尺寸
+        - region_rows: 子区域行数
+        - region_cols: 子区域列数（同region_rows）
+        """
+        # 生成完整解
+        solution = self._generate_full_sudoku()
+        
+        # 挖空50%的格子（可根据需求调整比例）
+        puzzle = self._dig_holes(solution.copy(), dig_prob=0.5)
+        
+        return {
+            "puzzle": [row.copy() for row in puzzle],
+            "size": self.size,
+            "region_rows": self.sqrt_n,
+            "region_cols": self.sqrt_n
+        }
+
+    @staticmethod
+    def prompt_func(question_case: dict) -> str:
+        """
+        将数独实例转换为自然语言描述的问题
+        
+        参数:
+            question_case: case_generator生成的谜题实例
+            
+        返回:
+            包含规则说明和当前谜题状态的格式化字符串
+        """
+        puzzle = question_case["puzzle"]
+        size = question_case["size"]
+        region_size = question_case["region_rows"]
+        
+        prompt = f"""你是一个专业数独玩家，请解决以下{size}x{size}的数独谜题。规则要求：
+1. 每行必须包含1-{size}所有数字，无重复
+2. 每列必须包含1-{size}所有数字，无重复
+3. 每个{region_size}x{region_size}的子区域必须包含1-{size}所有数字，无重复
+
+当前谜题状态（0表示空格）：
+"""
+        for i, row in enumerate(puzzle):
+            prompt += f"第{i+1}行：" + " ".join(str(n) if n != 0 else "▢" for n in row) + "\n"
+
+        prompt += "\n请将完整解答按如下格式放在[answer]标记之间：\n[answer]\n1 2 3 ...\n4 5 6 ...\n...\n[/answer]"
+        return prompt
+
+    @staticmethod
+    def extract_output(output: str) -> Optional[List[List[int]]]:
+        """
+        从模型输出中提取最后一个数独解
+        
+        参数:
+            output: 包含[answer]标记的完整输出文本
+            
+        返回:
+            二维整数矩阵，解析失败时返回None
+        """
+        import re
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+            
+        try:
+            solution = []
+            for line in matches[-1].strip().split('\n'):
+                nums = list(map(int, line.strip().split()))
+                if nums:
+                    solution.append(nums)
+            return solution
+        except:
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution: List[List[int]], identity: dict) -> bool:
+        """
+        验证解的正确性
+        
+        参数:
+            solution: 用户提交的解
+            identity: 谜题实例信息
+            
+        返回:
+            布尔值表示解的正确性
+        """
+        def is_valid_region(grid, row_start, col_start, size, region_size) -> bool:
+            """验证子区域有效性"""
+            nums = set()
+            for i in range(row_start, row_start+region_size):
+                for j in range(col_start, col_start+region_size):
+                    num = grid[i][j]
+                    if num < 1 or num > size or num in nums:
+                        return False
+                    nums.add(num)
+            return True
+
+        puzzle = identity["puzzle"]
+        size = identity["size"]
+        region_size = identity["region_rows"]
+        
+        # 基本维度检查
+        if len(solution) != size or any(len(row) != size for row in solution):
+            return False
+        
+        # 验证初始条件
+        for i in range(size):
+            for j in range(size):
+                if puzzle[i][j] != 0 and solution[i][j] != puzzle[i][j]:
+                    return False
+        
+        # 验证行、列、子区域
+        valid_range = set(range(1, size+1))
+        for i in range(size):
+            if set(solution[i]) != valid_range:  # 行验证
+                return False
+            if set(solution[j][i] for j in range(size)) != valid_range:  # 列验证
+                return False
+            
+        # 子区域验证
+        for i in range(0, size, region_size):
+            for j in range(0, size, region_size):
+                if not is_valid_region(solution, i, j, size, region_size):
+                    return False
+        
+        return True
+
+    def _generate_full_sudoku(self) -> List[List[int]]:
+        """生成有效完整数独的核心算法"""
+        size = self.size
+        region_size = self.sqrt_n
+        grid = [[0]*size for _ in range(size)]
+        
+        # 填充对角线子区域
+        for i in range(0, size, region_size):
+            nums = list(range(1, size+1))
+            random.shuffle(nums)
+            for x in range(region_size):
+                for y in range(region_size):
+                    grid[i+x][i+y] = nums[x*region_size + y]
+        
+        # 解数独
+        self._solve_sudoku(grid)
+        return grid
+
+    def _solve_sudoku(self, grid: List[List[int]]) -> bool:
+        """回溯法解数独"""
+        size = self.size
+        region_size = self.sqrt_n
+        empty = self._find_empty(grid)
+        
+        if not empty:
+            return True
+            
+        row, col = empty
+        for num in random.sample(range(1, size+1), size):  # 随机尝试增加多样性
+            if self._is_safe(grid, row, col, num):
+                grid[row][col] = num
+                if self._solve_sudoku(grid):
+                    return True
+                grid[row][col] = 0
+        return False
+
+    def _find_empty(self, grid: List[List[int]]) -> Optional[tuple]:
+        """寻找下一个空单元格"""
+        for i in range(self.size):
+            for j in range(self.size):
+                if grid[i][j] == 0:
+                    return (i, j)
+        return None
+
+    def _is_safe(self, grid: List[List[int]], row: int, col: int, num: int) -> bool:
+        """检查数字是否可以安全填入"""
+        size = self.size
+        region_size = self.sqrt_n
+        
+        # 检查行和列
+        if num in grid[row] or num in [grid[i][col] for i in range(size)]:
+            return False
+            
+        # 检查子区域
+        start_row, start_col = row - row%region_size, col - col%region_size
+        for i in range(region_size):
+            for j in range(region_size):
+                if grid[start_row+i][start_col+j] == num:
+                    return False
+        return True
+
+    def _dig_holes(self, grid: List[List[int]], dig_prob: float) -> List[List[int]]:
+        """挖洞生成谜题（保证至少有一个解）"""
+        size = self.size
+        for i in range(size):
+            for j in range(size):
+                if random.random() < dig_prob:
+                    grid[i][j] = 0
+        return grid