init-commit

internbootcamp/bootcamp/e1asterismeasyversion/e1asterismeasyversion.py

@@ -0,0 +1,256 @@
+"""# 
+
+### 谜题描述
+This is the easy version of the problem. The difference between versions is the constraints on n and a_i. You can make hacks only if all versions of the problem are solved.
+
+First, Aoi came up with the following idea for the competitive programming problem:
+
+Yuzu is a girl who collecting candies. Originally, she has x candies. There are also n enemies numbered with integers from 1 to n. Enemy i has a_i candies.
+
+Yuzu is going to determine a permutation P. A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, \{2,3,1,5,4\} is a permutation, but \{1,2,2\} is not a permutation (2 appears twice in the array) and \{1,3,4\} is also not a permutation (because n=3 but there is the number 4 in the array).
+
+After that, she will do n duels with the enemies with the following rules:
+
+  * If Yuzu has equal or more number of candies than enemy P_i, she wins the duel and gets 1 candy. Otherwise, she loses the duel and gets nothing. 
+  * The candy which Yuzu gets will be used in the next duels. 
+
+
+
+Yuzu wants to win all duels. How many valid permutations P exist?
+
+This problem was easy and wasn't interesting for Akari, who is a friend of Aoi. And Akari made the following problem from the above idea:
+
+Let's define f(x) as the number of valid permutations for the integer x.
+
+You are given n, a and a prime number p ≤ n. Let's call a positive integer x good, if the value f(x) is not divisible by p. Find all good integers x.
+
+Your task is to solve this problem made by Akari.
+
+Input
+
+The first line contains two integers n, p (2 ≤ p ≤ n ≤ 2000). It is guaranteed, that the number p is prime (it has exactly two divisors 1 and p).
+
+The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2000).
+
+Output
+
+In the first line, print the number of good integers x.
+
+In the second line, output all good integers x in the ascending order.
+
+It is guaranteed that the number of good integers x does not exceed 10^5.
+
+Examples
+
+Input
+
+
+3 2
+3 4 5
+
+
+Output
+
+
+1
+3
+
+
+Input
+
+
+4 3
+2 3 5 6
+
+
+Output
+
+
+2
+3 4
+
+
+Input
+
+
+4 3
+9 1 1 1
+
+
+Output
+
+
+0
+
+Note
+
+In the first test, p=2.
+
+  * If x ≤ 2, there are no valid permutations for Yuzu. So f(x)=0 for all x ≤ 2. The number 0 is divisible by 2, so all integers x ≤ 2 are not good. 
+  * If x = 3, \{1,2,3\} is the only valid permutation for Yuzu. So f(3)=1, so the number 3 is good. 
+  * If x = 4, \{1,2,3\} , \{1,3,2\} , \{2,1,3\} , \{2,3,1\} are all valid permutations for Yuzu. So f(4)=4, so the number 4 is not good. 
+  * If x ≥ 5, all 6 permutations are valid for Yuzu. So f(x)=6 for all x ≥ 5, so all integers x ≥ 5 are not good. 
+
+
+
+So, the only good number is 3.
+
+In the third test, for all positive integers x the value f(x) is divisible by p = 3.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+import sys
+if sys.subversion[0] == \"PyPy\":
+    import io, atexit
+    sys.stdout = io.BytesIO()
+    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
+    
+    sys.stdin = io.BytesIO(sys.stdin.read())
+    input = lambda: sys.stdin.readline().rstrip()
+
+RS = raw_input
+RI = lambda x=int: map(x,RS().split())
+RN = lambda x=int: x(RS())
+''' ...................................................................... '''
+
+def ok(x):
+    j=0
+    
+    for i in xrange(n):
+        while j<n and arr[j]<=(x+i):
+            j+=1
+        cnt = j -i
+        if cnt%p==0: return 0
+    return 1
+        
+
+n,p = RI()
+arr = RI()
+arr.sort()
+m = arr[n-1]
+ans = []
+for x in xrange(max(0,m-n)+1,m+1):
+    if ok(x): ans.append(x)
+
+print len(ans)
+print ' '.join(map(str,ans))
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+from bootcamp import Basebootcamp
+
+class E1asterismeasyversionbootcamp(Basebootcamp):
+    def __init__(self, min_n=2, max_n=10, max_a=2000, **kwargs):
+        super().__init__(**kwargs)
+        self.min_n = max(2, min_n)  # Ensure minimum n is 2
+        self.max_n = max(self.min_n, max_n)
+        self.max_a = max_a
+
+    def case_generator(self):
+        # Generate n within the specified range
+        n = random.randint(self.min_n, self.max_n)
+        
+        # Function to generate primes up to a given number
+        def get_primes_up_to(num):
+            sieve = [True] * (num + 1)
+            sieve[0] = sieve[1] = False
+            for i in range(2, int(num**0.5) + 1):
+                if sieve[i]:
+                    sieve[i*i : num+1 : i] = [False] * len(sieve[i*i : num+1 : i])
+            return [i for i, is_prime in enumerate(sieve) if is_prime]
+        
+        possible_p = get_primes_up_to(n)
+        if not possible_p:
+            possible_p = [2]  # Fallback, though this should not happen for n >= 2
+        p = random.choice(possible_p)
+        
+        # Generate and sort the array a
+        a = [random.randint(1, self.max_a) for _ in range(n)]
+        a.sort()
+        
+        return {
+            'n': n,
+            'p': p,
+            'a': a
+        }
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        p = question_case['p']
+        a = question_case['a']
+        a_str = ' '.join(map(str, a))
+        prompt = f"""Akari's programming problem involves finding 'good' integers x based on Yuzu's candy duel scenario. Yuzu must defeat {n} enemies, each with a certain number of candies. The goal is to determine all x where the number of valid permutations for Yuzu is not divisible by the prime p={p}.
+
+**Problem Details:**
+- Yuzu starts with x candies.
+- Each enemy i has {a_str} candies (sorted).
+- Yuzu wins all duels in a permutation if she has enough candies each time, gaining 1 candy per win.
+- Find all x such that the number of valid permutations is not divisible by p.
+
+**Input Constraints:**
+- n = {n}, prime p = {p} (p ≤ n)
+- Enemy candies: {a_str}
+
+**Output Format:**
+1. First line: Number of good integers x.
+2. Second line: List of good x values in ascending order.
+
+Example:
+If x values are 3 and 4, output:
+2
+3 4
+
+Place your answer between [answer] and [/answer], following the format exactly."""
+        return prompt
+
+    @staticmethod
+    def extract_output(output):
+        import re
+        answer_blocks = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not answer_blocks:
+            return None
+        last_block = answer_blocks[-1].strip()
+        lines = [line.strip() for line in last_block.split('\n') if line.strip()]
+        if len(lines) < 2:
+            return None
+        try:
+            count = int(lines[0])
+            x_list = list(map(int, lines[1].split()))
+            if len(x_list) != count or x_list != sorted(x_list):
+                return None
+            return x_list
+        except:
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        if solution is None:
+            return False
+        n = identity['n']
+        p = identity['p']
+        a = sorted(identity['a'])
+        m = a[-1] if n > 0 else 0
+        start_x = max(0, m - n) + 1
+        end_x = m
+        
+        correct_x = []
+        for x in range(start_x, end_x + 1):
+            j = 0
+            valid = True
+            for i in range(n):
+                while j < n and a[j] <= x + i:
+                    j += 1
+                cnt = j - i
+                if cnt % p == 0:
+                    valid = False
+                    break
+            if valid:
+                correct_x.append(x)
+        
+        return solution == correct_x