mirror of
https://github.com/InternLM/InternBootcamp.git
synced 2026-04-22 16:49:04 +00:00
339 lines
12 KiB
Python
Executable file
339 lines
12 KiB
Python
Executable file
"""# 谜题训练场开发任务
|
||
|
||
## 任务概述
|
||
你是一位资深程序员，我需要你帮我实现一个特定谜题的训练场环境类。这个类继承自`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
|