init-commit

internbootcamp/bootcamp/cluckysubsequence/cluckysubsequence.py

@@ -0,0 +1,320 @@
+"""# 
+
+### 谜题描述
+Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
+
+Petya has sequence a consisting of n integers.
+
+The subsequence of the sequence a is such subsequence that can be obtained from a by removing zero or more of its elements.
+
+Two sequences are considered different if index sets of numbers included in them are different. That is, the values ​of the elements ​do not matter in the comparison of subsequences. In particular, any sequence of length n has exactly 2n different subsequences (including an empty subsequence).
+
+A subsequence is considered lucky if it has a length exactly k and does not contain two identical lucky numbers (unlucky numbers can be repeated any number of times).
+
+Help Petya find the number of different lucky subsequences of the sequence a. As Petya's parents don't let him play with large numbers, you should print the result modulo prime number 1000000007 (109 + 7).
+
+Input
+
+The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105). The next line contains n integers ai (1 ≤ ai ≤ 109) — the sequence a. 
+
+Output
+
+On the single line print the single number — the answer to the problem modulo prime number 1000000007 (109 + 7).
+
+Examples
+
+Input
+
+3 2
+10 10 10
+
+
+Output
+
+3
+
+
+Input
+
+4 2
+4 4 7 7
+
+
+Output
+
+4
+
+Note
+
+In the first sample all 3 subsequences of the needed length are considered lucky.
+
+In the second sample there are 4 lucky subsequences. For them the sets of indexes equal (the indexation starts from 1): {1, 3}, {1, 4}, {2, 3} and {2, 4}.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+N, K = map(int, raw_input().split())
+ll = map(int, raw_input().split())
+
+MOD = 10**9+7
+rest = 0
+lk = {}
+def islucky(x):
+    global lk, rest
+
+    if x in lk:
+        lk[x] += 1
+        return
+
+    result = True
+    for ch in str(x):
+        if ch != \"4\" and ch != \"7\":
+            result = False
+            break
+
+    if result:
+        if x not in lk:
+            lk[x] = 0
+
+        lk[x] += 1
+    else:
+        rest += 1
+
+for elem in ll:
+    islucky(elem)
+
+llk = lk.values()
+
+dp = {}
+def solve(ind, need):
+    global MOD
+
+    if need == 0:
+        return 1
+
+    if ind < 0 or need < 0 or ind+1 < need:
+        return 0
+
+    if (ind, need) in dp:
+        return dp[(ind, need)]
+
+    dp[(ind, need)] = solve(ind-1, need) + solve(ind-1, need-1) * llk[ind]
+    dp[(ind, need)] %= MOD
+
+    return dp[(ind, need)]
+
+
+facts = [1 for _ in xrange(N+5)]
+for i in xrange(2, len(facts)):
+    facts[i] = facts[i-1] * i
+    facts[i] %= MOD
+
+def comber(a, b):
+    global MOD, facts
+
+    if b == 0:
+        return 1
+
+    if b > a or a < 0 or b < 0:
+        return 0
+
+    return (facts[a] * pow(facts[b], MOD-2, MOD) * pow(facts[a-b], MOD-2, MOD)) % MOD
+
+ans = 0
+for i in xrange(len(lk)+1):
+    ans += solve(len(lk)-1, i) * comber(rest, K-i)
+    ans %= MOD
+    #print \"==\", i, ans
+
+print ans
+#print dp
+#print lk, llk, rest
+#print facts
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+MOD = 10**9 + 7
+
+def calculate_answer(n, k, a):
+    rest = 0
+    lk = {}
+
+    def islucky(x):
+        nonlocal rest
+        s = str(x)
+        for c in s:
+            if c not in {'4', '7'}:
+                rest += 1
+                return False
+        lk[x] = lk.get(x, 0) + 1
+        return True
+
+    for elem in a:
+        islucky(elem)
+
+    llk = list(lk.values())
+    m = len(llk)
+    dp = {}
+
+    def solve(ind, need):
+        if need == 0:
+            return 1
+        if ind < 0 or need < 0 or ind + 1 < need:
+            return 0
+        if (ind, need) in dp:
+            return dp[(ind, need)]
+        res = (solve(ind-1, need) + solve(ind-1, need-1) * llk[ind]) % MOD
+        dp[(ind, need)] = res
+        return res
+
+    facts = [1] * (n + 5)
+    for i in range(2, len(facts)):
+        facts[i] = (facts[i-1] * i) % MOD
+
+    def comber(a_num, b_num):
+        if b_num == 0:
+            return 1
+        if b_num > a_num or a_num < 0 or b_num < 0:
+            return 0
+        numerator = facts[a_num]
+        denominator = (facts[b_num] * facts[a_num - b_num]) % MOD
+        return (numerator * pow(denominator, MOD-2, MOD)) % MOD
+
+    ans = 0
+    max_i = min(m, k)
+    for i in range(0, max_i + 1):
+        needed = k - i
+        if needed < 0 or needed > rest:
+            continue
+        way_lucky = solve(m-1, i) if m > 0 else (0 if i > 0 else 1)
+        way_non_lucky = comber(rest, needed)
+        ans = (ans + way_lucky * way_non_lucky) % MOD
+    return ans
+
+class Cluckysubsequencebootcamp(Basebootcamp):
+    def __init__(self, max_lucky_types=3, min_n=1, max_n=10, max_rest_count=5):
+        self.max_lucky_types = max_lucky_types
+        self.min_n = min_n
+        self.max_n = max_n
+        self.max_rest_count = max_rest_count
+        self.max_lucky_count = max(1, max_n // 2)  # 新增参数控制单个幸运数最大数量
+    
+    @staticmethod
+    def is_lucky(x):
+        s = str(x)
+        return all(c in {'4', '7'} for c in s)
+    
+    def generate_lucky_number(self):
+        return int(''.join(random.choice(['4', '7']) for _ in range(random.randint(1, 4))))
+    
+    def generate_non_lucky_number(self):
+        while True:
+            num = random.randint(1, 10**9)
+            s = list(str(num))
+            if any(c not in {'4', '7'} for c in s):
+                return num
+            # 强制修改最后一位为非幸运数字
+            s[-1] = random.choice(['0', '1', '2', '3', '5', '6', '8', '9'])
+            return int(''.join(s))
+    
+    def case_generator(self):
+        for _ in range(1000):  # 防止无限循环
+            m = random.randint(0, min(self.max_lucky_types, self.max_n))
+            lucky_numbers = list({self.generate_lucky_number() for _ in range(m)})
+            m = len(lucky_numbers)  # 实际生成的唯一幸运数数量
+            
+            # 生成counts并确保总和不超过max_n
+            counts = []
+            sum_c = 0
+            for _ in range(m):
+                max_possible = min(self.max_lucky_count, self.max_n - sum_c)
+                if max_possible < 1:
+                    break
+                cnt = random.randint(1, max_possible)
+                counts.append(cnt)
+                sum_c += cnt
+                if sum_c >= self.max_n:
+                    break
+            
+            # 计算rest_count范围
+            rest_min = max(0, self.min_n - sum_c)
+            rest_max = min(
+                self.max_rest_count,
+                self.max_n - sum_c,
+                self.max_n - rest_min  # 确保总和不超过max_n
+            )
+            
+            if rest_min > rest_max:
+                continue
+            
+            rest_count = random.randint(rest_min, rest_max)
+            n = sum_c + rest_count
+            
+            # 最终校验
+            if not (self.min_n <= n <= self.max_n):
+                continue
+            if not (1 <= rest_count <= self.max_rest_count):
+                continue
+            
+            k = random.randint(1, n)
+            
+            # 构建数组
+            a = []
+            for num, cnt in zip(lucky_numbers, counts):
+                a += [num] * cnt
+            a += [self.generate_non_lucky_number() for _ in range(rest_count)]
+            random.shuffle(a)
+            
+            try:
+                expected = calculate_answer(n, k, a)
+                return {
+                    'n': n,
+                    'k': k,
+                    'a': a,
+                    'expected': expected
+                }
+            except:
+                continue
+        raise ValueError("Failed to generate valid case after 1000 attempts")
+    
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        k = question_case['k']
+        a = question_case['a']
+        problem_desc = (
+            "Petya loves lucky numbers. Lucky numbers are positive integers that only contain digits 4 and 7. "
+            "You need to find the number of distinct lucky subsequences of length exactly k. A subsequence is lucky "
+            "if it contains no duplicate lucky numbers (non-lucky numbers can be repeated). Subsequences are "
+            "considered different if their indices are different. Output the answer modulo 1,000,000,007.\n\n"
+            "Input format:\n- First line: n and k (1 ≤ k ≤ n ≤ 1e5)\n- Second line: n integers a_1 to a_n (1 ≤ a_i ≤ 1e9)\n\n"
+            "Your task:\n"
+            f"n = {n}, k = {k}\n"
+            f"Array a: {a}\n\n"
+            "Compute the result and put your final answer within [answer] and [/answer]."
+        )
+        return problem_desc
+    
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+        try:
+            return int(matches[-1].strip()) % MOD
+        except (ValueError, TypeError):
+            return None
+    
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        expected = identity.get('expected')
+        if expected is None:
+            return False
+        return (solution % MOD) == (expected % MOD)