mirror of
https://github.com/InternLM/InternBootcamp.git
synced 2026-04-22 16:49:04 +00:00
289 lines
8.4 KiB
Python
Executable file
289 lines
8.4 KiB
Python
Executable file
"""#
|
|
|
|
### 谜题描述
|
|
Ringo found a string s of length n in his [yellow submarine](https://www.youtube.com/watch?v=m2uTFF_3MaA). The string contains only lowercase letters from the English alphabet. As Ringo and his friends love palindromes, he would like to turn the string s into a palindrome by applying two types of operations to the string.
|
|
|
|
The first operation allows him to choose i (2 ≤ i ≤ n-1) and to append the substring s_2s_3 … s_i (i - 1 characters) reversed to the front of s.
|
|
|
|
The second operation allows him to choose i (2 ≤ i ≤ n-1) and to append the substring s_i s_{i + 1}… s_{n - 1} (n - i characters) reversed to the end of s.
|
|
|
|
Note that characters in the string in this problem are indexed from 1.
|
|
|
|
For example suppose s=abcdef. If he performs the first operation with i=3 then he appends cb to the front of s and the result will be cbabcdef. Performing the second operation on the resulted string with i=5 will yield cbabcdefedc.
|
|
|
|
Your task is to help Ringo make the entire string a palindrome by applying any of the two operations (in total) at most 30 times. The length of the resulting palindrome must not exceed 10^6
|
|
|
|
It is guaranteed that under these constraints there always is a solution. Also note you do not have to minimize neither the number of operations applied, nor the length of the resulting string, but they have to fit into the constraints.
|
|
|
|
Input
|
|
|
|
The only line contains the string S (3 ≤ |s| ≤ 10^5) of lowercase letters from the English alphabet.
|
|
|
|
Output
|
|
|
|
The first line should contain k (0≤ k ≤ 30) — the number of operations performed.
|
|
|
|
Each of the following k lines should describe an operation in form L i or R i. L represents the first operation, R represents the second operation, i represents the index chosen.
|
|
|
|
The length of the resulting palindrome must not exceed 10^6.
|
|
|
|
Examples
|
|
|
|
Input
|
|
|
|
|
|
abac
|
|
|
|
|
|
Output
|
|
|
|
|
|
2
|
|
R 2
|
|
R 5
|
|
|
|
|
|
Input
|
|
|
|
|
|
acccc
|
|
|
|
|
|
Output
|
|
|
|
|
|
2
|
|
L 4
|
|
L 2
|
|
|
|
|
|
Input
|
|
|
|
|
|
hannah
|
|
|
|
|
|
Output
|
|
|
|
|
|
0
|
|
|
|
Note
|
|
|
|
For the first example the following operations are performed:
|
|
|
|
abac → abacab → abacaba
|
|
|
|
The second sample performs the following operations: acccc → cccacccc → ccccacccc
|
|
|
|
The third example is already a palindrome so no operations are required.
|
|
|
|
Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
|
|
```python
|
|
def check(c):
|
|
for i in xrange(len(c)):
|
|
if c[len(c) - i - 1] != c[i]:
|
|
print i
|
|
return False
|
|
return True
|
|
def process(st):
|
|
print 5
|
|
st = st + st[1:-1][::-1]
|
|
print st
|
|
a, b, H, b = st[0], st[-1], st[2:-1], st[-1]
|
|
print a, b, H, b
|
|
print b+a+b+H+b
|
|
print b+a+b+H+b+H+b+a
|
|
print b+a+b+H+b+H+b+a+b
|
|
c = b+a+b+H+b+H+b+a+b
|
|
print check(c)
|
|
|
|
def ans(st):
|
|
print 4
|
|
st = st + st[1:-1][::-1]
|
|
a, b, H, b = st[0], st[-1], st[2:-1], st[-1]
|
|
#print a, b, H, b
|
|
print 'R', 2
|
|
#print b+a+b+H+b
|
|
print 'L', 2
|
|
#print b+a+b+H+b+H+b+a
|
|
print 'R', 2
|
|
#print b+a+b+H+b+H+b+a+b
|
|
print 'R', len(b+a+b+H+b+H+b+a) - 1
|
|
#c = b+a+b+H+b+H+b+a+b
|
|
#print c
|
|
#print check(c)
|
|
def main():
|
|
t = input()
|
|
for _ in xrange(t):
|
|
n = input()
|
|
process(n)
|
|
|
|
if __name__ == '__main__':
|
|
#main()
|
|
s = raw_input()
|
|
#process(s)
|
|
ans(s)
|
|
```
|
|
|
|
|
|
请完成上述谜题的训练场环境类实现，包括所有必要的方法。
|
|
"""
|
|
|
|
from bootcamp import Basebootcamp
|
|
import random
|
|
import string
|
|
from bootcamp import Basebootcamp
|
|
|
|
class Cpalindromifierbootcamp(Basebootcamp):
|
|
def __init__(self, min_length=3, max_length=100, palindrome_prob=0.2):
|
|
"""
|
|
参数说明:
|
|
min_length: 生成字符串最小长度 (≥3)
|
|
max_length: 生成字符串最大长度 (≤1e5)
|
|
palindrome_prob: 直接生成回文字符串的概率
|
|
"""
|
|
self.min_length = max(3, min_length)
|
|
self.max_length = min(100000, max_length) # 遵守题目上限
|
|
self.palindrome_prob = palindrome_prob
|
|
|
|
def case_generator(self):
|
|
"""生成满足题目长度限制的字符串"""
|
|
length = random.randint(self.min_length, self.max_length)
|
|
|
|
if random.random() < self.palindrome_prob:
|
|
s = self._generate_palindrome(length)
|
|
else:
|
|
s = ''.join(random.choices(string.ascii_lowercase, k=length))
|
|
# 确保生成的字符串不是回文
|
|
while s == s[::-1]:
|
|
s = ''.join(random.choices(string.ascii_lowercase, k=length))
|
|
|
|
return {'s': s}
|
|
|
|
@staticmethod
|
|
def prompt_func(question_case) -> str:
|
|
s = question_case['s']
|
|
return f"""Ringo found a string s consisting of lowercase letters. He wants to turn it into a palindrome using at most 30 operations. The allowed operations are:
|
|
|
|
1. L i: Prepend the reversed substring from the 2nd to i-th character (2 ≤ i ≤ current length -1)
|
|
2. R i: Append the reversed substring from the i-th to second-last character (2 ≤ i ≤ current length -1)
|
|
|
|
The final string must be a palindrome with length ≤ 1,000,000.
|
|
|
|
Current string: {s}
|
|
|
|
Provide your solution in the format:
|
|
|
|
k
|
|
op1 i1
|
|
op2 i2
|
|
...
|
|
|
|
Enclose your answer within [answer] and [/answer] tags. For example:
|
|
|
|
[answer]
|
|
2
|
|
R 2
|
|
R 5
|
|
[/answer]"""
|
|
|
|
@staticmethod
|
|
def extract_output(output):
|
|
# 支持嵌套标签的情况，查找最后一个匹配的标签对
|
|
start_tag = '[answer]'
|
|
end_tag = '[/answer]'
|
|
|
|
last_start = output.rfind(start_tag)
|
|
if last_start == -1:
|
|
return None
|
|
|
|
last_end = output.find(end_tag, last_start)
|
|
if last_end == -1:
|
|
return None
|
|
|
|
return output[last_start+len(start_tag):last_end].strip()
|
|
|
|
@classmethod
|
|
def _verify_correction(cls, solution, identity):
|
|
try:
|
|
lines = solution.strip().split('\n')
|
|
if not lines:
|
|
return False
|
|
|
|
# 解析操作数量
|
|
try:
|
|
k = int(lines[0].strip())
|
|
except ValueError:
|
|
return False
|
|
|
|
# 验证操作数量范围
|
|
if k < 0 or k > 30:
|
|
return False
|
|
|
|
# 验证操作行数匹配
|
|
if len(lines[1:]) != k:
|
|
return False
|
|
|
|
operations = []
|
|
current = identity['s']
|
|
total_len = len(current)
|
|
|
|
for line in lines[1:k+1]:
|
|
parts = line.strip().split()
|
|
if len(parts) != 2:
|
|
return False
|
|
|
|
op, i_str = parts
|
|
if op not in ('L', 'R'):
|
|
return False
|
|
|
|
# 验证i的有效性
|
|
try:
|
|
i = int(i_str)
|
|
except ValueError:
|
|
return False
|
|
|
|
m = len(current)
|
|
if i < 2 or i > m - 1:
|
|
return False # 违反操作规则
|
|
|
|
# 执行操作（验证阶段不实际执行，只检查有效性）
|
|
if op == 'L':
|
|
new_part_len = i - 1 # 新增字符数
|
|
else:
|
|
new_part_len = (m - 1) - (i - 1) + 1 # 原题中i到n-1的子串长度
|
|
|
|
total_len += new_part_len
|
|
if total_len > 1e6:
|
|
return False
|
|
|
|
operations.append((op, i))
|
|
|
|
# 实际操作验证
|
|
current = identity['s']
|
|
for op, i in operations:
|
|
m = len(current)
|
|
|
|
if op == 'L':
|
|
# 取s[1:i] (1-based到i-1) 对应Python的[1-1:i-1] => [0:i-1]
|
|
part = current[0:i-1] # s_2到s_i的原始部分
|
|
prepend = part[::-1]
|
|
current = prepend + current
|
|
else:
|
|
# 取s[i-1:m-1] (原题i到n-1的Python表示)
|
|
part = current[i-1:m-1]
|
|
append_part = part[::-1]
|
|
current = current + append_part
|
|
|
|
return current == current[::-1]
|
|
|
|
except Exception as e:
|
|
return False
|
|
|
|
@staticmethod
|
|
def _generate_palindrome(length):
|
|
"""生成随机回文字符串的优化版本"""
|
|
half = (length + 1) // 2
|
|
chars = [random.choice(string.ascii_lowercase) for _ in range(half)]
|
|
return ''.join(chars + chars[:-1 if length % 2 else None][::-1])
|