Orig Description
B: Hierarchical Calculator
Problem
Ebi-chan has N formulae: y = a_i x for i =1, ..., N (inclusive). She wants to find a subsequence of indices s with length k: s_1, s_2, ..., s_k that maximizes the final output of the procedure, x_{s_k}. If there are many candidates, she wants the shortest one. If there are still many candidates, she wants the lexicographically smallest one.
At first, let x_0 be 1 and evaluate s_1-th formula with x = x_0. Next, let x_1 be the output of s_1 and evaluate s_2-th formula with x = x_1, and so on.
Sequence s is lexicographically smaller than sequence t, if and only if either of the following conditions hold:
there exists m < |s| such that s_i = t_i for i in 1 to m (inclusive) and s_{m+1} < t_{m+1}, or
s_i = t_i for i in 1 to |s| (inclusive) and |s| < |t|,
where |s| is the length of the s.
Input
N
a_1 a_2 $\cdots$ a_N
Constraints
1 \leq N \leq 60
-2 \leq a_i \leq 2 for i=1, ...,N (inclusive)
Every input is an integer.
Output
Output k+1 lines. First line, the length of the sequence, k. Following k lines, the index of the i-th element of the subsequence, s_i (one element per line).
Sample Input 1
4
2 0 -2 1
Sample Output for Input 1
1
1
Ebi-chan evaluates the first formula and gets the maximum value 2.
Sample Input 2
3
2 -2 -2
Sample Output for Input 2
3
1
2
3
Ebi-chan evaluates all the formulas and gets the maximum value 8.
Sample Input 3
2
-1 0
Sample Output for Input 3
0
Ebi-chan evaluates none of the formulas and gets the maximum value 0. The empty sequence is shorter and lexicographically smaller than any other sequences.
Sample Input 4
5
-1 2 1 -2 -1
Sample Output for Input 4
3
1
2
4
Ebi-chan evaluates $\langle$ 1, 2, 4 $\rangle$ and gets the maximum value 4. Note that $\langle$ 2, 4, 5 $\rangle$ is not lexicographically smallest one.
Extracted Specification
An integer N (1 ≤ N ≤ 60), representing some quantity or size.
A list of N integers, where each integer is between -2 and 2 (inclusive).
### Example Input:
```
4
2 0 -2 1
```
### 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
To generate test cases for the problem "Hierarchical Calculator", we need to consider the constraints and the nature of the problem. We will generate a random number of formulae \( N \) and their corresponding coefficients \( a_i \). Here is the test case generator:
```python
import random
def tcgen():
# Generate a random number of formulae N
N = random.randint(1, 60)
# Generate the coefficients a_i in the range [-2, 2]
A = [random.randint(-2, 2) for _ in range(N)]
return N, A
# Example usage:
if __name__ == "__main__":
N, A = tcgen()
print(N)
print(' '.join(map(str, A)))
```
### Explanation:
1. **N**: The number of formulae - randomly generated between 1 and 60, inclusive.
2. **A**: The list of coefficients, where each coefficient \( a_i \) is randomly chosen from the set \([-2, -1, 0, 1, 2]\).
### Example Output:
Running the `tcgen` function might output something like this:
```
5
2 -1 0 0 1
```
This output represents:
- \( N = 5 \) which means there are 5 formulae.
- The coefficients of the formulae are \( [2, -1, 0, 0, 1] \).
You can run the test case generator multiple times to get different test cases for your problem. These random test cases will help in thoroughly testing your solution to ensure it handles all edge cases correctly.
Extract Arguments
def extract_arguments(fh):
N = int(fh.readline().strip())
A = list(map(int, fh.readline().strip().split()))
return N, A