Problem p00026 - Generation 1

Orig Description

Dropping Ink
As shown in the following figure, there is a paper consisting of a grid structure where each cell is indicated by (x, y) coordinate system.
We are going to put drops of ink on the paper. A drop comes in three different sizes: Large, Medium, and Small. From the point of fall, the ink sinks into surrounding cells as shown in the figure depending on its size. In the figure, a star denotes the point of fall and a circle denotes the surrounding cells.
Originally, the paper is white that means for each cell the value of density is 0. The value of density is increased by 1 when the ink sinks into the corresponding cells.
For example, if we put a drop of Small ink at (1, 2) and a drop of Medium ink at (3, 2), the ink will sink as shown in the following figure (left side):
In the figure, density values of empty cells are 0. The ink sinking into out of the paper should be ignored as shown in the figure (top side). We can put several drops of ink at the same point.
Your task is to write a program which reads a sequence of points of fall (x, y) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of cells whose density value is 0. The program must also print the maximum value of density.
You may assume that the paper always consists of 10 × 10, and 0 ≤ x < 10, 0 ≤ y < 10.
Input
x1,y1,s1
x2,y2,s2
  :
  :
(xi, yi) represents the position of the i-th drop and si denotes its size. The number of drops is less than or equal to 50.
Output
Print the number of cells whose density value is 0 in first line.
Print the maximum value of density in the second line.
Sample Input
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
Output for the Sample Input
77
5

Extracted Specification

An integer T (1 ≤ T ≤ 50), representing the number of tuples.
A list of tuples (xi, yi, si) of size T, where each tuple consists of:
- xi (0 ≤ xi < 10), an integer.
- yi (0 ≤ yi < 10), an integer.
- si, an integer from the set {1, 2, 3}.

### Example Input:

```
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
```

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

Test Case Generator

Certainly! To generate test cases for the "Dropping Ink" problem, we need to consider the grid size, the number of drops, and the impact of each drop based on its size. Here's a test case generator for the problem:

```python
import random

def tcgen():
    # Grid size is fixed at 10x10
    grid_size = 10
    
    # Number of drops is between 1 and 50
    num_drops = random.randint(1, 50)
    
    drops = []
    
    for _ in range(num_drops):
        # Random coordinates within the grid
        x = random.randint(0, grid_size - 1)
        y = random.randint(0, grid_size - 1)
        # Random size of the drop (Small = 1, Medium = 2, Large = 3)
        size = random.randint(1, 3)
        drops.append((x, y, size))
    
    return drops

# Function to print the generated test case in the required format
def print_test_case(drops):
    for drop in drops:
        print(f"{drop[0]},{drop[1]},{drop[2]}")

# Generate and print a test case
test_case = tcgen()
print_test_case(test_case)
```

### Explanation
1. **Grid Size**: The grid size is fixed at 10x10.
2. **Number of Drops**: A random number between 1 and 50 is chosen for the number of ink drops.
3. **Drop Properties**: Each drop has random coordinates within the grid (0 ≤ x < 10, 0 ≤ y < 10) and a random size (1 for Small, 2 for Medium, 3 for Large).

### Example Output
When you run the test case generator, it will print the test cases in the format specified by the problem statement. For instance:

```
2,5,3
3,6,1
3,4,2
4,5,2
3,6,3
2,4,1
```

You can run this script multiple times to generate different sets of test cases.

Extract Arguments

def extract_arguments(fh):
    inputs = []
    for line in fh:
        x, y, s = map(int, line.strip().split(','))
        inputs.append((x, y, s))
    return inputs