init-commit

internbootcamp/bootcamp/bridges/bridges.py

@@ -0,0 +1,339 @@
+"""# 谜题训练场开发任务
+
+## 任务概述
+你是一位资深程序员，我需要你帮我实现一个特定谜题的训练场环境类。这个类继承自`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)
+```
+
+## 你的任务
+请根据以下谜题描述（谜题描述可能不完整，请先结合你的知识澄清规则），实现一个完整的谜题训练场类：
+
+### 谜题描述
+
+The objective of the Bridges puzzle (Hashiwokakero) is to connect all numbered \"islands\" on a grid using horizontal/vertical bridges, adhering to these principles:
+
+1. **Island Numbers**: Each island (node) displays a number (1-8) indicating how many bridges must connect to it.  
+   - Example: A \"3\" island must have exactly 3 bridges linked to it.
+
+2. **Bridge Placement**:  
+   - Bridges connect **two adjacent islands** horizontally/vertically.  
+   - Bridges cannot cross islands, other bridges, or \"turn\" mid-connection.  
+
+3. **Bridge Limits**:  
+   - A maximum of **2 bridges** can connect any pair of islands.  
+   - Bridges may overlap in straight lines if they connect different island pairs (no crossing).  
+
+4. **Connectivity**:  
+   - All islands must be interconnected into a **single continuous network** via bridges.  
+
+Key Constraints:  
+- Bridges cannot be placed diagonally.  
+- Islands cannot have fewer/more bridges than their number.  
+- Overlapping bridges (parallel lines) must align in the same direction without intersecting.  
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import random
+from collections import defaultdict
+
+class Bridgesbootcamp(Basebootcamp):
+    def __init__(self, width=5, height=5):
+        self.width = width
+        self.height = height
+
+    def case_generator(self):
+        direction = random.choice(['horizontal', 'vertical'])
+        islands = []
+        bridges = []
+
+        if direction == 'horizontal':
+            x = random.randint(0, self.width-1)
+            y1 = random.randint(0, self.height-3)
+            y2 = y1 + 2
+            islands = [
+                {'x': x, 'y': y1, 'num': 2},
+                {'x': x, 'y': y2, 'num': 2},
+            ]
+            bridges = [{'from': (x, y1), 'to': (x, y2), 'count': 2}]
+        else:
+            y = random.randint(0, self.height-1)
+            x1 = random.randint(0, self.width-3)
+            x2 = x1 + 2
+            islands = [
+                {'x': x1, 'y': y, 'num': 2},
+                {'x': x2, 'y': y, 'num': 2},
+            ]
+            bridges = [{'from': (x1, y), 'to': (x2, y), 'count': 2}]
+
+        return {
+            'islands': islands,
+            'bridges': bridges
+        }
+
+    @staticmethod
+    def prompt_func(question_case) -> str:
+        islands = question_case['islands']
+        islands_desc = []
+        for island in islands:
+            islands_desc.append(f"坐标({island['x']}, {island['y']})的岛屿数字为{island['num']}。")
+        islands_text = '\n'.join(islands_desc)
+        prompt = f"""你是Hashiwokakero谜题的解题专家，请根据以下规则连接所有岛屿：
+
+规则：
+1. 每个岛屿上的数字表示必须连接的桥梁数目。
+2. 桥梁必须水平或竖直连接相邻的岛屿，中间不能有其他岛屿或桥梁阻挡。
+3. 每对岛屿之间最多可以建造两座桥梁。
+4. 所有岛屿必须通过桥梁连通成一个单一网络。
+5. 桥梁不能交叉或转弯。
+
+当前的岛屿分布如下：
+{islands_text}
+
+请建造桥梁以满足所有条件，并将答案按照以下格式放置于[answer]和[/answer]之间。每个桥梁的格式为：(x1,y1)-(x2,y2):数量，多个桥梁用换行分隔。
+
+示例：
+[answer]
+(0,0)-(0,2):2
+(1,3)-(3,3):1
+[/answer]"""
+        return prompt
+
+    @staticmethod
+    def extract_output(output):
+        pattern = re.compile(r'\[answer\](.*?)\[/answer\]', re.DOTALL)
+        matches = pattern.findall(output)
+        if not matches:
+            return None
+        return matches[-1].strip()
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        try:
+            bridges = []
+            pattern = re.compile(r'\((\d+)\s*,\s*(\d+)\)\s*-\s*\((\d+)\s*,\s*(\d+)\)\s*:\s*(\d+)')
+            matches = pattern.findall(solution)
+            for m in matches:
+                x1, y1, x2, y2, cnt = map(int, m)
+                if cnt not in (1, 2):
+                    return False
+                if (x1, y1) > (x2, y2):
+                    x1, x2, y1, y2 = x2, x1, y2, y1
+                bridges.append({'from': (x1, y1), 'to': (x2, y2), 'count': cnt})
+
+            island_coords = {(i['x'], i['y']) for i in identity['islands']}
+            for bridge in bridges:
+                if bridge['from'] not in island_coords or bridge['to'] not in island_coords:
+                    return False
+                x1, y1 = bridge['from']
+                x2, y2 = bridge['to']
+                if not (x1 == x2 or y1 == y2):
+                    return False
+
+                if x1 == x2:
+                    y_min, y_max = sorted([y1, y2])
+                    for y in range(y_min+1, y_max):
+                        if (x1, y) in island_coords:
+                            return False
+                else:
+                    x_min, x_max = sorted([x1, x2])
+                    for x in range(x_min+1, x_max):
+                        if (x, y1) in island_coords:
+                            return False
+
+            bridge_counts = defaultdict(int)
+            for bridge in bridges:
+                pair = (bridge['from'], bridge['to'])
+                bridge_counts[pair] += bridge['count']
+            if any(v > 2 for v in bridge_counts.values()):
+                return False
+
+            island_num = {(i['x'], i['y']): i['num'] for i in identity['islands']}
+            usage = defaultdict(int)
+            for bridge in bridges:
+                usage[bridge['from']] += bridge['count']
+                usage[bridge['to']] += bridge['count']
+            for coord, num in island_num.items():
+                if usage.get(coord, 0) != num:
+                    return False
+
+            bridges_path = []
+            for bridge in bridges:
+                x1, y1 = bridge['from']
+                x2, y2 = bridge['to']
+                if x1 == x2:
+                    y_start, y_end = sorted([y1, y2])
+                    bridges_path.append(('vertical', x1, y_start, y_end))
+                else:
+                    x_start, x_end = sorted([x1, x2])
+                    bridges_path.append(('horizontal', y1, x_start, x_end))
+
+            for i in range(len(bridges_path)):
+                ti, ai, si, ei = bridges_path[i]
+                for j in range(i+1, len(bridges_path)):
+                    tj, aj, sj, ej = bridges_path[j]
+                    if ti == tj:
+                        continue
+                    if ti == 'horizontal':
+                        y_h = ai
+                        xh_s, xh_e = si, ej
+                        x_v = aj
+                        yv_s, yv_e = sj, ej
+                    else:
+                        x_v = ai
+                        yv_s, yv_e = si, ei
+                        y_h = aj
+                        xh_s, xh_e = sj, ej
+                    if (xh_s <= x_v <= xh_e) and (yv_s <= y_h <= yv_e):
+                        return False
+
+            coord_to_id = {(i['x'], i['y']): idx for idx, i in enumerate(identity['islands'])}
+            parent = list(range(len(coord_to_id)))
+
+            def find(u):
+                while parent[u] != u:
+                    parent[u] = parent[parent[u]]
+                    u = parent[u]
+                return u
+
+            def union(u, v):
+                pu, pv = find(u), find(v)
+                if pu != pv:
+                    parent[pu] = pv
+
+            for bridge in bridges:
+                u = coord_to_id[bridge['from']]
+                v = coord_to_id[bridge['to']]
+                union(u, v)
+
+            roots = {find(i) for i in range(len(parent))}
+            return len(roots) == 1
+
+        except Exception as e:
+            return False