Problem p01253 - Generation 3

Orig Description

Problem D: Deadly Dice Game
T.I. Financial Group, a world-famous group of finance companies, has decided to hold an evil gambling
game in which insolvent debtors compete for special treatment of exemption from their debts.
In this game, each debtor starts from one cell on the stage called the Deadly Ring. The Deadly Ring
consists of N cells and each cell is colored black or red. Each cell is connected to exactly two other
adjacent cells and all the cells form a ring. At the start of the game, each debtor chooses which cell to
start. Then he rolls a die and moves on the ring in clockwise order by cells as many as the number of
spots shown on the upside of the die. This step is called a round, and each debtor repeats a round T times.
A debtor will be exempted from his debt if he is standing on a red cell after he finishes all the rounds.
On the other hand, if he finishes the game at a black cell, he will be sent somewhere else and forced to
devote his entire life to hard labor.
You have happened to take part in this game. As you are allowed to choose the starting cell, you want to
start from a cell that maximizes the probability of finishing the game at a red cell. Fortunately you can
bring a laptop PC to the game stage, so you have decided to write a program that calculates the maximum
winning probability.
Input
The input consists of multiple datasets.
Each dataset consists of two lines. The first line contains two integers N (1 ≤ N ≤ 2000) and T (1 ≤ T ≤ 2000) in this order, delimited with a single space. The second line contains a string of N characters that
consists of characters ‘R’ and ‘B’, which indicate red and black respectively. This string represents the
colors of the cells in clockwise order.
The input is terminated by a line with two zeros. This is not part of any datasets and should not be
processed.
Output
For each dataset, print the maximum probability of finishing the game at a red cell in one line. Your
program may output an arbitrary number of digits after the decimal point, provided that the absolute
error does not exceed 10-8.
Sample Input
6 1
RBRBRB
10 1
RBBBRBBBBB
10 2
RBBBRBBBBB
10 10
RBBBBBBBBB
0 0
Output for the Sample Input
0.50000000
0.33333333
0.22222222
0.10025221

Extracted Specification

Canonicalized Input Description:

An integer N (1 ≤ N ≤ 2000), representing some quantity or size.
An integer T (1 ≤ T ≤ 2000), representing some quantity or size.
A string S of length N, consisting of characters 'R' and 'B' only.

### Example Input:

```
6 1
RBRBRB
```

### Function Signature:
Write a function f(inputs) that takes in a list of tuples as input.
def f(inputs: List[Tuple[int, int, str]]):
    '''
    inputs: a list of tuples, where each tuple contains:
        N: an integer
        T: an integer
        S: a string
    '''

Test Case Generator

Sure! Here is a test case generator for the "Deadly Dice Game" problem:

```python
import random

def tcgen():
    # Randomly generating values for N and T within their given constraints
    N = random.randint(1, 2000)
    T = random.randint(1, 2000)
    
    # Generating a random string of 'R' and 'B' of length N
    cells = ''.join(random.choice(['R', 'B']) for _ in range(N))
    
    return N, T, cells

def main():
    # Generate a number of test cases, for example, 5
    num_test_cases = 5

    for _ in range(num_test_cases):
        N, T, cells = tcgen()
        print(f"{N} {T}")
        print(cells)
    
    # End of input
    print("0 0")

if __name__ == "__main__":
    main()
```

### Explanation:
1. **N and T Randomization:**
   - `N` and `T` are randomly selected between 1 and 2000.

2. **Cells Generation:**
   - The string `cells` is generated randomly, consisting of characters 'R' and 'B' with a length of `N`.

3. **Test Case Format:**
   - Each test case starts with a line containing `N` and `T`.
   - The next line contains the string of cell colors.

4. **Terminating Input:**
   - After generating the required number of test cases, the generator prints `0 0` to indicate the end of input.

This generator produces random valid test cases for the given problem and should help you test your solution comprehensively.

Extract Arguments

def extract_arguments(fh):
    datasets = []
    while True:
        line = fh.readline().strip()
        if line == "0 0":
            break
        N, T = map(int, line.split())
        colors = fh.readline().strip()
        datasets.append((N, T, colors))
    return datasets