init-commit

internbootcamp/bootcamp/cmodifiedgcd/cmodifiedgcd.py

@@ -0,0 +1,219 @@
+"""# 
+
+### 谜题描述
+Well, here is another math class task. In mathematics, GCD is the greatest common divisor, and it's an easy task to calculate the GCD between two positive integers.
+
+A common divisor for two positive numbers is a number which both numbers are divisible by.
+
+But your teacher wants to give you a harder task, in this task you have to find the greatest common divisor d between two integers a and b that is in a given range from low to high (inclusive), i.e. low ≤ d ≤ high. It is possible that there is no common divisor in the given range.
+
+You will be given the two integers a and b, then n queries. Each query is a range from low to high and you have to answer each query.
+
+Input
+
+The first line contains two integers a and b, the two integers as described above (1 ≤ a, b ≤ 109). The second line contains one integer n, the number of queries (1 ≤ n ≤ 104). Then n lines follow, each line contains one query consisting of two integers, low and high (1 ≤ low ≤ high ≤ 109).
+
+Output
+
+Print n lines. The i-th of them should contain the result of the i-th query in the input. If there is no common divisor in the given range for any query, you should print -1 as a result for this query.
+
+Examples
+
+Input
+
+9 27
+3
+1 5
+10 11
+9 11
+
+
+Output
+
+3
+-1
+9
+
+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 factor(num):
+    i = 1
+    fac = set()
+    while i*i<=num:
+        if num%i==0:
+            fac.add(i)
+            fac.add(num/i)
+        i+=1
+    return fac
+
+a,b = RI()
+facA = factor(a)
+facB = factor(b)
+common = facA&facB
+
+for _ in xrange(RN()):
+    lo,hi = RI()
+    ans = -1
+    for f in common:
+        if lo<=f<=hi:
+            ans = max(ans,f)
+    print ans
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import math
+import random
+from bootcamp import Basebootcamp
+
+class Cmodifiedgcdbootcamp(Basebootcamp):
+    def __init__(self, min_d=1, max_d=100, min_mult=1, max_mult=100, min_queries=3, max_queries=5):
+        self.min_d = min_d
+        self.max_d = max_d
+        self.min_mult = min_mult
+        self.max_mult = max_mult
+        self.min_queries = min_queries  # 最少3个查询以保证案例多样性
+        self.max_queries = max_queries
+
+    def case_generator(self):
+        # 确保生成合法的公约数
+        d = random.randint(max(1, self.min_d), self.max_d)
+
+        def generate_coprimes(max_retry=100):
+            for _ in range(max_retry):
+                a_mult = random.randint(self.min_mult, self.max_mult)
+                b_mult = random.randint(self.min_mult, self.max_mult)
+                if math.gcd(a_mult, b_mult) == 1:
+                    return a_mult, b_mult
+            return 1, 1  # fallback
+
+        a_mult, b_mult = generate_coprimes()
+        a = d * a_mult
+        b = d * b_mult
+
+        # 生成所有公约数（降序排列）
+        def collect_factors(num):
+            factors = set()
+            for i in range(1, int(math.sqrt(num)) + 1):
+                if num % i == 0:
+                    factors.update({i, num//i})
+            return sorted(factors, reverse=True)
+        common_factors = collect_factors(math.gcd(a, b))
+
+        # 生成包含不同类型查询的测试案例
+        n = random.randint(self.min_queries, self.max_queries)
+        queries = []
+        answers = []
+        
+        # 预先生成必须包含的测试类型
+        query_types = [
+            ('exact_match', d),  # 精确匹配最大公约数
+            ('below_min', 0),    # 下界低于最小因数
+            ('over_max', d*2)    # 上界超过最大因数
+        ]
+        
+        # 填充剩余查询为随机类型
+        for _ in range(n - len(query_types)):
+            query_types.append(('random', None))
+        
+        random.shuffle(query_types)
+
+        for q_type in query_types[:n]:  # 确保总数为n
+            if q_type[0] == 'exact_match':
+                low = high = q_type[1]
+            elif q_type[0] == 'below_min':
+                low = 1
+                high = min(common_factors) - 1
+            elif q_type[0] == 'over_max':
+                low = common_factors[0] + 1
+                high = low + 10
+            else:
+                # 生成包含有效范围的随机查询
+                if common_factors and random.random() < 0.7:
+                    target = random.choice(common_factors)
+                    low = random.randint(max(1, target-2), target)
+                    high = random.randint(target, target+2)
+                else:
+                    low = random.randint(1, 10**9)
+                    high = random.randint(low, 10**9)
+
+            # 计算答案
+            ans = -1
+            for f in common_factors:
+                if low <= f <= high:
+                    ans = f
+                    break
+            queries.append((low, high))
+            answers.append(ans)
+
+        return {
+            'a': a,
+            'b': b,
+            'n': n,
+            'queries': queries,
+            'answers': answers
+        }
+
+    @staticmethod
+    def prompt_func(question_case):
+        prompt = f"""请解决以下数学问题：
+
+**任务说明**
+给定两个正整数a和b（分别为{question_case['a']}和{question_case['b']}），您需要处理{question_case['n']}个查询。每个查询给出两个整数low和high，要求找到a和b的最大公约数d，使得d满足low ≤ d ≤ high。如果不存在这样的d，返回-1。
+
+**输入格式**
+- 第1行：a和b，空格分隔
+- 第2行：n（查询数量）
+- 随后n行：每行两个整数low和high，空格分隔
+
+**当前测试用例**
+{question_case['a']} {question_case['b']}
+{question_case['n']}
+""" 
+        prompt += "\n".join(f"{lo} {hi}" for lo, hi in question_case['queries'])
+        prompt += "\n\n**输出要求**\n请严格按照顺序输出{question_case['n']}行结果，每行一个整数，使用如下格式：\n[answer]\n结果1\n结果2\n...\n[/answer]"
+
+        return prompt
+
+    @staticmethod
+    def extract_output(output):
+        answer_blocks = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not answer_blocks:
+            return None
+            
+        processed = []
+        for line in answer_blocks[-1].strip().split('\n'):
+            cleaned = line.strip()
+            if cleaned:
+                try:
+                    processed.append(int(cleaned))
+                except ValueError:
+                    pass
+        return processed or None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        # 双重验证：答案数量必须匹配且每个答案正确
+        return (
+            isinstance(solution, list) and
+            len(solution) == identity['n'] and
+            solution == identity['answers']
+        )