init-commit

internbootcamp/bootcamp/enumbertransformationii/enumbertransformationii.py

@@ -0,0 +1,181 @@
+"""# 
+
+### 谜题描述
+You are given a sequence of positive integers x1, x2, ..., xn and two non-negative integers a and b. Your task is to transform a into b. To do that, you can perform the following moves:
+
+  * subtract 1 from the current a; 
+  * subtract a mod xi (1 ≤ i ≤ n) from the current a. 
+
+
+
+Operation a mod xi means taking the remainder after division of number a by number xi.
+
+Now you want to know the minimum number of moves needed to transform a into b.
+
+Input
+
+The first line contains a single integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers x1, x2, ..., xn (2 ≤ xi ≤ 109). The third line contains two integers a and b (0 ≤ b ≤ a ≤ 109, a - b ≤ 106).
+
+Output
+
+Print a single integer — the required minimum number of moves needed to transform number a into number b.
+
+Examples
+
+Input
+
+3
+3 4 5
+30 17
+
+
+Output
+
+6
+
+
+Input
+
+3
+5 6 7
+1000 200
+
+
+Output
+
+206
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+#include <bits/stdc++.h>
+using namespace std;
+int main() {
+  int n, a, b;
+  scanf(\"%d\", &n);
+  vector<int> v(n);
+  for (int i = 0; i < n; i++) scanf(\"%d\", &v[i]);
+  sort(v.begin(), v.end(), greater<int>());
+  v.resize(unique(v.begin(), v.end()) - v.begin());
+  scanf(\"%d%d\", &a, &b);
+  int count = 0, be = 0;
+  while (a > b && be < v.size()) {
+    count++;
+    int step = 0;
+    for (int i = be; i < v.size() && v[i] > step; i++) {
+      if (a - a % v[i] >= b)
+        step = ((step > (a % v[i])) ? step : (a % v[i]));
+      else
+        be = i + 1;
+    }
+    if (step)
+      a -= step;
+    else
+      a--;
+  }
+  count += a - b;
+  printf(\"%d\n\", count);
+  return 0;
+}
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import json
+import random
+from bootcamp import Basebootcamp
+
+class Enumbertransformationiibootcamp(Basebootcamp):
+    def __init__(self, n_min=1, n_max=100, xi_min=2, xi_max=10**9, 
+                 a_min=100, a_max=10**9, diff_min=1, diff_max=10**6):
+        super().__init__()
+        self.n_min = n_min
+        self.n_max = n_max
+        self.xi_min = xi_min
+        self.xi_max = xi_max
+        self.a_min = a_min
+        self.a_max = a_max
+        self.diff_min = diff_min
+        self.diff_max = diff_max
+
+    def case_generator(self):
+        n = random.randint(self.n_min, self.n_max)
+        xi = [random.randint(self.xi_min, self.xi_max) for _ in range(n)]
+        xi = list(set(xi))  # 去重
+        xi.sort(reverse=True)
+        b = random.randint(0, self.a_max - self.diff_min)
+        diff = random.randint(self.diff_min, self.diff_max)
+        a = b + diff
+        case = {
+            'n': n,
+            'xi': xi,
+            'a': a,
+            'b': b
+        }
+        return case
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        xi = question_case['xi']
+        a = question_case['a']
+        b = question_case['b']
+        prompt = f"你有一个序列的正整数x1, x2, ..., xn，以及两个非负整数a和b。你的任务是将a转换为b，使用尽可能少的步骤。允许的操作有两种：1. 减去1；2. 减去a mod xi中的一个xi，其中xi是序列中的一个数。例如，如果a=30，xi=[3,4,5]，那么a mod 3是0，mod4是2，mod5是0。那么，可以选择减去0（这其实是无效操作，因为a不变），或者减去2。所以，操作后a变为28。请给定以下参数，求最小的操作次数：\n\nn = {n}\nxi = {xi}\na = {a}\nb = {b}\n\n请将你的答案放在[answer]标签中，例如：[answer]6[/answer]。"
+        return prompt
+
+    @staticmethod
+    def extract_output(output):
+        start_tag = "[answer]"
+        end_tag = "[/answer]"
+        start = output.rfind(start_tag)
+        if start == -1:
+            return None
+        end = output.find(end_tag, start + len(start_tag))
+        if end == -1:
+            return None
+        answer_str = output[start + len(start_tag):end].strip()
+        if answer_str.isdigit():
+            return int(answer_str)
+        else:
+            return None
+
+    @staticmethod
+    def compute_min_steps(a, b, xi):
+        if a == b:
+            return 0
+        xi = sorted(list(set(xi)), reverse=True)
+        count = 0
+        be = 0
+        while a > b and be < len(xi):
+            max_step = 0
+            new_be = be
+            for i in range(be, len(xi)):
+                mod = a % xi[i]
+                if mod == 0:
+                    continue
+                if a - mod >= b:
+                    if mod > max_step:
+                        max_step = mod
+                        new_be = i + 1
+                else:
+                    new_be = i + 1
+                    break
+            if max_step > 0:
+                a -= max_step
+                count += 1
+                be = new_be
+            else:
+                a -= 1
+                count += 1
+        count += (a - b)
+        return count
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        a = identity['a']
+        b = identity['b']
+        xi = identity['xi']
+        expected = cls.compute_min_steps(a, b, xi)
+        return solution == expected