init-commit

internbootcamp/bootcamp/caddone/caddone.py

@@ -0,0 +1,243 @@
+"""# 
+
+### 谜题描述
+You are given an integer n. You have to apply m operations to it.
+
+In a single operation, you must replace every digit d of the number with the decimal representation of integer d + 1. For example, 1912 becomes 21023 after applying the operation once.
+
+You have to find the length of n after applying m operations. Since the answer can be very large, print it modulo 10^9+7.
+
+Input
+
+The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^5) — the number of test cases.
+
+The only line of each test case contains two integers n (1 ≤ n ≤ 10^9) and m (1 ≤ m ≤ 2 ⋅ 10^5) — the initial number and the number of operations. 
+
+Output
+
+For each test case output the length of the resulting number modulo 10^9+7.
+
+Example
+
+Input
+
+
+5
+1912 1
+5 6
+999 1
+88 2
+12 100
+
+
+Output
+
+
+5
+2
+6
+4
+2115
+
+Note
+
+For the first test, 1912 becomes 21023 after 1 operation which is of length 5.
+
+For the second test, 5 becomes 21 after 6 operations which is of length 2.
+
+For the third test, 999 becomes 101010 after 1 operation which is of length 6.
+
+For the fourth test, 88 becomes 1010 after 2 operations which is of length 4.
+
+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
+testing = len(sys.argv) == 4 and sys.argv[3] == \"myTest\"
+if testing:
+    cmd = sys.stdout
+    from time import time
+    start_time = int(round(time() * 1000)) 
+    readAll = open(sys.argv[1], 'r').read
+    sys.stdout = open(sys.argv[2], 'w')
+else:
+    readAll = sys.stdin.read
+
+# ############ ---- I/O Functions ---- ############
+
+flush = sys.stdout.flush
+class InputData:
+    def __init__(self):
+        self.lines = readAll().split('\n')
+        self.n = len(self.lines)
+        self.ii = -1
+    def input(self):
+        self.ii += 1
+        assert self.ii < self.n
+        return self.lines[self.ii]
+inputData = InputData()
+input = inputData.input
+
+def intin():
+    return(int(input()))
+def intlin():
+    return(list(map(int,input().split())))
+def chrin():
+    return(list(input()))
+def strin():
+    return input()
+def lout(l, sep=\"\n\", toStr=True):
+    print(sep.join(map(str, l) if toStr else l))
+def dout(*args, **kargs):
+    if not testing: return
+    if args: print(args[0] if len(args)==1 else args)
+    if kargs: print([(k,v) for k,v in kargs.items()])
+    
+# ############ ---- I/O Functions ---- ############
+
+# from math import ceil
+from collections import defaultdict as ddict, Counter
+# from heapq import *
+# from Queue import Queue
+mmap = [0]*(2*10**5+100)
+mod = 10**9+7
+cnts = [0]*10
+k = 0
+cnts[k] = 1
+for i in xrange(1,2*10**5+100):
+    prv = cnts[0]
+    for j in xrange(9):
+        nxt = cnts[j+1]
+        cnts[j+1] = prv
+        prv = nxt
+    cnts[0] = prv
+    cnts[1] = (prv+cnts[1])%mod
+    mmap[i] = (sum(cnts))%mod
+
+def main():
+    n,m = intlin()
+    ans = 0
+    # cnts = Counter(map(int,(list(str(n)))))
+    # for i in xrange(10):
+    #     ans += mmap[m+i]*cnts[i]
+    while n > 0:
+        ans += mmap[m+n%10]
+        n /= 10
+    return(ans%mod)
+
+anss = []
+for _ in xrange(intin()):
+    anss.append(main())
+    # anss.append(\"YES\" if main() else \"NO\")
+lout(anss)
+
+if testing:
+    sys.stdout = cmd
+    print(int(round(time() * 1000))  - start_time)
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import random
+from bootcamp import Basebootcamp
+
+class Caddonebootcamp(Basebootcamp):
+    _mmap = None
+    MOD = 10**9 + 7
+
+    def __init__(self, **params):
+        super().__init__(**params)
+        self.params = params
+
+    @classmethod
+    def _precompute_mmap(cls):
+        if cls._mmap is not None:
+            return
+        max_m = 2 * 10**5 + 10
+        cls._mmap = [0] * (max_m + 10)  # 覆盖最大可能m+9的情况
+        
+        # 初始化状态：0应用0次操作时的位数
+        cnts = [0] * 10
+        cnts[0] = 1
+        
+        # 预处理所有可能的操作次数
+        for k in range(0, max_m + 10):
+            # 当前状态的总位数即为mmap[k]
+            cls._mmap[k] = sum(cnts) % cls.MOD
+            
+            # 如果未达到最大次数，准备下一层状态
+            if k >= max_m:
+                continue
+                
+            # 更新下一层状态
+            new_cnts = [0] * 10
+            for d in range(10):
+                next_num = d + 1
+                for digit in str(next_num):
+                    new_d = int(digit)
+                    new_cnts[new_d] = (new_cnts[new_d] + cnts[d]) % cls.MOD
+            cnts = new_cnts
+
+    def case_generator(self):
+        # 平衡生成随机和边界用例
+        if random.random() < 0.2:  # 20%概率生成预定义边界用例
+            cases = [
+                (1912, 1), (5, 6), (999, 1),
+                (88, 2), (12, 100), (1, 200000),
+                (10**9, 1), (9, 200000), (0, 1)
+            ]
+            n, m = random.choice(cases)
+        else:  # 80%概率生成随机有效用例
+            n = random.randint(1, 10**9)
+            m = random.randint(1, 2*10**5)
+        
+        # 确保n不包含前导零
+        return {'n': n, 'm': m}
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        m = question_case['m']
+        return f"""Given initial number {n} and {m} operations where each digit d becomes the decimal representation of d+1:
+(e.g. 9→10 becomes two digits). Compute the final number length modulo 10^9+7.
+
+Rules:
+1. Operations are applied simultaneously to all digits
+2. 9→10, 5→6 (single-digit→single-digit)
+3. Answer must be an integer within [answer]...[/answer] tags.
+
+Example: For input 1912 with 1 operation:
+[answer]5[/answer]
+
+Now solve for n={n}, m={m}."""
+
+    @staticmethod
+    def extract_output(output):
+        # 支持多空格和换行的健壮正则
+        pattern = r'\[answer\][\s\n]*(\d+)[\s\n]*\[/answer\]'
+        matches = re.findall(pattern, output, re.IGNORECASE | re.DOTALL)
+        return int(matches[-1]) if matches else None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        cls._precompute_mmap()
+        n, m = identity['n'], identity['m']
+        
+        # 处理n=0的特殊情况（虽然题目限制n≥1）
+        if n == 0:
+            return solution == 1 if m == 0 else 0
+        
+        total = 0
+        while n > 0:
+            d = n % 10
+            k = m + d
+            if k < len(cls._mmap):
+                total = (total + cls._mmap[k]) % cls.MOD
+            else:
+                # 动态计算超出预处理范围的情况（理论上不应发生）
+                pass  
+            n //= 10
+        return total == solution