init-commit

internbootcamp/bootcamp/bsequentialnim/bsequentialnim.py

@@ -0,0 +1,187 @@
+"""# 
+
+### 谜题描述
+There are n piles of stones, where the i-th pile has a_i stones. Two people play a game, where they take alternating turns removing stones.
+
+In a move, a player may remove a positive number of stones from the first non-empty pile (the pile with the minimal index, that has at least one stone). The first player who cannot make a move (because all piles are empty) loses the game. If both players play optimally, determine the winner of the game.
+
+Input
+
+The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
+
+The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the number of piles.
+
+The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 10^9) — a_i is equal to the number of stones in the i-th pile.
+
+It is guaranteed that the sum of n for all test cases does not exceed 10^5.
+
+Output
+
+For each test case, if the player who makes the first move will win, output \"First\". Otherwise, output \"Second\".
+
+Example
+
+Input
+
+
+7
+3
+2 5 4
+8
+1 1 1 1 1 1 1 1
+6
+1 2 3 4 5 6
+6
+1 1 2 1 2 2
+1
+1000000000
+5
+1 2 2 1 1
+3
+1 1 1
+
+
+Output
+
+
+First
+Second
+Second
+First
+First
+Second
+First
+
+Note
+
+In the first test case, the first player will win the game. His winning strategy is: 
+
+  1. The first player should take the stones from the first pile. He will take 1 stone. The numbers of stones in piles will be [1, 5, 4]. 
+  2. The second player should take the stones from the first pile. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 5, 4]. 
+  3. The first player should take the stones from the second pile because the first pile is empty. He will take 4 stones. The numbers of stones in piles will be [0, 1, 4]. 
+  4. The second player should take the stones from the second pile because the first pile is empty. He will take 1 stone because he can't take any other number of stones. The numbers of stones in piles will be [0, 0, 4]. 
+  5. The first player should take the stones from the third pile because the first and second piles are empty. He will take 4 stones. The numbers of stones in piles will be [0, 0, 0]. 
+  6. The second player will lose the game because all piles will be empty. 
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+T = int(raw_input())
+for _ in range(T):
+    N = int(raw_input())
+    stones = [int(v) for v in raw_input().split()]
+    winner =  N % 2
+    for i in range(N):
+        if stones[i] > 1:
+            winner = (i+1) % 2
+            break
+    if winner == 0:
+        print('Second')
+    else:
+        print('First')
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import random
+from bootcamp import Basebootcamp
+
+class Bsequentialnimbootcamp(Basebootcamp):
+    def __init__(self, min_n=1, max_n=10**5, min_a=1, max_a=10**9, case_type='mixed'):
+        self.params = {
+            'min_n': max(1, min_n),
+            'max_n': max(min_n, max_n),
+            'min_a': max(1, min_a),
+            'max_a': max(min_a, max_a),
+            'case_type': case_type
+        }
+    
+    def case_generator(self):
+        params = self.params
+        n = random.randint(params['min_n'], params['max_n'])
+        
+        case_type = params['case_type']
+        if case_type == 'all_ones':
+            a = [1] * n
+        elif case_type == 'first_gt1':
+            first_gt1 = random.randint(0, n-1)
+            a = self._generate_piles_with_key(n, first_gt1)
+        else:
+            if random.random() < 0.3:
+                a = [1] * n
+            else:
+                first_gt1 = random.randint(0, n-1)
+                a = self._generate_piles_with_key(n, first_gt1)
+        
+        return {'n': n, 'a': a}
+    
+    def _generate_piles_with_key(self, n, key_index):
+        a = []
+        for _ in range(key_index):
+            a.append(1)
+        a.append(random.randint(2, self.params['max_a']))
+        for _ in range(n - key_index -1):
+            a.append(random.randint(1, self.params['max_a']))
+        return a
+
+    @staticmethod
+    def prompt_func(question_case) -> str:
+        input_data = {
+            't': 1,
+            'n': question_case['n'],
+            'a': question_case['a']
+        }
+        
+        return """## 石子游戏胜负判断
+
+### 游戏规则
+双方玩家轮流操作，每次必须从第一个非空石堆中取至少一个石子。无法操作者输。胜负判定规则：
+1. 找到第一个石子数>1的石堆（从第1堆开始检查）
+2. 若存在：
+   - 该堆位置为奇数 → 先手胜（First）
+   - 位置为偶数 → 后手胜（Second）
+3. 若不存在（全为1）：
+   - 总堆数奇数 → 先手胜
+   - 总堆数偶数 → 后手胜
+
+### 输入格式
+{t}
+{n}
+{a_vals}
+
+### 输出要求
+1. 严格按规则分析
+2. 最终答案用[answer]标签包裹，如：[answer]First[/answer]
+
+请逐步分析当前测试用例：""".format(
+    t=input_data['t'],
+    n=input_data['n'],
+    a_vals=' '.join(map(str, input_data['a']))
+)
+
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.I)
+        if not matches:
+            return None
+        last_match = matches[-1].strip().upper()
+        return 'First' if last_match.startswith('F') else 'Second'
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        try:
+            n = identity['n']
+            a = identity['a']
+            
+            gt1_index = next((i for i, x in enumerate(a) if x > 1), None)
+            if gt1_index is not None:
+                correct = 'First' if (gt1_index % 2 == 0) else 'Second'
+            else:
+                correct = 'First' if (n % 2 == 1) else 'Second'
+            
+            return str(solution).strip().upper() == correct.upper()
+        except:
+            return False