init-commit

internbootcamp/bootcamp/cnezzarandsymmetricarray/cnezzarandsymmetricarray.py

@@ -0,0 +1,230 @@
+"""# 
+
+### 谜题描述
+Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
+
+For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
+
+Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
+
+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 a single integer n (1 ≤ n ≤ 10^5).
+
+The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
+
+It is guaranteed that the sum of n over all test cases does not exceed 10^5.
+
+Output
+
+For each test case, print \"YES\" in a single line if there exists a possible array a. Otherwise, print \"NO\".
+
+You can print letters in any case (upper or lower).
+
+Example
+
+Input
+
+
+6
+2
+8 12 8 12
+2
+7 7 9 11
+2
+7 11 7 11
+1
+1 1
+4
+40 56 48 40 80 56 80 48
+6
+240 154 210 162 174 154 186 240 174 186 162 210
+
+
+Output
+
+
+YES
+NO
+NO
+NO
+NO
+YES
+
+Note
+
+In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
+
+In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+from sys import stdin
+
+rint = lambda: int(stdin.readline())
+rints = lambda: [int(x) for x in stdin.readline().split()]
+out = []
+for _ in range(int(input())):
+    n, a, su, ans = rint(), sorted(rints()), 0, 'yes'
+
+    for i in range(n * 2 - 1, -1, -2):
+        if a[i] != a[i - 1] or (i > 1 and a[i] == a[i - 2]) or (a[i] - 2 * su) % (2 * n):
+            ans = 'no'
+            break
+        cur = (a[i] - 2 * su) // (n * 2)
+        if cur <= 0:
+            ans = 'no'
+            break
+        su += cur
+        n -= 1
+
+    out.append(ans)
+print('\n'.join(map(str, out)))
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+from bootcamp import Basebootcamp
+
+class Cnezzarandsymmetricarraybootcamp(Basebootcamp):
+    def __init__(self, case_type='mixed', min_n=1, max_n=10, value_range=(1, 10000)):
+        self.case_type = case_type
+        self.min_n = min_n
+        self.max_n = max_n
+        self.value_range = value_range
+
+    def case_generator(self):
+        n = random.randint(self.min_n, self.max_n)
+        if self.case_type == 'valid':
+            return self._generate_valid_case(n)
+        elif self.case_type == 'invalid':
+            return self._generate_robust_invalid_case(n)
+        else:
+            return random.choice([self._generate_valid_case(n), self._generate_robust_invalid_case(n)])
+
+    def _generate_valid_case(self, n):
+        min_val, max_val = self.value_range
+        positives = []
+        while len(positives) < n:
+            num = random.randint(min_val, max_val)
+            if num not in positives:
+                positives.append(num)
+        
+        symmetric_array = []
+        for num in positives:
+            symmetric_array.extend([num, -num])
+        random.shuffle(symmetric_array)
+        
+        d_array = [sum(abs(num - other) for other in symmetric_array) for num in symmetric_array]
+        return {'n': n, 'd': d_array}
+
+    def _generate_robust_invalid_case(self, n, max_attempts=10):
+        # 策略1：破坏有效案例的约束条件
+        for _ in range(max_attempts):
+            valid_case = self._generate_valid_case(n)
+            d = valid_case['d'].copy()
+            sorted_d = sorted(d)
+            
+            # 破坏方法1：打破配对约束
+            last_pair_index = 2*n - 2
+            if sorted_d[last_pair_index] == sorted_d[last_pair_index + 1]:
+                sorted_d[-1] += 1
+                shuffled = sorted_d.copy()
+                random.shuffle(shuffled)
+                if self.check_case(n, shuffled) == 'NO':
+                    return {'n': n, 'd': shuffled}
+            
+            # 破坏方法2：修改数值导致余数错误
+            target_index = random.choice(range(0, 2*n, 2))
+            sorted_d[target_index] += 2*n
+            shuffled = sorted_d.copy()
+            random.shuffle(shuffled)
+            if self.check_case(n, shuffled) == 'NO':
+                return {'n': n, 'd': shuffled}
+
+        # 策略2：完全随机生成直至找到无效案例
+        for _ in range(max_attempts):
+            random_d = [random.randint(0, 10**6) for _ in range(2*n)]
+            if self.check_case(n, random_d) == 'NO':
+                return {'n': n, 'd': random_d}
+        
+        # 保底策略：构造必定失败的案例
+        return {'n': n, 'd': [0]*(2*n)}
+
+    @staticmethod
+    def check_case(n, d_list):
+        sorted_d = sorted(d_list)
+        su = 0
+        current_n = n
+        valid = True
+        
+        if len(sorted_d) != 2*current_n:
+            return 'NO'
+        
+        while current_n > 0 and valid:
+            i = 2*current_n - 1
+            if i < 1 or sorted_d[i] != sorted_d[i-1]:
+                valid = False
+                break
+            
+            if i > 1 and sorted_d[i] == sorted_d[i-2]:
+                valid = False
+                break
+            
+            total = sorted_d[i] - 2*su
+            if total % (2*current_n) != 0:
+                valid = False
+                break
+            
+            cur = total // (2*current_n)
+            if cur <= 0:
+                valid = False
+                break
+            
+            su += cur
+            current_n -= 1
+        
+        return 'YES' if valid and current_n == 0 else 'NO'
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        d = question_case['d']
+        return f"""Determine if a symmetric array exists given the parameters:
+- n = {n}
+- d = {d}
+
+A symmetric array requires:
+1. Exactly 2n distinct integers
+2. For each element a, there exists -a
+3. Each d_i = sum of absolute differences from a_i to all elements
+
+Output YES or NO within [answer] tags:
+
+[answer]
+{{ANSWER}}
+[/answer]"""
+
+    @staticmethod
+    def extract_output(output):
+        markers = ['[answer]', '[/answer]']
+        try:
+            start = output.rindex(markers[0]) + len(markers[0])
+            end = output.index(markers[1], start)
+            answer = output[start:end].strip().upper()
+            return answer if answer in ('YES', 'NO') else None
+        except ValueError:
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        if not solution:
+            return False
+        expected = cls.check_case(identity['n'], identity['d'])
+        return solution.upper() == expected