init-commit

internbootcamp/bootcamp/cproduct1modulon/cproduct1modulon.py

@@ -0,0 +1,304 @@
+"""# 
+
+### 谜题描述
+Now you get Baby Ehab's first words: \"Given an integer n, find the longest subsequence of [1,2, …, n-1] whose product is 1 modulo n.\" Please solve the problem.
+
+A sequence b is a subsequence of an array a if b can be obtained from a by deleting some (possibly all) elements. The product of an empty subsequence is equal to 1.
+
+Input
+
+The only line contains the integer n (2 ≤ n ≤ 10^5).
+
+Output
+
+The first line should contain a single integer, the length of the longest subsequence.
+
+The second line should contain the elements of the subsequence, in increasing order.
+
+If there are multiple solutions, you can print any.
+
+Examples
+
+Input
+
+
+5
+
+
+Output
+
+
+3
+1 2 3 
+
+Input
+
+
+8
+
+
+Output
+
+
+4
+1 3 5 7 
+
+Note
+
+In the first example, the product of the elements is 6 which is congruent to 1 modulo 5. The only longer subsequence is [1,2,3,4]. Its product is 24 which is congruent to 4 modulo 5. Hence, the answer is [1,2,3].
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+#!/usr/bin/env python
+# https://github.com/cheran-senthil/PyRival
+from __future__ import division, print_function
+
+import os
+import sys
+from io import BytesIO, IOBase
+from collections import defaultdict
+
+if sys.version_info[0] < 3:
+    from __builtin__ import xrange as range
+    from future_builtins import ascii, filter, hex, map, oct, zip
+
+
+def main():
+    import math
+
+    def prime_factors(n):
+        factors = []
+        while n % 2 == 0:
+            factors.append(2)
+            n //= 2
+        for i in range(3, int(math.sqrt(n)) + 1, 2):
+            while n % i == 0:
+                factors.append(i)
+                n //= i
+        if n > 2:
+            factors.append(n)
+        return factors
+
+    N = int(input())
+    s = [True] * N
+    for p in set(prime_factors(N)):
+        for k in range(p, N, p):
+            s[k] = False
+    p = 1
+    ans = []
+    for j in range(1, N):
+        if s[j]:
+            p = (p * j) % N
+            ans.append(j)
+    if p != 1:
+        ans.remove(p)
+    print(len(ans))
+    print(' '.join(map(str, ans)))
+
+
+# region fastio
+
+BUFSIZE = 8192
+
+
+class FastIO(IOBase):
+    newlines = 0
+
+    def __init__(self, file):
+        self._fd = file.fileno()
+        self.buffer = BytesIO()
+        self.writable = \"x\" in file.mode or \"r\" not in file.mode
+        self.write = self.buffer.write if self.writable else None
+
+    def read(self):
+        while True:
+            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
+            if not b:
+                break
+            ptr = self.buffer.tell()
+            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
+        self.newlines = 0
+        return self.buffer.read()
+
+    def readline(self):
+        while self.newlines == 0:
+            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
+            self.newlines = b.count(b\"\n\") + (not b)
+            ptr = self.buffer.tell()
+            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
+        self.newlines -= 1
+        return self.buffer.readline()
+
+    def flush(self):
+        if self.writable:
+            os.write(self._fd, self.buffer.getvalue())
+            self.buffer.truncate(0), self.buffer.seek(0)
+
+
+class IOWrapper(IOBase):
+    def __init__(self, file):
+        self.buffer = FastIO(file)
+        self.flush = self.buffer.flush
+        self.writable = self.buffer.writable
+        self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))
+        self.read = lambda: self.buffer.read().decode(\"ascii\")
+        self.readline = lambda: self.buffer.readline().decode(\"ascii\")
+
+
+def print(*args, **kwargs):
+    \"\"\"Prints the values to a stream, or to sys.stdout by default.\"\"\"
+    sep, file = kwargs.pop(\"sep\", \" \"), kwargs.pop(\"file\", sys.stdout)
+    at_start = True
+    for x in args:
+        if not at_start:
+            file.write(sep)
+        file.write(str(x))
+        at_start = False
+    file.write(kwargs.pop(\"end\", \"\n\"))
+    if kwargs.pop(\"flush\", False):
+        file.flush()
+
+
+if sys.version_info[0] < 3:
+    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
+else:
+    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
+
+input = lambda: sys.stdin.readline().rstrip(\"\r\n\")
+
+# endregion
+
+if __name__ == \"__main__\":
+    main()
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import math
+import random
+from bootcamp import Basebootcamp
+
+class Cproduct1modulonbootcamp(Basebootcamp):
+    def __init__(self, min_n=2, max_n=10**5):
+        self.min_n = max(2, min_n)
+        self.max_n = min(10**5, max_n)
+    
+    def case_generator(self):
+        # 基础随机生成（80%概率）
+        if random.random() < 0.8:
+            n = random.randint(self.min_n, self.max_n)
+        else:  # 特殊案例生成（20%概率）
+            candidates = self._generate_special_candidates()
+            n = random.choice(candidates) if candidates else random.randint(self.min_n, self.max_n)
+        return {'n': n}
+    
+    def _generate_special_candidates(self):
+        candidates = []
+        
+        # 质数列表（动态生成范围内）
+        primes = [p for p in [2,3,5,7,11,13,17,19,23,29] if self.min_n <= p <= self.max_n]
+        if primes:
+            candidates.append(random.choice(primes))
+        
+        # 平方数生成
+        max_square_root = int(math.sqrt(self.max_n))
+        squares = [x*x for x in range(2, max_square_root+1) if x*x >= self.min_n]
+        if squares:
+            candidates.append(random.choice(squares))
+        
+        # 合数生成（至少两个不同质因数）
+        composites = []
+        for x in range(max(4, self.min_n), min(100, self.max_n)+1):
+            factors = set()
+            num = x
+            for i in [2,3,5,7]:
+                if num % i == 0:
+                    factors.add(i)
+                    while num % i == 0:
+                        num //= i
+            if num > 1:
+                factors.add(num)
+            if len(factors) >= 2:
+                composites.append(x)
+        if composites:
+            candidates.append(random.choice(composites))
+            
+        return candidates if candidates else [random.randint(self.min_n, self.max_n)]
+    
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        return f"""Given integer n={n}, find the longest increasing subsequence of [1,2,...,{n-1}] where the product ≡1 mod n.
+
+Output format:
+[answer]
+<length>
+<sorted elements>
+[/answer]"""
+
+    @staticmethod
+    def extract_output(output):
+        import re
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+            
+        last_match = matches[-1].strip()
+        lines = [line.strip() for line in last_match.split('\n') if line.strip()]
+        if len(lines) < 2:
+            return None
+            
+        try:
+            length = int(lines[0])
+            elements = list(map(int, lines[1].split()))
+            if len(elements) != length or elements != sorted(elements):
+                return None
+            return elements
+        except:
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        n = identity['n']
+        
+        # 基础校验
+        if not solution or len(solution) == 0:
+            return False
+        if any(e < 1 or e >= n for e in solution):
+            return False
+        if solution != sorted(solution) or len(solution) != len(set(solution)):
+            return False
+        
+        # 互质验证
+        prime_factors = set()
+        num = n
+        for p in [2,3,5,7,11,13,17,19]:
+            if num % p == 0:
+                prime_factors.add(p)
+                while num % p == 0:
+                    num //= p
+        if num > 1:
+            prime_factors.add(num)
+        
+        for e in solution:
+            if any(e % p == 0 for p in prime_factors):
+                return False
+        
+        # 乘积验证
+        product = 1
+        for x in solution:
+            product = (product * x) % n
+        
+        return product == 1 and len(solution) == cls._calculate_expected_length(n)
+    
+    @classmethod
+    def _calculate_expected_length(cls, n):
+        # 计算理论最大长度
+        coprimes = [x for x in range(1, n) if math.gcd(x, n) == 1]
+        product = 1
+        for x in coprimes:
+            product = (product * x) % n
+        return len(coprimes) - (0 if product == 1 else 1)