init-commit

internbootcamp/bootcamp/crestoringpermutation/crestoringpermutation.py

@@ -0,0 +1,199 @@
+"""# 
+
+### 谜题描述
+You are given a sequence b_1, b_2, …, b_n. Find the lexicographically minimal permutation a_1, a_2, …, a_{2n} such that b_i = min(a_{2i-1}, a_{2i}), or determine that it is impossible.
+
+Input
+
+Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100).
+
+The first line of each test case consists of one integer n — the number of elements in the sequence b (1 ≤ n ≤ 100).
+
+The second line of each test case consists of n different integers b_1, …, b_n — elements of the sequence b (1 ≤ b_i ≤ 2n).
+
+It is guaranteed that the sum of n by all test cases doesn't exceed 100.
+
+Output
+
+For each test case, if there is no appropriate permutation, print one number -1.
+
+Otherwise, print 2n integers a_1, …, a_{2n} — required lexicographically minimal permutation of numbers from 1 to 2n.
+
+Example
+
+Input
+
+
+5
+1
+1
+2
+4 1
+3
+4 1 3
+4
+2 3 4 5
+5
+1 5 7 2 8
+
+
+Output
+
+
+1 2 
+-1
+4 5 1 2 3 6 
+-1
+1 3 5 6 7 9 2 4 8 10 
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+from bisect import bisect
+for _ in range(input()):
+    n = input()
+    a = map(int,raw_input().split())
+    if 1 not in a or 2*n in a:
+        print -1
+        continue
+    l = []
+    for i in range(1,2*n+1):
+        if i not in a:
+            l.append(i)
+    d = {}
+    f = 0
+    for i in range(n):
+        p = bisect(l,a[i])
+        if p==len(l):
+            f = 1
+            break
+        d[a[i]] = l[p]
+        l.remove(l[p])
+    if f==1:
+        print -1
+        continue
+    for i in range(n):
+        print a[i],d[a[i]],
+    print
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+from bisect import bisect_right as bisect
+import re
+from bootcamp import Basebootcamp
+
+class Crestoringpermutationbootcamp(Basebootcamp):
+    def __init__(self, min_n=1, max_n=5, unsolvable_prob=0.2):
+        self.min_n = min_n
+        self.max_n = max_n
+        self.unsolvable_prob = unsolvable_prob
+    
+    def case_generator(self):
+        if random.random() < self.unsolvable_prob:
+            n = random.randint(self.min_n, self.max_n)
+            case_type = random.choice([1, 2])
+            b = []
+            if case_type == 1:
+                b = [2 * n]
+                remaining = list(range(1, 2 * n))
+                if n > 1:
+                    others = random.sample(remaining, n-1)
+                    b.extend(others)
+            else:
+                possible = list(range(2, 2 * n + 1))
+                b = random.sample(possible, k=n)
+            random.shuffle(b)
+            return {
+                'n': n,
+                'b': b,
+                'expected': -1
+            }
+        else:
+            while True:
+                n = random.randint(self.min_n, self.max_n)
+                possible_values = list(range(1, 2 * n + 1))
+                if 2 * n in possible_values:
+                    possible_values.remove(2 * n)
+                if 1 not in possible_values:
+                    continue
+                b = [1]
+                if n > 1:
+                    remaining = possible_values.copy()
+                    remaining.remove(1)
+                    others = random.sample(remaining, n-1)
+                    b.extend(others)
+                if len(set(b)) != n or 2 * n in b or 1 not in b:
+                    continue
+                sorted_b = sorted(b)
+                l = sorted([num for num in range(1, 2 * n + 1) if num not in sorted_b])
+                d = {}
+                f = 0
+                for bi in sorted_b:
+                    pos = bisect(l, bi)
+                    if pos >= len(l):
+                        f = 1
+                        break
+                    selected = l[pos]
+                    d[bi] = selected
+                    del l[pos]
+                if f:
+                    continue
+                a = []
+                for num in sorted_b:
+                    a.append(num)
+                    a.append(d[num])
+                return {
+                    'n': n,
+                    'b': b,
+                    'expected': a
+                }
+    
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        b = question_case['b']
+        prompt = f"""You are given a sequence b of length {n}. Find the lexicographically smallest permutation a of 1 to {2*n} such that for each i (1 ≤ i ≤ {n}), b[i] is the minimum of a[2i-1] and a[2i]. If impossible, output -1.
+
+Input:
+n = {n}
+b = {b}
+
+Format your answer as space-separated numbers within [answer] tags. Example:
+[answer]1 2 3 4[/answer] or [answer]-1[/answer]"""
+        return prompt
+    
+    @staticmethod
+    def extract_output(output):
+        pattern = r'\[answer\](.*?)\[/answer\]'
+        matches = re.findall(pattern, output, re.DOTALL)
+        if not matches:
+            return None
+        last_match = matches[-1].strip()
+        if last_match == '-1':
+            return -1
+        try:
+            return list(map(int, last_match.split()))
+        except:
+            return None
+    
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        n = identity['n']
+        b = identity['b']
+        expected = identity.get('expected')
+        if solution == -1:
+            return expected == -1
+        if not isinstance(solution, list) or len(solution) != 2 * n:
+            return False
+        if set(solution) != set(range(1, 2 * n + 1)):
+            return False
+        for i in range(n):
+            if min(solution[2*i], solution[2*i+1]) != b[i]:
+                return False
+        if expected != -1:
+            return solution == expected
+        return False