init-commit

internbootcamp/bootcamp/ckcompleteword/ckcompleteword.py

@@ -0,0 +1,220 @@
+"""# 
+
+### 谜题描述
+Word s of length n is called k-complete if 
+
+  * s is a palindrome, i.e. s_i=s_{n+1-i} for all 1 ≤ i ≤ n; 
+  * s has a period of k, i.e. s_i=s_{k+i} for all 1 ≤ i ≤ n-k. 
+
+
+
+For example, \"abaaba\" is a 3-complete word, while \"abccba\" is not.
+
+Bob is given a word s of length n consisting of only lowercase Latin letters and an integer k, such that n is divisible by k. He wants to convert s to any k-complete word.
+
+To do this Bob can choose some i (1 ≤ i ≤ n) and replace the letter at position i with some other lowercase Latin letter.
+
+So now Bob wants to know the minimum number of letters he has to replace to convert s to any k-complete word.
+
+Note that Bob can do zero changes if the word s is already k-complete.
+
+You are required to answer t test cases independently.
+
+Input
+
+The first line contains a single integer t (1 ≤ t≤ 10^5) — the number of test cases.
+
+The first line of each test case contains two integers n and k (1 ≤ k < n ≤ 2 ⋅ 10^5, n is divisible by k).
+
+The second line of each test case contains a word s of length n.
+
+It is guaranteed that word s only contains lowercase Latin letters. And it is guaranteed that the sum of n over all test cases will not exceed 2 ⋅ 10^5.
+
+Output
+
+For each test case, output one integer, representing the minimum number of characters he has to replace to convert s to any k-complete word.
+
+Example
+
+Input
+
+
+4
+6 2
+abaaba
+6 3
+abaaba
+36 9
+hippopotomonstrosesquippedaliophobia
+21 7
+wudixiaoxingxingheclp
+
+
+Output
+
+
+2
+0
+23
+16
+
+Note
+
+In the first test case, one optimal solution is aaaaaa.
+
+In the second test case, the given word itself is k-complete.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+'''input
+4
+6 2
+abaaba
+6 3
+abaaba
+36 9
+hippopotomonstrosesquippedaliophobia
+21 7
+wudixiaoxingxingheclp
+'''
+
+import sys
+import math
+from collections import Counter
+
+debug = 1
+readln = sys.stdin.readline
+#sys.setrecursionlimit(1000000)
+
+def write(s):
+    sys.stdout.write(str(s))
+
+def writeln(s):
+    sys.stdout.write(str(s))
+    sys.stdout.write('\n')
+
+def readint():
+    return int(readln().strip())
+
+def readints():
+    return map(int, readln().split())
+
+def readstr():
+    return readln().strip()
+
+def readstrs():
+    return readln().split()
+
+def dbg(*args):
+    if debug: print(' '.join(map(str, args)))
+
+def solve(n,k,s):
+    cts = [Counter() for _ in xrange(k)]
+    for i,c in enumerate(s):
+        b = 0
+        if i % k < k/2:
+            b = i % k
+        else:
+            b = k - i % k - 1
+        cts[b][c] += 1
+    ans = 0
+    for ct in cts:
+        if not ct: break
+        common = ct.most_common(1)[0]
+        ans += common[1]
+    return n - ans
+
+t = readint()
+for _ in xrange(t):
+    n,k = readints()
+    s = readstr()
+    writeln(solve(n,k,s))
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import string
+from collections import Counter
+from bootcamp import Basebootcamp
+
+class Ckcompletewordbootcamp(Basebootcamp):
+    def __init__(self, max_k=5, max_m=5, **params):
+        super().__init__(**params)
+        self.max_k = max_k
+        self.max_m = max_m
+
+    def case_generator(self):
+        while True:
+            # Generate valid k and n with k < n
+            k = random.randint(1, self.max_k)
+            m = random.randint(2, self.max_m)
+            n = k * m
+            if k < n:
+                break
+        
+        # Generate valid k-complete base structure
+        group_size = (k + 1) // 2
+        base_chars = [random.choice(string.ascii_lowercase) for _ in range(group_size)]
+        
+        # Build minimal k-complete string
+        s = []
+        for i in range(n):
+            mod = i % k
+            if mod >= group_size:
+                mod = k - mod - 1  # Mirror for palindrome
+            s.append(base_chars[mod % group_size])
+        
+        # Add controlled noise
+        max_noise = min(n, max(1, n // 4))
+        noise_count = random.randint(0, max_noise)
+        noise_indices = random.sample(range(n), k=noise_count)
+        for idx in noise_indices:
+            available_chars = [c for c in string.ascii_lowercase if c != s[idx]]
+            if available_chars:
+                s[idx] = random.choice(available_chars)
+        
+        return {'n': n, 'k': k, 's': ''.join(s)}
+
+    @staticmethod
+    def prompt_func(question_case) -> str:
+        n = question_case['n']
+        k = question_case['k']
+        s = question_case['s']
+        return f"""Given a word s of length {n} and integer k = {k}, find the minimum number of character changes needed to make it k-complete. The word is: "{s}"
+
+A k-complete word must:
+1. Be a palindrome
+2. Have a period of k
+
+Put your final answer between [answer] and [/answer] tags. Example: [answer]3[/answer]"""
+
+    @staticmethod
+    def extract_output(output):
+        import re
+        matches = re.findall(r'\[answer\]\s*(\d+)\s*\[/answer\]', output)
+        return int(matches[-1]) if matches else None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        try:
+            return solution == cls.solve(identity['n'], identity['k'], identity['s'])
+        except:
+            return False
+
+    @staticmethod
+    def solve(n, k, s):
+        group_size = (k + 1) // 2
+        groups = [Counter() for _ in range(group_size)]
+        
+        for i, c in enumerate(s):
+            mod = i % k
+            if mod >= group_size:
+                mod = k - mod - 1
+            groups[mod % group_size][c] += 1
+        
+        total = sum(max(ct.values(), default=0) for ct in groups)
+        return n - total