Problem p02300 - Generation 2

Orig Description

Convex Hull
Find the convex hull of a given set of points P. In other words, find the smallest convex polygon containing all the points of P. Here, in a convex polygon, all interior angles are less than or equal to 180 degrees.
Please note that you should find all the points of P on both corner and boundary of the convex polygon.
Input
n
x1 y1 
x2 y2
:
xn yn
The first integer n is the number of points in P. The coordinate of the i-th point pi is given by two integers xi and yi. 
Output
In the first line, print the number of points on the corner/boundary of the convex polygon. In the following lines, print x y coordinates of the set of points.
The coordinates should be given in the order of counter-clockwise visit of them starting from the point in P with the minimum y-coordinate, or the leftmost such point in case of a tie.
Constraints
3 ≤ n ≤ 100000
-10000 ≤ xi, yi ≤ 10000
No point in the P will occur more than once.
Sample Input 1
7
2 1
0 0
1 2
2 2
4 2
1 3
3 3
Sample Output 1
5
0 0
2 1
4 2
3 3
1 3
Sample Input 2
4
0 0
2 2
0 2
0 1
Sample Output 2
4
0 0
2 2
0 2
0 1

Extracted Specification

Canonicalized Input Description:

An integer n (3 ≤ n ≤ 100000), representing some quantity or size.
n pairs of integers (xi, yi) where each integer is between -10000 and 10000.

### Example Input:

```
7
2 1
0 0
1 2
2 2
4 2
1 3
3 3
```

### Function Signature:
Write a function f(n, points) that takes in the input.
def f(n: int, points: List[Tuple[int, int]]):
    '''
    n: an integer
    points: a list of tuples of integers
    '''

Test Case Generator

Sure! To generate test cases for the Convex Hull problem, we'll need to produce random sets of points within the given constraints. Here's a Python function to generate such test cases:

```python
import random

def tcgen():
    # Number of points
    n = random.randint(3, 100000)
    
    # Generate a set of unique points within the range [-10000, 10000]
    points = set()
    while len(points) < n:
        x = random.randint(-10000, 10000)
        y = random.randint(-10000, 10000)
        points.add((x, y))
    
    # Convert the set of points to a list to maintain order
    points_list = list(points)
    
    return n, points_list

# Example usage:
n, points = tcgen()
print(n)
for x, y in points:
    print(x, y)
```

### Explanation:

1. **Number of Points**: Randomly select the number of points \( n \) between 3 and 100,000.
2. **Generate Points**: Use a set to ensure all points are unique. Randomly generate \( x \) and \( y \) coordinates within the range [-10,000, 10,000]. Continue adding points to the set until we have \( n \) unique points.
3. **Return Points**: Convert the set to a list for ordered output.

This approach ensures we respect the constraints and provide valid test cases for the Convex Hull problem. 

### Output Format:
- The first line is the number of points \( n \).
- The following \( n \) lines contain the coordinates of each point.

Feel free to run the function and generate test cases for your problem!

Extract Arguments

def extract_arguments(fh):
    n = int(fh.readline().strip())
    points = []
    for _ in range(n):
        x, y = map(int, fh.readline().strip().split())
        points.append((x, y))
    return n, points

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