Problem p03651 - Generation 2

Orig Description

Score : 300 points
Problem StatementThere is a box containing N balls. The i-th ball has the integer A_i written on it.
Snuke can perform the following operation any number of times:
Take out two balls from the box. Then, return them to the box along with a new ball, on which the absolute difference of the integers written on the two balls is written.
Determine whether it is possible for Snuke to reach the state where the box contains a ball on which the integer K is written.
Constraints
1 \leq N \leq 10^5
1 \leq A_i \leq 10^9
1 \leq K \leq 10^9
All input values are integers.
InputInput is given from Standard Input in the following format:
N K
A_1 A_2 ... A_N
OutputIf it is possible for Snuke to reach the state where the box contains a ball on which the integer K is written, print POSSIBLE; if it is not possible, print IMPOSSIBLE.
Sample Input 13 7
9 3 4
Sample Output 1POSSIBLE
First, take out the two balls 9 and 4, and return them back along with a new ball, abs(9-4)=5.
Next, take out 3 and 5, and return them back along with abs(3-5)=2.
Finally, take out 9 and 2, and return them back along with abs(9-2)=7.
Now we have 7 in the box, and the answer is therefore POSSIBLE.
Sample Input 23 5
6 9 3
Sample Output 2IMPOSSIBLE
No matter what we do, it is not possible to have 5 in the box. The answer is therefore IMPOSSIBLE.
Sample Input 34 11
11 3 7 15
Sample Output 3POSSIBLE
The box already contains 11 before we do anything. The answer is therefore POSSIBLE.
Sample Input 45 12
10 2 8 6 4
Sample Output 4IMPOSSIBLE

Extracted Specification

Canonicalized Input Description:

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

### Example Input:

```
3 7
9 3 4
```

### Function Signature:

Write a function f(N, K, A) that takes in the input.

```python
def f(N: int, K: int, A: List[int]):
    '''
    N: an integer
    K: an integer
    A: a list of integers
    '''
```

Test Case Generator

To write a test case generator for the problem statement provided, we need to create random test cases that adhere to the given constraints. Here is a Python function that generates such test cases:

```python
import random

def tcgen():
    # Generate a random value for N within the constraints
    N = random.randint(1, 10**5)
    
    # Generate a list A of size N with random integers between 1 and 10^9
    A = [random.randint(1, 10**9) for _ in range(N)]
    
    # Generate a random value for K within the constraints
    K = random.randint(1, 10**9)
    
    return N, K, A

# Example usage:
N, K, A = tcgen()
print(N)
print(K)
print(" ".join(map(str, A)))
```

### Explanation:

1. **N Generation**: 
   - `N` is generated randomly between 1 and \(10^5\).

2. **A Generation**:
   - List `A` is created with `N` integers.
   - Each integer in `A` is randomly chosen between 1 and \(10^9\).

3. **K Generation**:
   - `K` is a random integer between 1 and \(10^9\).

### Example Output:

If you run the `tcgen()` function, it will generate a random test case. For instance:

```python
N, K, A = tcgen()
print(N)
print(K)
print(" ".join(map(str, A)))
```

This might produce the following output:

```
5
375987632
827364827 172837465 283746528 827364839 192837465
```

This test case can be directly used for input to the problem. The function ensures that all constraints are respected and provides diverse test cases for thorough testing of the solution algorithm.

Extract Arguments

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