Problem p02642 - Generation 2

Orig Description

Score : 400 points
Problem StatementGiven is a number sequence A of length N.
Find the number of integers i \left(1 \leq i \leq N\right) with the following property:
For every integer j \left(1 \leq j \leq N\right) such that i \neq j , A_j does not divide A_i.
Constraints
All values in input are integers.
1 \leq N \leq 2 \times 10^5
1 \leq A_i \leq 10^6
InputInput is given from Standard Input in the following format:
N
A_1 A_2 \cdots A_N
OutputPrint the answer.
Sample Input 15
24 11 8 3 16
Sample Output 13
The integers with the property are 2, 3, and 4.
Sample Input 24
5 5 5 5
Sample Output 20
Note that there can be multiple equal numbers.
Sample Input 310
33 18 45 28 8 19 89 86 2 4
Sample Output 35

Extracted Specification

An integer N (1 ≤ N ≤ 2 × 10^5), representing some quantity or size.
A list of integers A of size N, where each integer is between 1 and 1e6.

### Example Input:

```
5
24 11 8 3 16
```

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

Test Case Generator

Sure, here is a test case generator for the given problem statement:

```python
import random

def tcgen():
    N = random.randint(1, 2 * 10**5)
    
    A = [random.randint(1, 10**6) for _ in range(N)]
    
    return N, A

# Generate a test case and print it in the required format
N, A = tcgen()
print(N)
print(" ".join(map(str, A)))
```

### Explanation of the Test Case Generator

1. **N Generation**: 
    - We generate a random integer \( N \) in the range \([1, 2 \times 10^5]\). This ensures that the size of the array adheres to the problem constraints.

2. **A Generation**:
    - We generate a list \( A \) of size \( N \) with each element being a random integer in the range \([1, 10^6]\). This ensures that each element in the array adheres to the problem constraints.

3. **Output**:
    - The generated test case is printed in the required format: 
        - First, the integer \( N \) is printed.
        - Then, the list \( A \) is printed as space-separated integers.

This generator will help create numerous test cases to validate the solution of the problem.

Extract Arguments

def extract_arguments(fh):
    N = int(fh.readline().strip())
    A = list(map(int, fh.readline().strip().split()))
    return N, A