Problem p02796 - Generation 1

Orig Description

Score : 200 points
Problem StatementIn a factory, there are N robots placed on a number line.
Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect.
Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
1 \leq N \leq 100,000
0 \leq X_i \leq 10^9 (1 \leq i \leq N)
1 \leq L_i \leq 10^9 (1 \leq i \leq N)
If i \neq j, X_i \neq X_j.
All values in input are integers.
InputInput is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
OutputPrint the maximum number of robots that we can keep.
Sample Input 14
2 4
4 3
9 3
100 5
Sample Output 13
By removing Robot 2, we can keep the other three robots.
Sample Input 22
8 20
1 10
Sample Output 21
Sample Input 35
10 1
2 1
4 1
6 1
8 1
Sample Output 35

Extracted Specification

Canonicalized Input Description:

An integer N (1 ≤ N ≤ 100,000), representing some quantity or size.
A list of N tuples (X_i, L_i), where each X_i (0 ≤ X_i ≤ 10^9) and each L_i (1 ≤ L_i ≤ 10^9).

### Example Input:

```
4
2 4
4 3
9 3
100 5
```

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

Test Case Generator

Here's a test case generator for the given problem statement:

```python
import random

def tcgen():
    # Generate a random integer N (1 ≤ N ≤ 100,000)
    N = random.randint(1, 100000)
    
    # Generate N unique X_i (0 ≤ X_i ≤ 10^9)
    X = random.sample(range(0, 10**9+1), N)
    
    # Generate N random L_i (1 ≤ L_i ≤ 10^9)
    L = [random.randint(1, 10**9) for _ in range(N)]
    
    # Combine X and L into a list of tuples for easy parsing
    robots = list(zip(X, L))
    
    return N, robots

# Function to print the test case in the required format
def print_test_case():
    N, robots = tcgen()
    print(N)
    for x, l in robots:
        print(f"{x} {l}")

# Example usage
if __name__ == "__main__":
    print_test_case()
```

### Explanation:
1. **N Generation**: Generates a random integer `N` which signifies the number of robots. The value of `N` is between 1 and 100,000.
2. **X_i Generation**: Generates `N` unique random integers for the positions of the robots. Each `X_i` is between 0 and 10^9.
3. **L_i Generation**: Generates `N` random integers for the arm lengths of the robots. Each `L_i` is between 1 and 10^9.
4. **Combining X and L**: Combines the X and L values into a list of tuples for easier handling.
5. **Printing the Test Case**: The `print_test_case` function prints the generated test case in the required format.

This generator provides a variety of test cases with different distributions of robot positions and arm lengths, ensuring that the solution is well-tested for all possible scenarios.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    robots = []
    for _ in range(N):
        X, L = map(int, fh.readline().strip().split())
        robots.append((X, L))
    return N, robots

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