InternBootcamp/internbootcamp/bootcamp/cinnaandcandyboxes/cinnaandcandyboxes.py

"""# 

### 谜题描述
Inna loves sweets very much. She has n closed present boxes lines up in a row in front of her. Each of these boxes contains either a candy (Dima's work) or nothing (Sereja's work). Let's assume that the boxes are numbered from 1 to n, from left to right.

As the boxes are closed, Inna doesn't know which boxes contain candies and which boxes contain nothing. Inna chose number k and asked w questions to Dima to find that out. Each question is characterised by two integers li, ri (1 ≤ li ≤ ri ≤ n; r - l + 1 is divisible by k), the i-th question is: \"Dima, is that true that among the boxes with numbers from li to ri, inclusive, the candies lie only in boxes with numbers li + k - 1, li + 2k - 1, li + 3k - 1, ..., ri?\"

Dima hates to say \"no\" to Inna. That's why he wonders, what number of actions he will have to make for each question to make the answer to the question positive. In one action, Dima can either secretly take the candy from any box or put a candy to any box (Dima has infinitely many candies). Help Dima count the number of actions for each Inna's question.

Please note that Dima doesn't change the array during Inna's questions. That's why when you calculate the number of operations for the current question, please assume that the sequence of boxes didn't change.

Input

The first line of the input contains three integers n, k and w (1 ≤ k ≤ min(n, 10), 1 ≤ n, w ≤ 105). The second line contains n characters. If the i-th box contains a candy, the i-th character of the line equals 1, otherwise it equals 0.

Each of the following w lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th question. It is guaranteed that ri - li + 1 is divisible by k.

Output

For each question, print a single number on a single line — the minimum number of operations Dima needs to make the answer to the question positive.

Examples

Input

10 3 3
1010100011
1 3
1 6
4 9


Output

1
3
2

Note

For the first question, you need to take a candy from the first box to make the answer positive. So the answer is 1.

For the second question, you need to take a candy from the first box, take a candy from the fifth box and put a candy to the sixth box. The answer is 3.

For the third question, you need to take a candy from the fifth box and put it to the sixth box. The answer is 2.

Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
```python
from sys import stdin, stdout
def main():
    n, k, m = map(int, stdin.readline().split())
    s = stdin.readline().strip()
    a = [0] * (n + k + 10)
    for i in xrange(n):
        a[i+1+k] = a[i+1] + (1 if s[i] == '1' else 0)
    ans = []
    for i in xrange(m):
        l, r = map(int, stdin.readline().split())
        l, r = l + k - 1, r + k
        ans.append((r - l) / k - (a[r] - a[l]) + sum(a[r-j] - a[l-j] for j in xrange(1, k)))
    stdout.write('\n'.join(map(str, ans)))
main()
```


请完成上述谜题的训练场环境类实现，包括所有必要的方法。
"""

from bootcamp import Basebootcamp
import random
import re
from bootcamp import Basebootcamp

class Cinnaandcandyboxesbootcamp(Basebootcamp):
    def __init__(self, k_min=1, k_max=10, n_min=5, n_max=15, w_min=1, w_max=5, **kwargs):
        super().__init__(**kwargs)
        self.k_min = max(k_min, 1)
        self.k_max = min(k_max, 10)  # Enforce k ≤ 10
        self.n_min = max(n_min, self.k_min)  # Ensure n ≥ k_min
        self.n_max = max(n_max, self.n_min)
        self.w_min = max(w_min, 1)
        self.w_max = max(w_max, self.w_min)
    
    def case_generator(self):
        n = random.randint(self.n_min, self.n_max)
        k = random.randint(self.k_min, min(n, self.k_max))  # Force k ≤ min(n,10)
        
        # Generate valid candy configuration
        s = ''.join(random.choice('01') for _ in range(n))
        
        # Generate guaranteed valid queries
        w = random.randint(self.w_min, self.w_max)
        queries = [self.generate_valid_query(n, k) for _ in range(w)]
        
        return {
            'n': n,
            'k': k,
            'w': w,
            's': s,
            'queries': queries
        }
    
    def generate_valid_query(self, n, k):
        max_attempts = 100
        for _ in range(max_attempts):
            # Ensure li allows at least 1k-length interval
            li = random.randint(1, max(1, n - k + 1))
            max_possible_length = n - li + 1
            m_max = max_possible_length // k  # At least 1
            m = random.randint(1, m_max)
            ri = li + m*k - 1
            if ri <= n:
                return (li, ri)
        
        # Fallback: first valid interval
        return (1, k)
    
    @staticmethod
    def prompt_func(question_case) -> str:
        return f"""Inna has {question_case['n']} boxes arranged in a row (1-indexed). Each box contains 1 (candy) or 0 (empty). Answer {question_case['w']} queries about intervals [l, r] where (r-l+1) is divisible by {question_case['k']}. For each query, ensure candies only appear at positions l+{question_case['k']-1}, l+{2*question_case['k']-1}, ..., r. Compute minimum add/remove operations.

Input:
{question_case['n']} {question_case['k']} {question_case['w']}
{question_case['s']}
""" + '\n'.join(f"{l} {r}" for l, r in question_case['queries']) + """

Format answers as:
[answer]
ans1
ans2
...
[/answer]"""
    
    @staticmethod
    def extract_output(output):
        last_answer = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
        if not last_answer:
            return None
        answers = []
        for line in last_answer[-1].strip().splitlines():
            if line.strip().isdigit():
                answers.append(int(line.strip()))
        return answers if answers else None
    
    @classmethod
    def _verify_correction(cls, solution, identity):
        if not solution or len(solution) != identity['w']:
            return False
        try:
            correct = cls.solve_case(
                identity['n'], identity['k'], identity['w'],
                identity['s'], identity['queries']
            )
            return solution == correct
        except:
            return False
    
    @staticmethod
    def solve_case(n, k, w, s, queries):
        # Build prefix sum array with offset
        offset = k + 1
        prefix = [0] * (n + 2*offset)
        for i in range(n):
            prefix[i + offset] = prefix[i] + (1 if s[i] == '1' else 0)
        
        answers = []
        for l, r in queries:
            # Calculate required positions
            target_length = r - l + 1
            steps = target_length // k  # Number of required positions
            
            # Calculate required changes
            required_add = steps - sum(1 for i in range(steps) if s[l + i*k - 1] == '1')
            other_remove = sum(1 for pos in range(l-1, r) if (pos - (l-1)) % k != k-1 and s[pos] == '1')
            answers.append(required_add + other_remove)
        return answers