Problem p00773 - Generation 1

Orig Description

Tax Rate Changed
    VAT (value-added tax) is a tax imposed at a certain rate proportional to the sale price.
  
    Our store uses the following rules to calculate the after-tax prices.
    
	When the VAT rate is x%,
	for an item with the before-tax price of p yen,
	its after-tax price of the item is p (100+x) / 100 yen, fractions rounded off.
      
	The total after-tax price of multiple items paid at once is
	the sum of after-tax prices of the items.
      
    The VAT rate is changed quite often.
    Our accountant has become aware that
    "different pairs of items that had the same total after-tax price
    may have different total after-tax prices after VAT rate changes."
    For example, when the VAT rate rises from 5% to 8%,
    a pair of items that had the total after-tax prices of 105 yen before
    can now have after-tax prices either of 107, 108, or 109 yen, as shown in the table below.
  
Before-tax prices of two itemsAfter-tax price with 5% VATAfter-tax price with 8% VAT
20, 8021 + 84 = 10521 + 86 = 107
2, 992 + 103 = 1052 + 106 = 108
13, 8813 + 92 = 10514 + 95 = 109
    Our accountant is examining effects of VAT-rate changes on after-tax prices.
    You are asked to write a program that calculates the possible maximum
    total after-tax price of two items with the new VAT rate,
    knowing their total after-tax price before the VAT rate change.
  
Input
    The input consists of multiple datasets.
    Each dataset is in one line,
    which consists of three integers x, y, and s separated by a space.
    x is the VAT rate in percent before the VAT-rate change,
    y is the VAT rate in percent after the VAT-rate change,
    and s is the sum of after-tax prices of two items before the VAT-rate change.
    For these integers, 0 < x < 100, 0 < y < 100,
    10 < s < 1000, and x ≠ y hold.
    For before-tax prices of items, all possibilities of 1 yen through s-1 yen should be considered.
  
    The end of the input is specified by three zeros separated by a space.
  
Output
    For each dataset,
    output in a line the possible maximum total after-tax price when the VAT rate is changed to y%.
  
Sample Input
5 8 105
8 5 105
1 2 24
99 98 24
12 13 26
1 22 23
1 13 201
13 16 112
2 24 50
1 82 61
1 84 125
1 99 999
99 1 999
98 99 999
1 99 11
99 1 12
0 0 0
Output for the Sample Input
109
103
24
24
26
27
225
116
62
111
230
1972
508
1004
20
7
Hints
    In the following table,
    an instance of a before-tax price pair that has the maximum after-tax price after the VAT-rate change
    is given for each dataset of the sample input.
  
DatasetBefore-tax pricesAfter-tax price with y% VAT
5 8 105  13, 88 14 + 95 = 109
8 5 105  12, 87 12 + 91 = 103
1 2 24   1, 23  1 + 23 =  24
99 98 24   1, 12  1 + 23 =  24
12 13 26   1, 23  1 + 25 =  26
1 22 23   1, 22  1 + 26 =  27
1 13 201   1,199  1 +224 = 225
13 16 112 25, 75 29 + 87 = 116
2 24 50  25, 25 31 + 31 =  62
1 82 61  11, 50 20 + 91 = 111
1 84 125  50, 75 92 +138 = 230
1 99 999  92,899183+1789 =1972
99 1 999   1,502  1 +507 = 508
98 99 999  5,500  9 +995 =1004
1 99 11   1, 10  1 + 19 =  20
99 1 12   1,  6  1 +  6 =   7

Extracted Specification

An integer x (0 < x < 100), representing some percentage rate before a change.
An integer y (0 < y < 100), representing some percentage rate after a change.
An integer s (10 < s < 1000), representing some total amount before the change.
The end of the input is specified by three zeros separated by a space.

### Example Input:

```
5 8 105
8 5 105
1 2 24
0 0 0
```

### Function Signature:
Write a function f(inputs) that takes in the input as a list of tuples.
def f(inputs: List[Tuple[int, int, int]]):
    '''
    inputs: a list of tuples where each tuple contains three integers
    '''

Test Case Generator

Certainly! Here is a test case generator for the "Tax Rate Changed" problem:

```python
import random

def tcgen():
    while True:
        x = random.randint(1, 99)
        y = random.randint(1, 99)
        s = random.randint(11, 999)
        
        # Ensure x ≠ y
        if x != y:
            return x, y, s

def generate_test_cases(num_cases):
    test_cases = []
    for _ in range(num_cases):
        test_cases.append(tcgen())
    return test_cases

# Example of generating 10 test cases
test_cases = generate_test_cases(10)
for case in test_cases:
    print(case)
```

### Explanation:
1. **`tcgen()` Function**: This function generates a single test case.
   - It randomly selects integers `x` and `y` between 1 and 99 (inclusive).
   - It ensures that `x` is not equal to `y`.
   - It randomly selects an integer `s` between 11 and 999 (inclusive).

2. **`generate_test_cases(num_cases)` Function**: This function generates a specified number of test cases.
   - It calls `tcgen()` repeatedly to generate the desired number of test cases.
   - It stores each generated test case in a list and returns the list.

3. **Example Usage**: The example at the end generates 10 test cases and prints them.

### Sample Output:
```
(15, 31, 432)
(10, 52, 221)
(45, 23, 987)
(1, 99, 123)
(34, 67, 456)
(12, 89, 789)
(56, 45, 321)
(78, 34, 678)
(23, 11, 234)
(2, 98, 876)
```

These functions ensure that the generated test cases adhere to the constraints specified in the problem statement, including the requirement that `x` and `y` are different. Adjust the `num_cases` parameter to generate the desired number of test cases.

Extract Arguments

def extract_arguments(fh):
    inputs = []
    while True:
        line = fh.readline().strip()
        if line == "0 0 0":
            break
        x, y, s = map(int, line.split())
        inputs.append((x, y, s))
    return inputs

# if __name__ == "__main__":
#     input_path = sys.argv[1]
#     with open(input_path, 'r') as fh:
#         inputs = extract_arguments(fh)
#         f(inputs)