Orig Description
Problem E: Mobile Computing
There is a mysterious planet called Yaen, whose space is 2-dimensional. There are many beautiful
stones on the planet, and the Yaen people love to collect them. They bring the stones back home
and make nice mobile arts of them to decorate their 2-dimensional living rooms.
In their 2-dimensional world, a mobile is defined recursively as follows:
a stone hung by a string, or
a rod of length 1 with two sub-mobiles at both ends; the rod
is hung by a string at the center of gravity of sub-mobiles.
When the weights of the sub-mobiles are n and m, and their
distances from the center of gravity are a and b respectively,
the equation n × a = m × b holds.
For example, if you got three stones with weights 1, 1, and 2, here are some possible mobiles
and their widths:
Given the weights of stones and the width of the room, your task is to design the widest possible
mobile satisfying both of the following conditions.
It uses all the stones.
Its width is less than the width of the room.
You should ignore the widths of stones.
In some cases two sub-mobiles hung from both ends of a rod might
overlap (see the figure on the below). Such mobiles are acceptable.
The width of the example is (1/3) + 1 + (1/4).
Input
The first line of the input gives the number of datasets. Then the specified number of datasets
follow. A dataset has the following format.
r
s
w1
.
.
.
ws
r is a decimal fraction representing the width of the room, which satisfies 0 < r < 10. s is the
number of the stones. You may assume 1 ≤ s ≤ 6. wi is the weight of the i-th stone, which is
an integer. You may assume 1 ≤ wi ≤ 1000.
You can assume that no mobiles whose widths are between r - 0.00001 and r + 0.00001 can be made of given stones.
Output
For each dataset in the input, one line containing a decimal fraction should be output. The
decimal fraction should give the width of the widest possible mobile as defined above. An
output line should not contain extra characters such as spaces.
In case there is no mobile which satisfies the requirement, answer -1 instead.
The answer should not have an error greater than 0.00000001. You may output any number of
digits after the decimal point, provided that the above accuracy condition is satisfied.
Sample Input
5
1.3
3
1
2
1
1.4
3
1
2
1
2.0
3
1
2
1
1.59
4
2
1
1
3
1.7143
4
1
2
3
5
Output for the Sample Input
-1
1.3333333333333335
1.6666666666666667
1.5833333333333335
1.7142857142857142
Extracted Specification
An integer D (1 ≤ D ≤ 10), representing the number of datasets. Each dataset consists of:
- A decimal fraction R (0 < R < 10).
- An integer S (1 ≤ S ≤ 6).
- A list of S integers, each between 1 and 1000.
### Example Input:
```
5
1.3
3
1
2
1
1.4
3
1
2
1
2.0
3
1
2
1
1.59
4
2
1
1
3
1.7143
4
1
2
3
5
```
### Function Signature:
Write a function f(inputs) that takes in the input.
def f(inputs: List[Tuple[float, int, List[int]]]):
'''
inputs: a list of tuples, each containing a float, an integer, and a list of integers
'''
Test Case Generator
Sure, I can help you create a test case generator for the given problem statement. Here's the test case generator function for the "Mobile Computing" problem:
```python
import random
def generate_random_weight():
return random.randint(1, 1000)
def generate_random_room_width():
return round(random.uniform(0.00001, 10.0 - 0.00001), 8)
def tcgen():
num_datasets = random.randint(1, 10) # Number of datasets to be generated
datasets = []
for _ in range(num_datasets):
r = generate_random_room_width()
s = random.randint(1, 6) # Number of stones
weights = [generate_random_weight() for _ in range(s)]
datasets.append((r, s, weights))
return datasets
def format_test_case(datasets):
test_case_str = f"{len(datasets)}\n"
for r, s, weights in datasets:
test_case_str += f"{r}\n{s}\n"
test_case_str += "\n".join(map(str, weights)) + "\n"
return test_case_str.strip()
# Generate test cases
datasets = tcgen()
test_case_str = format_test_case(datasets)
print(test_case_str)
```
### Explanation:
1. **`generate_random_weight` Function**: Generates a random weight for a stone between 1 and 1000.
2. **`generate_random_room_width` Function**: Generates a random room width between very close to 0 and just below 10, formatted to 8 decimal places for precision.
3. **`tcgen` Function**:
- Generates a random number of datasets (between 1 and 10 for testing purposes; you can adjust this range as needed).
- For each dataset, it generates:
- `r`: A random room width.
- `s`: A random number of stones (between 1 and 6).
- `weights`: A list of random weights for the stones.
- Appends each dataset to a list of datasets.
4. **`format_test_case` Function**: Formats the generated datasets into a string that matches the input format specified in the problem statement.
### Sample Output:
The `print(test_case_str)` will display the generated test cases in the format expected by the problem statement. Here's an example of what the output might look like:
```
3
5.67890123
4
123
456
789
101
2.34567890
5
234
567
890
123
456
9.87654321
1
999
```
This generator will create varied test cases to help you thoroughly test your solution to the problem.
Extract Arguments
def extract_arguments(fh):
num_datasets = int(fh.readline().strip())
inputs = []
for _ in range(num_datasets):
r = float(fh.readline().strip())
s = int(fh.readline().strip())
w = [int(fh.readline().strip()) for _ in range(s)]
inputs.append((r, s, w))
return inputs
# if __name__ == "__main__":
# input_path = sys.argv[1]
# with open(input_path, 'r') as fh:
# inputs = extract_arguments(fh)
# f(inputs)