Problem p00732 - Generation 1

Orig Description

Problem E: Twirl Around
Let's think about a bar rotating clockwise as if it were a
twirling baton moving on a planar surface surrounded by a
polygonal wall (see Figure 1).
Figure 1.  A bar rotating in a polygon
Initially, an end of the bar (called "end A") is at (0,0), and
the other end (called "end B") is at (0,L) where L is the
length of the bar.  Initially, the bar is touching the wall only
at the end A.
The bar turns fixing a touching point as the center.
The center changes as a new point touches the wall.
Your task is to calculate the coordinates of the end A when the
bar has fully turned by the given count R.
Figure 2.  Examples of turning bars
In Figure 2, some examples are shown.  In cases (D) and
(E), the bar is stuck prematurely (cannot rotate clockwise anymore 
with any point touching the wall as the center)
before R rotations.  In such cases, you should answer the
coordinates of the end A in that (stuck) position.
You can assume the following:
When the bar's length L changes by ε (|ε| <
0.00001), the final (x,y) coordinates
will not change more than 0.0005.
Input
The input consists of multiple datasets.  The number of
datasets is no more than 100.  The end of the input is represented
by "0 0 0".
The format of each dataset is as follows:
L R N
X1 Y1
X2 Y2
...
XN YN
L is the length of the bar.
The bar rotates 2π× R radians (if it is not
stuck prematurely).
N is the number of vertices which make the polygon.
The vertices of the polygon are arranged in a counter-clockwise order.
You may assume that the polygon is simple, that is,
its border never crosses or touches itself.
N, Xi and Yi are
integer numbers; R and L are decimal fractions.
Ranges of those values are as follows:
1.0 ≤ L ≤ 500.0,
1.0 ≤ R ≤ 10.0,
3 ≤ N ≤ 100,
-1000 ≤ Xi ≤ 1000,
-1000 ≤ Yi ≤ 1000,
X1 ≤ -1,  Y1 = 0,
X2 ≥ 1,  Y2 = 0.
Output
For each dataset, print one line containing x- and
y-coordinates of the final position of the end A,
separated by a space.
The value may contain an error less than or equal to 0.001.
You may print any number of digits after the decimal point.
Sample Input
4.0 2.0 8
-1 0
5 0
5 -2
7 -2
7 0
18 0
18 6
-1 6
4.0 2.0 4
-1 0
10 0
10 12
-1 12
4.0 1.0 7
-1 0
2 0
-1 -3
-1 -8
6 -8
6 6
-1 6
4.0 2.0 6
-1 0
10 0
10 3
7 3
7 5
-1 5
5.0 2.0 6
-1 0
2 0
2 -4
6 -4
6 6
-1 6
6.0 1.0 8
-1 0
8 0
7 2
9 2
8 4
11 4
11 12
-1 12
0 0 0
Output for the Sample Input
16.0 0.0
9.999999999999998 7.4641016151377535
0.585786437626906 -5.414213562373095
8.0 0.0
6.0 0.0
9.52786404500042 4.0
Note that the above sample input corresponds to the
cases in Figure 2.  For convenience, in Figure 3, we will show an
animation and corresponding photographic playback for the case (C).
Figure 3.  Animation and photographic playback for case (C)

Extracted Specification

An integer L (1.0 ≤ L ≤ 500.0), a decimal fraction representing some quantity.
An integer R (1.0 ≤ R ≤ 10.0), a decimal fraction representing some count.
An integer N (3 ≤ N ≤ 100), representing some quantity or size.
A list of tuples (X, Y) of size N, where each integer X and Y is between -1000 and 1000.

### Example Input:

```
4.0 2.0 8
-1 0
5 0
5 -2
7 -2
7 0
18 0
18 6
-1 6
```

### Function Signature:
Write a function f(inputs) that takes in the input.
```python
def f(inputs: List[Tuple[float, float, int, List[Tuple[int, int]]]]):
    '''
    inputs: a list of tuples
    '''
```

Test Case Generator

Certainly! Below is a test case generator for the described problem "Twirl Around":

```python
import random

def generate_polygon(n):
    """Generates a simple polygon with `n` vertices in counter-clockwise order."""
    points = []
    # Start with the first point per the given constraints
    points.append((-1, 0))
    # Ensure subsequent points are unique and adhere to the problem's constraints
    for i in range(1, n):
        while True:
            x = random.randint(-1000, 1000)
            y = random.randint(-1000, 1000)
            if (x, y) != points[-1] and (i != 1 or x >= 1):  # Ensure X2 >= 1, Y2 = 0 for second point
                points.append((x, y))
                break
    return points

def tcgen():
    datasets = []
    
    num_datasets = random.randint(1, 100)
    for _ in range(num_datasets):
        L = round(random.uniform(1.0, 500.0), 4)
        R = round(random.uniform(1.0, 10.0), 4)
        N = random.randint(3, 100)
        
        polygon = generate_polygon(N)
        
        dataset = f"{L} {R} {N}\n"
        dataset += "\n".join(f"{x} {y}" for x, y in polygon)
        datasets.append(dataset)
    
    # Add the terminating line
    datasets.append("0 0 0")
    
    return "\n".join(datasets)

# Example usage:
print(tcgen())
```

### Explanation:
- **generate_polygon(n)**: This helper function generates a simple polygon with `n` vertices, ensuring that the vertices are arranged in a counter-clockwise order and adhere to the given constraints.
- **tcgen()**:
  - Randomly decides the number of datasets to generate, constrained to be between 1 and 100.
  - For each dataset:
    - Generates a random bar length \(L\) and rotation count \(R\) within the specified ranges.
    - Generates a random number of vertices \(N\).
    - Uses **generate_polygon(n)** to generate the vertices of the polygon.
    - Constructs the dataset string in the specified format.
  - Adds the terminating line "0 0 0" at the end.
- The return value of **tcgen()** is a string that represents the entire input for the problem, which can be directly used in tests.

This should cover a wide range of possible inputs for the problem, ensuring thorough testing.

Extract Arguments

def extract_arguments(fh):
    datasets = []
    while True:
        line = fh.readline().strip()
        if line == "0 0 0":
            break
        L, R, N = map(float, line.split())
        N = int(N)
        polygon = []
        for _ in range(N):
            x, y = map(int, fh.readline().strip().split())
            polygon.append((x, y))
        datasets.append((L, R, N, polygon))
    return datasets

# Example usage:
# with open("input.txt", 'r') as fh:
#     data = extract_arguments(fh)
#     for dataset in data:
#         L, R, N, polygon = dataset
#         print(f"L: {L}, R: {R}, N: {N}, polygon: {polygon}")