Orig Description
Hit and Blow
Let's play Hit and Blow game. A imagines four numbers and B guesses the numbers. After B picks out four numbers, A answers:
The number of numbers which have the same place with numbers A imagined (Hit)
The number of numbers included (but different place) in the numbers A imagined (Blow)
For example, if A imagined numbers:
9 1 8 2
and B chose:
4 1 5 9
A should say 1 Hit and 1 Blow.
Write a program which reads four numbers A imagined and four numbers B chose and prints the number of Hit and Blow respectively. You may assume that the four numbers are all different and within from 0 to 9.
Input
The input consists of multiple datasets. Each dataset set consists of:
a1 a2 a3 a4
b1 b2 b3 b4
, where ai (0 ≤ ai ≤ 9) is i-th number A imagined and bi (0 ≤ bi ≤ 9) is i-th number B chose.
The input ends with EOF. The number of datasets is less than or equal to 50.
Output
For each dataset, print the number of Hit and Blow in a line. These two numbers should be separated by a space.
Sample Input
9 1 8 2
4 1 5 9
4 6 8 2
4 6 3 2
Output for the Sample Input
1 1
3 0
Extracted Specification
An integer sequence of size 4 with each integer between 0 and 9.
Another integer sequence of size 4 with each integer between 0 and 9.
Multiple such datasets. The input ends with EOF. The number of datasets is less than or equal to 50.
### Example Input:
```
9 1 8 2
4 1 5 9
4 6 8 2
4 6 3 2
```
### Function Signature:
Write a function f(inputs) that takes in the input.
def f(inputs: List[Tuple[List[int], List[int]]]):
'''
inputs: a list of tuples where each tuple contains two lists of integers
'''
Test Case Generator
Certainly! Here's a test case generator for the "Hit and Blow" problem:
```python
import random
def generate_unique_numbers():
"""Generate a list of 4 unique numbers between 0 and 9."""
return random.sample(range(10), 4)
def generate_test_case():
"""Generate a single test case for the Hit and Blow problem."""
A = generate_unique_numbers()
B = generate_unique_numbers()
return A, B
def tcgen(num_cases=50):
"""
Generate multiple test cases for the Hit and Blow problem.
Args:
- num_cases (int): The number of test cases to generate. Default is 50.
Returns:
- List of tuples, where each tuple contains two lists (A and B).
"""
test_cases = []
for _ in range(num_cases):
test_cases.append(generate_test_case())
return test_cases
# Example usage:
if __name__ == "__main__":
test_cases = tcgen()
for A, B in test_cases:
print(" ".join(map(str, A)))
print(" ".join(map(str, B)))
```
### Explanation:
1. **`generate_unique_numbers`**: This function generates a list of 4 unique random numbers between 0 and 9 using `random.sample`.
2. **`generate_test_case`**: This function generates a single test case by calling `generate_unique_numbers` twice to get the lists `A` and `B`.
3. **`tcgen`**: This function generates multiple test cases. By default, it generates 50 test cases, but you can specify a different number. It returns a list of tuples where each tuple contains the two lists `A` and `B`.
4. **Example Usage**: The example usage at the bottom demonstrates how to generate the test cases and print them in the required format.
This generator ensures that the numbers in each list are unique and within the range [0, 9]. The `num_cases` parameter allows you to control how many test cases you want to generate.
Extract Arguments
def extract_arguments(fh):
inputs = []
while True:
line_a = fh.readline().strip()
if not line_a:
break
line_b = fh.readline().strip()
a = list(map(int, line_a.split()))
b = list(map(int, line_b.split()))
inputs.append((a, b))
return inputs