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
An integer N (1 ≤ N ≤ 100,000), representing some quantity or size.
A list of tuples of size N, where each tuple contains two integers. The first integer is between 0 and 10^9, and the second integer is between 1 and 10^9.
### Example Input:
```
4
2 4
4 3
9 3
100 5
```
### Function Signature:
Write a function f(N, inputs) that takes in the input.
def f(N: int, inputs: List[Tuple[int, int]]):
'''
N: an integer
inputs: a list of tuples containing pairs of integers
'''
Test Case Generator
Sure, I can help you generate test cases for the given problem statement. Below is a Python function to generate random test cases:
```python
import random
def tcgen():
N = random.randint(1, 100000)
X = set()
while len(X) < N:
X.add(random.randint(0, 10**9))
X = list(X)
robots = [(x, random.randint(1, 10**9)) for x in X]
return N, robots
def format_test_case(N, robots):
test_case = f"{N}\n"
for x, l in robots:
test_case += f"{x} {l}\n"
return test_case.strip()
# Example usage:
N, robots = tcgen()
print(format_test_case(N, robots))
```
This function generates random test cases within the given constraints:
1. `N` is chosen randomly between 1 and 100,000.
2. Each `X_i` is a unique integer between 0 and 10^9.
3. Each `L_i` is an integer between 1 and 10^9.
The `format_test_case` function formats the generated test case for easy reading and use.
You can call `tcgen` to generate a random test case and then use `format_test_case` to print it in the required format. Here's an example of how to call and print a generated test case:
```python
N, robots = tcgen()
print(format_test_case(N, robots))
```
This will output a randomly generated test case in the proper format used for competitive programming problems.
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