+ Time Limit: 1 second + Memory Limit: 256 MB ---------- In this problem, you are given two integers $a$ and $b$. Write a program that reads $a$ and $b$ and prints $a + b$. # Input The input consists of a single line containing two integers $a$ and $b$, separated by a space. $$1 \leq a, b \leq 100$$ # Output Print the value of $a + b$ in a single line. # Examples ### Sample Input 1 ``` 3 5 ``` ### Sample Output 1 ``` 8 ``` ### Sample Input 2 ``` 1 1 ``` ### Sample Output 2 ``` 2 ```

+ Time Limit: 1 second + Memory Limit: 256 MB ---------- There's a treasure hidden at some integer point $(a, b)$ such that $0 \leq a \leq n$ and $0 \leq b \leq m$. The Manhattan distance between two points $(s, t)$ and $(u, v)$ is defined as $|s - u| + |t - v|$. We are given two numbers: the Manhattan distance from $(a, b)$ to $(0, 0)$ is $x$, and its distance to $(0, m)$ is $y$. Check whether such a treasure can exist. If no valid treasure exists, print $-1$. It can be proved that if a solution exists, it is unique. # Input The first line of input contains an integer $t$, the number of test cases. $$1 \leq t \leq 10^4$$ Each of the next $t$ lines contains four integers: $n$, $m$, $x$, and $y$. $$1 \leq n, m \leq 10^8$$ $$0 \leq x, y \leq n + m$$ # Output For each test case, print two integers $a$ and $b$, the coordinates of the treasure. If no valid treasure exists, print $-1$. # Subtasks | condition | score | | :---------------------: | :---: | | $n, m, t \leq 100$ | `30` | | No additional condition | `70` | # Examples ### Sample Input 1 ``` 5 100 100 40 80 100 100 40 81 12 65 0 65 1 1 2 1 3 2 5 5 ``` ### Sample Output 1 ``` 10 30 -1 0 0 1 1 -1 ```

+ Time Limit: 1 second + Memory Limit: 256 MB ---------- We ask you a simple question. Count how many integers $a$ exist in the range $[1, n]$ such that the condition $a \,\&\, 2 = 0$ **or** $a \,\&\, 4 = 0$ holds. # Input The first line contains an integer $t$ representing the number of test cases. $$1 \leq t \leq 10^5$$ Each of the next $t$ lines contains a single integer $n$. $$1 \leq n \leq 10^{18}$$ # Output For each test case, print the answer on a separate line. # Subtasks |condition | score | |:---:|:---:| |$n, t \leq 1000$ | `10`| | $n \leq 10^6$ | `40` | | `No additional condition` | `50`| # Example ### Sample Input 1 ``` 7 10 20 3 15 1000 60 16 ``` ### Sample Output 1 ``` 8 16 3 11 750 46 12 ``` From $1$ to $10$, the numbers $1$, $2$, $3$, $4$, $5$, $8$, $9,$ and $10$ satisfy the condition.

+ Time Limit: 1 second + Memory Limit: 256 MB ---------- You are given an array of length $n \geq 2$ like $a_1, a_2, \dots, a_n\,\,$. You may perform each of the following operations any number of times: * Choose an index $i$ $(1 \leq i \leq n - 1)$ and replace $a_i$ with $\lfloor\dfrac{a_i + a_{i+1}}{2}\rfloor\,$. * Choose an index $i$ $(2 \leq i \leq n)$ and replace $a_i$ with $\lfloor\dfrac{a_{i-1} + a_i}{2}\rfloor\,$. Your task is to determine, for each test case, the minimum number of operations required to maximize the sum of the array. # Input The first line contains an integer $t$, the number of test cases. $$1 \le t \le 10^4$$ The first line of each test contains an integer $n$, the length of the array. $$2 \leq n \le 2 \times 10^5$$ The second line contains $n$ integers $a_1, a_2, \dots, a_n\,\,$, the elements of the array. $$1 \leq a_i \leq 10^9$$ It is guaranteed that $\sum n$ over all test cases does not exceed $2 \times 10^5$. # Output For each test case print a single integer, the minimum number of operations required to maximize the total sum of the array. # Examples ### Sample Input 1 ``` 4 2 1 3 5 9 3 4 8 2 3 5 1 7 2 1000 1000 ``` ### Sample Output 1 ``` 1 8 3 0 ```

+ Time Limit: 2 seconds + Memory Limit: 256 MB ---------- You are given an array of $n \geq 3$ integers. You must remove exactly two elements. The *beauty* of the remaining array is defined as the greatest common divisor (GCD) of all its elements. Your task is to maximize this beauty and output its value. # Input The first line contains an integer $t$ the number of test cases. $$1 \leq t \leq 10^4$$ The first line of each test contains an integer $n$ the size of the array. $$3 \leq n \leq 3 \times 10^5$$ The second line contains $n$ integers $a_1, a_2, \dots, a_n\,\,$. $$1 \leq a_i \leq 10^8$$ It is guaranteed that the sum of $n$ over all test cases does not exceed $3 \times 10^5$. # Output For each test case print a single integer, the maximum possible beauty after removing exactly two elements. # Examples ### Sample Input 1 ``` 3 5 21 36 39 12 54 4 30 40 50 60 3 78 97 56 ``` ### Sample Output 1 ``` 6 30 97 ```

+ Time Limit: 2 second + Memory Limit: 256 MB ---------- Iran is a country with $n$ cities, numbered from $1$ to $n$. The population of city $i$ is $w_i$. The cities are connected by $n - 1$ bidirectional roads, forming a tree (so every two cities are connected by exactly one path). An **Adversary** plans to destroy exactly one existing road. The *damage* caused by removing a road is defined as the number of unordered pairs of people who could visit each other before the removal, but become disconnected afterward. The Adversary always chooses the road that maximizes this damage. Before the Adversary acts, a **Defender** may add up to $k$ new roads between pairs of cities that are not already directly connected. The Defender acts optimally to minimize the final damage, while the Adversary acts optimally to maximize it. Your task is to determine, for each test case, the number of disconnected pairs of people after the Adversary removes a road, assuming both players act optimally. # Input The first line contains an integer $t$, the number of test cases. $$1 \leq t \leq 10^4$$ The first line of each test contains two integers $n$ and $k$: the number of cities and the maximum number of roads the Defender may add. $$ 1 \leq n \leq 3 \times 10^5, \quad 0 \leq k \leq 3 \times 10^5$$ The second line of each test contains $n$ integers $w_1, w_2, \dots, w_n\,\,$, the populations of the cities. $$1 \leq w_i \leq 10^4$$ Each of the next $n-1$ lines contains two integers $u, v$, describing a road between cities $u$ and $v$. $$1 \leq u, v \leq n$$ The input graph is guaranteed to be a tree. It is guaranteed that the total $\sum n$ across all test cases does not exceed $3 \times 10^5$. # Output For each test case, print a single integer, the maximum number of disconnected pairs of people after the Adversary removes one road, assuming the Defender adds roads optimally beforehand. # Examples ### Sample Input 1 ``` 3 6 1 1 1 1 1 1 1 1 2 2 3 2 4 4 5 4 6 3 2 7 8 9 1 2 2 3 7 2 10 20 3 15 1000 60 16 1 2 1 3 1 4 3 5 3 6 3 7 ``` ### Sample Output 1 ``` 5 0 16635 ```