Problem p00638 - Generation 2

Orig Description

Problem B: Old Bridges
Long long ago, there was a thief. Looking for treasures, he was running about all over the world. One day, he heard a rumor that there were islands that had large amount of treasures, so he decided to head for there.
Finally he found n islands that had treasures and one island that had nothing. Most of islands had seashore and he can land only on an island which had nothing. He walked around the island and found that there was an old bridge between this island and each of all other n islands.
He tries to visit all islands one by one and pick all the treasures up. Since he is afraid to be stolen, he visits with bringing all treasures that he has picked up. He is a strong man and can bring all the treasures at a time, but the old bridges will break if he cross it with taking certain or more amount of treasures.
Please write a program that judges if he can collect all the treasures and can be back to the island where he land on by properly selecting an order of his visit.
Input
Input consists of several datasets.
The first line of each dataset contains an integer n.
Next n lines represents information of the islands. Each line has two integers, which means the amount of treasures of the island and the maximal amount that he can take when he crosses the bridge to the islands, respectively.
The end of input is represented by a case with n = 0.
Output
For each dataset, if he can collect all the treasures and can be back, print "Yes" Otherwise print "No"
Constraints
1  ≤ n ≤ 25
Sample Input
3
2 3
3 6
1 2
3
2 3
3 5
1 2
0
Output for the Sample Input
Yes
No

Extracted Specification

Canonicalized Input Description:

An integer n (1 ≤ n ≤ 25), representing some quantity or size.  
A list of n tuples, where each tuple contains two integers. The first integer is between 1 and 1e5, and the second integer is between 1 and 1e5.  
The end of input is represented by a case with n = 0.

### Example Input:

```
3
2 3
3 6
1 2
3
2 3
3 5
1 2
0
```

### Function Signature:

Write a function f(inputs) that takes in the input. 

```python
def f(inputs: List[Tuple[int, List[Tuple[int, int]]]]): 
    ''' 
    inputs: a list of tuples, where each tuple contains:
        - an integer 
        - a list of tuples, where each tuple contains two integers 
    '''
```

Test Case Generator

Sure, I can help you write a test case generator for the given problem statement "Old Bridges". To generate test cases, we'll need to consider the constraints and generate random values within those constraints. Here is a Python function that generates random test cases for the problem:

```python
import random

def tcgen():
    datasets = []
    
    while True:
        n = random.randint(1, 25)  # Random value for number of islands (1 ≤ n ≤ 25)
        
        if n == 0:
            break
        
        dataset = []
        for _ in range(n):
            treasures = random.randint(0, 100)  # Assuming a reasonable upper limit for treasures
            max_weight = random.randint(treasures, treasures + 100)  # Max weight should be at least as much as treasures
            
            dataset.append((treasures, max_weight))
        
        datasets.append(dataset)

    return datasets

# Example of how to use the generator and print the datasets
test_cases = tcgen()

for i, dataset in enumerate(test_cases):
    print(f"Dataset {i+1}:")
    print(len(dataset))
    for treasures, max_weight in dataset:
        print(treasures, max_weight)
```

This function generates multiple datasets. Each dataset contains:
1. An integer `n` representing the number of islands.
2. `n` pairs of integers, where each pair represents the amount of treasures on the island and the maximum weight that the bridge to the island can support.

To ensure the function terminates, we simulate the end of input by breaking the loop when `n == 0`. 

You can use this function to generate test cases for your problem. Adjust the ranges of random values for treasures and maximum weights if needed, depending on the specific requirements or constraints of your problem.

Extract Arguments

def extract_arguments(fh):
    datasets = []
    while True:
        n = int(fh.readline().strip())
        if n == 0:
            break
        islands = []
        for _ in range(n):
            treasures, max_weight = map(int, fh.readline().strip().split())
            islands.append((treasures, max_weight))
        datasets.append((n, islands))
    return datasets