task_type
stringclasses 1
value | problem
stringlengths 209
3.39k
| answer
stringlengths 35
6.15k
| problem_tokens
int64 60
774
| answer_tokens
int64 12
2.04k
|
|---|---|---|---|---|
coding
|
Solve the programming task below in a Python markdown code block.
This time your assignment is really simple.
Calculate GCD(1, 1) * GCD(1, 2) * ... * GCD(1, M) * GCD(2, 1) * GCD(2, 2) * ... * GCD(2, M) * ... * GCD(N, 1) * GCD(N, 2) * ... * GCD(N, M).
where GCD is defined as the Greatest Common Divisor.
Input Format
The first and only line contains two space separated integers N and M.
Output Format
Output the required product modulo 10^{9}+7.
Constraints
1 <= N, M <= 1.5 * 10^{7}
Sample input:
4 4
Sample output:
96
Explanation
For the above testcase, N = 4, M = 4. So,
GCD(1, 1) * GCD(1, 2) * ...... * GCD(4, 4) = 1 * 1 * 1 * 1 * 1 * 2 * 1 * 2 * 1 * 1 * 3 * 1 * 1 * 2 * 1 * 4 = 96.
|
{"inputs": ["4 4\n"], "outputs": ["96\n"]}
| 284
| 17
|
coding
|
Solve the programming task below in a Python markdown code block.
You are teaching a class of $N$ students. Today, during the morning prayer, all the students are standing in a line. You are given a string $s$ with length $N$; for each valid $i$, the $i$-th character of this string is 'b' if the $i$-th student in the line is a boy or 'g' if this student is a girl.
The awkwardness of this configuration of students is defined as the sum of pairwise distances between each boy and girl. The distance between the $i$-th and $j$-th student in the line is $|i - j|$. Formally, the awkwardness is ∑i=1N∑j=i+1sj≠siN(j−i).∑i=1N∑j=i+1sj≠siN(j−i).\sum\limits_{i=1}^N \, \sum\limits_{j=i+1\\ s_j \neq s_i}^N (j - i)\,.
As the teacher, it is your responsibility to reorder the students in such a way that the awkwardness of the resulting configuration is the smallest possible. You may reorder the students in the line in any way you want. Find the minimum awkwardness that can be achieved.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single string $s$.
-----Output-----
For each test case, print a single line containing one integer - the minimum possible awkwardness.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le |s| \le 10^5$
- each character of $s$ is either 'b' or 'g'
- the sum of $|s|$ over all test cases does not exceed $4 \cdot 10^6$
-----Example Input-----
3
gb
bgg
bbgg
-----Example Output-----
1
2
6
-----Explanation-----
Example case 1: The total awkwardness is $|1 - 0| = 1$, no matter how you arrange the students.
Example case 2: Initially, the awkwardness is $|1 - 0| + |2 - 0| = 1 + 2 = 3$. However, you can move the boy between the two girls, i.e. choose the configuration "gbg". Here, the awkwardness is $|1 - 0| + |2 - 1| = 1 + 1 = 2$.
|
{"inputs": ["3\ngb\nbgg\nbbgg"], "outputs": ["1\n2\n6"]}
| 576
| 25
|
coding
|
Solve the programming task below in a Python markdown code block.
Given is a sequence of N digits a_1a_2\ldots a_N, where each element is 1, 2, or 3. Let x_{i,j} defined as follows:
* x_{1,j} := a_j \quad (1 \leq j \leq N)
* x_{i,j} := | x_{i-1,j} - x_{i-1,j+1} | \quad (2 \leq i \leq N and 1 \leq j \leq N+1-i)
Find x_{N,1}.
Constraints
* 2 \leq N \leq 10^6
* a_i = 1,2,3 (1 \leq i \leq N)
Input
Input is given from Standard Input in the following format:
N
a_1a_2\ldotsa_N
Output
Print x_{N,1}.
Examples
Input
4
1231
Output
1
Input
10
2311312312
Output
0
|
{"inputs": ["4\n21", "4\n32", "4\n13", "4\n21", "4\n44", "4\n12", "4\n11", "4\n22"], "outputs": ["1\n", "1\n", "2\n", "1\n", "0\n", "1\n", "0\n", "0\n"]}
| 249
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
Little penguin Polo adores integer segments, that is, pairs of integers [l; r] (l ≤ r).
He has a set that consists of n integer segments: [l_1; r_1], [l_2; r_2], ..., [l_{n}; r_{n}]. We know that no two segments of this set intersect. In one move Polo can either widen any segment of the set 1 unit to the left or 1 unit to the right, that is transform [l; r] to either segment [l - 1; r], or to segment [l; r + 1].
The value of a set of segments that consists of n segments [l_1; r_1], [l_2; r_2], ..., [l_{n}; r_{n}] is the number of integers x, such that there is integer j, for which the following inequality holds, l_{j} ≤ x ≤ r_{j}.
Find the minimum number of moves needed to make the value of the set of Polo's segments divisible by k.
-----Input-----
The first line contains two integers n and k (1 ≤ n, k ≤ 10^5). Each of the following n lines contain a segment as a pair of integers l_{i} and r_{i} ( - 10^5 ≤ l_{i} ≤ r_{i} ≤ 10^5), separated by a space.
It is guaranteed that no two segments intersect. In other words, for any two integers i, j (1 ≤ i < j ≤ n) the following inequality holds, min(r_{i}, r_{j}) < max(l_{i}, l_{j}).
-----Output-----
In a single line print a single integer — the answer to the problem.
-----Examples-----
Input
2 3
1 2
3 4
Output
2
Input
3 7
1 2
3 3
4 7
Output
0
|
{"inputs": ["1 7\n0 0\n", "1 7\n0 0\n", "1 1\n0 0\n", "1 2\n0 0\n", "2 3\n1 2\n3 4\n", "2 1\n1 2\n3 4\n", "2 3\n1 2\n3 7\n", "2 2\n1 2\n3 4\n"], "outputs": ["6\n", "6\n", "0\n", "1\n", "2\n", "0\n", "2\n", "0\n"]}
| 442
| 134
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
We have an array of integers, nums, and an array of requests where requests[i] = [starti, endi]. The ith request asks for the sum of nums[starti] + nums[starti + 1] + ... + nums[endi - 1] + nums[endi]. Both starti and endi are 0-indexed.
Return the maximum total sum of all requests among all permutations of nums.
Since the answer may be too large, return it modulo 109 + 7.
Please complete the following python code precisely:
```python
class Solution:
def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,2,3,4,5], requests = [[1,3],[0,1]]) == 19\n assert candidate(nums = [1,2,3,4,5,6], requests = [[0,1]]) == 11\n assert candidate(nums = [1,2,3,4,5,10], requests = [[0,2],[1,3],[1,1]]) == 47\n\n\ncheck(Solution().maxSumRangeQuery)"}
| 162
| 122
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Russian]
Chef is having a candlelit dinner with his girlfriend at his place. Currently, it is time $0$, Chef just managed to light a candle, but he is out of matchsticks.
Since Chef has an infinite supply of (unlit) candles, he can use the following strategy: each second (starting at time $0$), he takes one lit candle and lights up $X$ other candles using it. This process takes $1$ unit of time to complete, i.e. if Chef starts lighting up $X$ candles at a time $t_{1}$, he is able to finish at the time $t_{1} + 1$.
However, since candle wax is limited, a candle can only burn for $Y$ units of time and then it is extinguished.
Chef's girlfriend arrives at a time $A$ — specifically, after all the candles that were supposed to get extinguished at time $A$ have been extinguished and after Chef lights up all the candles that he was lighting up since time $A-1$. Now Chef wants to know the maximum number of candles which can be lit at the time $A$ to impress his girlfriend.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $A$, $Y$ and $X$.
------ Output ------
For each test case, print a single line containing one integer — the maximum number of lit candles Chef can impress his girlfriend with.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ A, Y, X ≤ 10^{9}$
------ Subtasks ------
Subtask #1 (40 points): $A ≥ Y$
Subtask #2 (60 points): original constraints
----- Sample Input 1 ------
3
1 1 1
1 2 1
2 2 1
----- Sample Output 1 ------
1
2
2
----- explanation 1 ------
Example case 1: At the time $0$, there is one lit candle, using which we light $1$ more candle. At the time $1$, the starting candle gets extinguished and the candle which we started lighting up at the time $0$ is lit, so we have only $1$ candle lit up when Chef's girlfriend arrives.
Example case 2: At the time $0$, there is one lit candle, using which we light $1$ more candle. At the time $1$, the candle which we started lighting up at the time $0$ and the starting candle are both lit.
Example case 3: At the time $0$, there is one lit candle, using which we light $1$ more candle. At the time $1$, the candle which we started lighting up at time $0$ is lit, and we start lighting up one more candle. At the time $2$, the starting candle gets extinguished and the candle which we started lighting up at the time $1$ is lit. In total, we have $2$ lit candles when Chef's girlfriend arrives.
|
{"inputs": ["3\n1 1 1\n1 2 1\n2 2 1"], "outputs": ["1\n2\n2"]}
| 691
| 34
|
coding
|
Solve the programming task below in a Python markdown code block.
One popular blog site edits the uploaded photos like this. It cuts a rectangular area out of them so that the ratio of height to width (i.e. the height / width quotient) can vary from 0.8 to 1.25 inclusively. Besides, at least one side of the cut area should have a size, equal to some power of number 2 (2x for some integer x). If those rules don't indicate the size of the cut are clearly, then the way with which the cut part possesses the largest area is chosen. Of course, both sides of the cut area should be integer. If there are several answers to this problem, you should choose the answer with the maximal height.
Input
The first line contains a pair of integers h and w (1 ≤ h, w ≤ 109) which are the height and width of the uploaded photo in pixels.
Output
Print two integers which are the height and width of the cut area.
Examples
Input
2 1
Output
1 1
Input
2 2
Output
2 2
Input
5 5
Output
5 4
|
{"inputs": ["6 5\n", "1 1\n", "2 1\n", "2 2\n", "5 5\n", "9 10\n", "8 10\n", "15 13\n"], "outputs": ["5 4\n", "1 1\n", "1 1", "2 2", "5 4", "8 10", "8 10\n", "10 8"]}
| 249
| 104
|
coding
|
Solve the programming task below in a Python markdown code block.
Due to the COVID pandemic, maintaining social distancing is of utmost importance. In this problem, you'd calculate how many days would it take to reach an apocalypse from an initial case if nobody maintains social distancing.
The Earth is flat (for this question) and it's dimensions are $R$ x $C$
The whole Earth is already divided into blocks and the virus can spread in all directions except diagonally. The virus from each newly infected person will spread in all directions in the next day, thus growing exponentially.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Next line contains $R$ and $C$ respectively separated by a space.
- Next line contains $x$ and $y$ respectively separated by a space, denoting the indices of the initial case in the world.
-----Output:-----
For each testcase, output in a single line an integer denoting the number of days after which everyone will be infected.
-----Constraints-----
- $1 \leq T \leq 10^4$
- $2 \leq R,C \leq 10^7$
- $0 \leq x,y \leq 10^7$
-----Subtasks-----
- 10 points : $1 \leq T \leq 5$ and $2 \leq R,C \leq 10$
- 20 points : $2 \leq R,C \leq 10^5$
- 70 points : Original constraints
-----Sample Input:-----
2
4 5
2 1
3 4
1 1
-----Sample Output:-----
5
3
-----EXPLANATION:-----
2nd test case:
Assuming, it's a small world of $3$ x $4$
0 is not infected. 1 is infected.
World indexing is like a 2D array:
(0,0) (0,1) (0,2) (0,3)
(1,0) (1,1) (1,2) (1,3)
(2,0) (2,1) (2,2) (2,3)
If this is the case on Day 0:
0 0 0 0
0 1 0 0
0 0 0 0
This will be the case on Day 1:
0 1 0 0
1 1 1 0
0 1 0 0
This will be the case on Day 2:
1 1 1 0
1 1 1 1
1 1 1 0
The End on Day 3:
1 1 1 1
1 1 1 1
1 1 1 1
Thus, answer will be 3
|
{"inputs": ["2\n4 5\n2 1\n3 4\n1 1"], "outputs": ["5\n3"]}
| 614
| 30
|
coding
|
Solve the programming task below in a Python markdown code block.
Salve, mi amice.
Et tu quidem de lapis philosophorum. Barba non facit philosophum. Labor omnia vincit. Non potest creatio ex nihilo. Necesse est partibus.
Rp:
I Aqua Fortis
I Aqua Regia
II Amalgama
VII Minium
IV Vitriol
Misce in vitro et æstus, et nil admirari. Festina lente, et nulla tenaci invia est via.
Fac et spera,
Vale,
Nicolas Flamel
-----Input-----
The first line of input contains several space-separated integers a_{i} (0 ≤ a_{i} ≤ 100).
-----Output-----
Print a single integer.
-----Examples-----
Input
2 4 6 8 10
Output
1
|
{"inputs": ["0 0 0 0 0\n", "1 1 2 7 4\n", "1 0 2 7 4\n", "1 1 2 6 4\n", "1 1 1 7 4\n", "1 2 2 7 4\n", "1 1 3 7 4\n", "1 1 2 6 4\n"], "outputs": ["0\n", "1\n", "0\n", "0\n", "0\n", "1\n", "1\n", "0\n"]}
| 196
| 134
|
coding
|
Solve the programming task below in a Python markdown code block.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
|
{"inputs": ["1 1\n1 1\n0 0\n.\n", "1 1\n1 1\n1 0\n.\n", "1 1\n1 1\n31 42\n.\n", "1 7\n1 1\n0 3\n.......\n", "1 7\n1 1\n0 0\n.......\n", "4 4\n3 2\n0 1\n....\n..*.\n....\n....\n", "4 4\n2 2\n0 1\n....\n..*.\n....\n....\n", "4 5\n3 2\n1 2\n.....\n..***\n...**\n*....\n"], "outputs": ["1", "1\n", "1", "4", "1\n", "7\n", "7", "12\n"]}
| 531
| 202
|
coding
|
Solve the programming task below in a Python markdown code block.
An array $a$ consisting of $k$ integers is strictly increasing if $a_1 < a_2 < \dots < a_k$. For example, the arrays $[1, 3, 5]$, $[1, 2, 3, 4]$, $[3, 5, 6]$ are strictly increasing; the arrays $[2, 2]$, $[3, 7, 5]$, $[7, 4, 3]$, $[1, 2, 2, 3]$ are not.
For a strictly increasing array $a$ of $k$ elements, let's denote the characteristic as the number of different elements in the array $[a_2 - a_1, a_3 - a_2, \dots, a_k - a_{k-1}]$. For example, the characteristic of the array $[1, 3, 4, 7, 8]$ is $3$ since the array $[2, 1, 3, 1]$ contains $3$ different elements: $2$, $1$ and $3$.
You are given two integers $k$ and $n$ ($k \le n$). Construct an increasing array of $k$ integers from $1$ to $n$ with maximum possible characteristic.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 819$) — the number of test cases.
Each test case consists of one line containing two integers $k$ and $n$ ($2 \le k \le n \le 40$).
-----Output-----
For each test case, print $k$ integers — the elements of the strictly increasing array $a$ with the maximum possible characteristic. If there are multiple answers, print any of them.
-----Examples-----
Input
7
5 9
4 12
3 3
3 4
4 4
4 6
8 11
Output
1 3 4 7 8
2 4 7 12
1 2 3
1 3 4
1 2 3 4
2 4 5 6
1 2 3 5 6 7 8 11
-----Note-----
None
|
{"inputs": ["1\n4 6\n", "1\n5 6\n", "7\n5 9\n4 12\n3 3\n3 4\n4 4\n4 6\n8 11\n"], "outputs": ["1 3 4 5\n", "1 3 4 5 6\n", "1 3 6 7 8\n1 3 6 10\n1 2 3\n1 3 4\n1 2 3 4\n1 3 4 5\n1 3 6 7 8 9 10 11\n"]}
| 509
| 145
|
coding
|
Solve the programming task below in a Python markdown code block.
You have an array of integers (initially empty).
You have to perform $q$ queries. Each query is of one of two types:
"$1$ $x$" — add the element $x$ to the end of the array;
"$2$ $x$ $y$" — replace all occurrences of $x$ in the array with $y$.
Find the resulting array after performing all the queries.
-----Input-----
The first line contains a single integer $q$ ($1 \le q \le 5 \cdot 10^5$) — the number of queries.
Next $q$ lines contain queries (one per line). Each query is of one of two types:
"$1$ $x$" ($1 \le x \le 5 \cdot 10^5$);
"$2$ $x$ $y$" ($1 \le x, y \le 5 \cdot 10^5$).
It's guaranteed that there is at least one query of the first type.
-----Output-----
In a single line, print $k$ integers — the resulting array after performing all the queries, where $k$ is the number of queries of the first type.
-----Examples-----
Input
7
1 3
1 1
2 1 2
1 2
1 1
1 2
2 1 3
Output
3 2 2 3 2
Input
4
1 1
1 2
1 1
2 2 2
Output
1 2 1
Input
8
2 1 4
1 1
1 4
1 2
2 2 4
2 4 3
1 2
2 2 7
Output
1 3 3 7
-----Note-----
In the first example, the array changes as follows:
$[]$ $\rightarrow$ $[3]$ $\rightarrow$ $[3, 1]$ $\rightarrow$ $[3, 2]$ $\rightarrow$ $[3, 2, 2]$ $\rightarrow$ $[3, 2, 2, 1]$ $\rightarrow$ $[3, 2, 2, 1, 2]$ $\rightarrow$ $[3, 2, 2, 3, 2]$.
In the second example, the array changes as follows:
$[]$ $\rightarrow$ $[1]$ $\rightarrow$ $[1, 2]$ $\rightarrow$ $[1, 2, 1]$ $\rightarrow$ $[1, 2, 1]$.
In the third example, the array changes as follows:
$[]$ $\rightarrow$ $[]$ $\rightarrow$ $[1]$ $\rightarrow$ $[1, 4]$ $\rightarrow$ $[1, 4, 2]$ $\rightarrow$ $[1, 4, 4]$ $\rightarrow$ $[1, 3, 3]$ $\rightarrow$ $[1, 3, 3, 2]$ $\rightarrow$ $[1, 3, 3, 7]$.
|
{"inputs": ["1\n1 8\n", "1\n1 6\n", "1\n1 3\n", "1\n1 5\n", "1\n1 1\n", "1\n1 4\n", "1\n1 9\n", "1\n1 2\n"], "outputs": ["8", "6", "3", "5", "1", "4", "9", "2"]}
| 674
| 94
|
coding
|
Solve the programming task below in a Python markdown code block.
Little Artem got n stones on his birthday and now wants to give some of them to Masha. He knows that Masha cares more about the fact of receiving the present, rather than the value of that present, so he wants to give her stones as many times as possible. However, Masha remembers the last present she received, so Artem can't give her the same number of stones twice in a row. For example, he can give her 3 stones, then 1 stone, then again 3 stones, but he can't give her 3 stones and then again 3 stones right after that.
How many times can Artem give presents to Masha?
-----Input-----
The only line of the input contains a single integer n (1 ≤ n ≤ 10^9) — number of stones Artem received on his birthday.
-----Output-----
Print the maximum possible number of times Artem can give presents to Masha.
-----Examples-----
Input
1
Output
1
Input
2
Output
1
Input
3
Output
2
Input
4
Output
3
-----Note-----
In the first sample, Artem can only give 1 stone to Masha.
In the second sample, Atrem can give Masha 1 or 2 stones, though he can't give her 1 stone two times.
In the third sample, Atrem can first give Masha 2 stones, a then 1 more stone.
In the fourth sample, Atrem can first give Masha 1 stone, then 2 stones, and finally 1 stone again.
|
{"inputs": ["1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "6\n"], "outputs": ["1\n", "1\n", "2\n", "3\n", "3\n", "4\n", "5\n", "4"]}
| 337
| 69
|
coding
|
Solve the programming task below in a Python markdown code block.
For a dynamic array $A = \\{a_0, a_1, ...\\}$ of integers, perform a sequence of the following operations:
* pushBack($x$): add element $x$ at the end of $A$
* randomAccess($p$):print element $a_p$
* popBack(): delete the last element of $A$
$A$ is a 0-origin array and it is empty in the initial state.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq p < $ the size of $A$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $p$
or
2
where the first digits 0, 1 and 2 represent pushBack, randomAccess and popBack operations respectively.
randomAccess and popBack operations will not be given for an empty array.
Output
For each randomAccess, print $a_p$ in a line.
Example
Input
8
0 1
0 2
0 3
2
0 4
1 0
1 1
1 2
Output
1
2
4
|
{"inputs": ["8\n0 0\n0 2\n0 3\n2\n0 4\n1 0\n1 1\n1 2", "8\n0 0\n0 2\n0 3\n2\n0 4\n1 0\n1 1\n1 1", "8\n0 0\n0 2\n0 3\n2\n1 0\n1 0\n1 1\n1 1", "8\n0 1\n0 2\n0 4\n2\n0 4\n1 0\n1 1\n1 2", "8\n0 0\n0 2\n0 3\n2\n0 4\n1 0\n1 1\n0 2", "8\n0 0\n0 2\n0 3\n2\n0 4\n1 0\n1 1\n1 0", "8\n0 0\n0 3\n0 3\n2\n0 0\n1 0\n1 1\n1 1", "8\n0 1\n0 2\n0 4\n2\n0 3\n1 0\n1 1\n1 2"], "outputs": ["0\n2\n4\n", "0\n2\n2\n", "0\n0\n2\n2\n", "1\n2\n4\n", "0\n2\n", "0\n2\n0\n", "0\n3\n3\n", "1\n2\n3\n"]}
| 331
| 334
|
coding
|
Solve the programming task below in a Python markdown code block.
Complete the solution so that it strips all text that follows any of a set of comment markers passed in. Any whitespace at the end of the line should also be stripped out.
**Example:**
Given an input string of:
```
apples, pears # and bananas
grapes
bananas !apples
```
The output expected would be:
```
apples, pears
grapes
bananas
```
The code would be called like so:
```python
result = solution("apples, pears # and bananas\ngrapes\nbananas !apples", ["#", "!"])
# result should == "apples, pears\ngrapes\nbananas"
```
Also feel free to reuse/extend the following starter code:
```python
def solution(string,markers):
```
|
{"functional": "_inputs = [['apples, pears # and bananas\\ngrapes\\nbananas !apples', ['#', '!']], ['a #b\\nc\\nd $e f g', ['#', '$']], ['apples, pears # and bananas\\ngrapes\\nbananas !#apples', ['#', '!']], ['apples, pears # and bananas\\ngrapes\\nbananas #!apples', ['#', '!']], ['apples, pears # and bananas\\ngrapes\\navocado @apples', ['@', '!']], ['apples, pears \u00a7 and bananas\\ngrapes\\navocado *apples', ['*', '\u00a7']], ['', ['#', '!']], ['#', ['#', '!']], ['\\n\u00a7', ['#', '\u00a7']], ['apples, pears # and bananas\\ngrapes\\nbananas !apples', []]]\n_outputs = [['apples, pears\\ngrapes\\nbananas'], ['a\\nc\\nd'], ['apples, pears\\ngrapes\\nbananas'], ['apples, pears\\ngrapes\\nbananas'], ['apples, pears # and bananas\\ngrapes\\navocado'], ['apples, pears\\ngrapes\\navocado'], [''], [''], ['\\n'], ['apples, pears # and bananas\\ngrapes\\nbananas !apples']]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(solution(*i), o[0])"}
| 181
| 452
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has an exam which will start exactly M minutes from now. However, instead of preparing for his exam, Chef started watching Season-1 of Superchef. Season-1 has N episodes, and the duration of each episode is K minutes.
Will Chef be able to finish watching Season-1 strictly before the exam starts?
\textbf{Note:} Please read the explanations of the sample test cases carefully.
------ Input Format ------
- The first line contains an integer T denoting the number of test cases. T test cases then follow.
- The first and only line of each test case contains 3 space separated integers M, N and K.
------ Output Format ------
For each test case, output on one line YES if it is possible to finish Season-1 strictly before the exam starts, or NO if it is not possible to do so.
Output is case insensitive, which means that "yes", "Yes", "YEs", "no", "nO" - all such strings will be acceptable.
------ Constraints ------
$1 ≤ T ≤ 10^{4}$
$1 ≤ M ≤ 10^{9}$
$1 ≤ N, K ≤ 10^{4}$
----- Sample Input 1 ------
3
10 1 10
25 2 10
15 2 10
----- Sample Output 1 ------
NO
YES
NO
----- explanation 1 ------
Test Case $1$: The duration of the only episode is $10$ minutes, and the exam starts exactly after $10$ minutes. So, Chef will not be able to finish watching Season-$1$ strictly before the exam starts.
Test Case $2$: There are two episodes in Season-$1$, each of duration $10$ minutes. Therefore, Chef will require $10 + 10 = 20$ minutes to finish watching Season-$1$. As the exam starts after $25$ minutes, Chef will be able to finish watching Season-$1$ strictly before the exam starts.
Test Case $3$: There are two episodes in Season-$1$, each of duration $10$ minutes. Therefore, Chef will require $10 + 10 = 20$ minutes to finish watchin Season-$1$. As the exam starts after $15$ minutes, Chef will not be able to finish watching Season-$1$ strictly before the exam starts.
|
{"inputs": ["3\n10 1 10\n25 2 10\n15 2 10"], "outputs": ["NO\nYES\nNO"]}
| 520
| 40
|
coding
|
Solve the programming task below in a Python markdown code block.
Sagheer is playing a game with his best friend Soliman. He brought a tree with n nodes numbered from 1 to n and rooted at node 1. The i-th node has a_{i} apples. This tree has a special property: the lengths of all paths from the root to any leaf have the same parity (i.e. all paths have even length or all paths have odd length).
Sagheer and Soliman will take turns to play. Soliman will make the first move. The player who can't make a move loses.
In each move, the current player will pick a single node, take a non-empty subset of apples from it and do one of the following two things: eat the apples, if the node is a leaf. move the apples to one of the children, if the node is non-leaf.
Before Soliman comes to start playing, Sagheer will make exactly one change to the tree. He will pick two different nodes u and v and swap the apples of u with the apples of v.
Can you help Sagheer count the number of ways to make the swap (i.e. to choose u and v) after which he will win the game if both players play optimally? (u, v) and (v, u) are considered to be the same pair.
-----Input-----
The first line will contain one integer n (2 ≤ n ≤ 10^5) — the number of nodes in the apple tree.
The second line will contain n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^7) — the number of apples on each node of the tree.
The third line will contain n - 1 integers p_2, p_3, ..., p_{n} (1 ≤ p_{i} ≤ n) — the parent of each node of the tree. Node i has parent p_{i} (for 2 ≤ i ≤ n). Node 1 is the root of the tree.
It is guaranteed that the input describes a valid tree, and the lengths of all paths from the root to any leaf will have the same parity.
-----Output-----
On a single line, print the number of different pairs of nodes (u, v), u ≠ v such that if they start playing after swapping the apples of both nodes, Sagheer will win the game. (u, v) and (v, u) are considered to be the same pair.
-----Examples-----
Input
3
2 2 3
1 1
Output
1
Input
3
1 2 3
1 1
Output
0
Input
8
7 2 2 5 4 3 1 1
1 1 1 4 4 5 6
Output
4
-----Note-----
In the first sample, Sagheer can only win if he swapped node 1 with node 3. In this case, both leaves will have 2 apples. If Soliman makes a move in a leaf node, Sagheer can make the same move in the other leaf. If Soliman moved some apples from a root to a leaf, Sagheer will eat those moved apples. Eventually, Soliman will not find a move.
In the second sample, There is no swap that will make Sagheer win the game.
Note that Sagheer must make the swap even if he can win with the initial tree.
|
{"inputs": ["3\n2 2 3\n1 1\n", "3\n1 2 3\n1 1\n", "3\n1 1 3\n1 1\n", "3\n2 2 3\n1 2\n", "3\n2 0 3\n1 2\n", "3\n2 0 1\n1 2\n", "3\n1 2 3\n1 1\n", "3\n2 2 3\n1 1\n"], "outputs": ["1\n", "0\n", "1\n", "1\n", "0\n", "0\n", "0\n", "1\n"]}
| 739
| 150
|
coding
|
Solve the programming task below in a Python markdown code block.
Given two arrays A and B each of length N.
Find the value \sum_{i=1}^N\sum_{j=1}^N \max(A_{i}\oplus B_{j},A_{i}\& B_{j}).
Here \oplus and \& denote the [bitwise XOR operation] and [bitwise AND operation] respectively.
------ Input Format ------
- The first line of input contains a single integer T - the number of test cases. The description of T test cases follows.
- The first line of each test case contains an integer N - the length of arrays A and B.
- The second line of each test case contains N space-separated integers A_{1},A_{2},…,A_{N} representing the array A.
- The third line of each test case contains N space-separated integers B_{1},B_{2},…,B_{N} representing the array B.
------ Output Format ------
For each test case, output the value \sum_{i=1}^N\sum_{j=1}^N \max(A_{i}\oplus B_{j},A_{i}\& B_{j}).
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$0 ≤ A_{i}, B_{i} < 2^{20}$
- Sum of $N$ does not exceed $2\cdot 10^{5}$ over all test cases.
----- Sample Input 1 ------
3
2
3 4
1 2
1
0
0
3
2 4 3
1 2 1
----- Sample Output 1 ------
15
0
30
----- explanation 1 ------
- Test Case $1$: For the given arrays, the value is: $\max(3\oplus 1,3\& 1) + \max(3\oplus 2,3\& 2) + \max(4\oplus 1,4\& 1) + \max(4\oplus 2,4\& 2) = 2 + 2 + 5 + 6 = 15$.
- Test Case $2$: For the given arrays, the value is: $\max(0\oplus 0,0\& 0) = 0$.
- Test Case $3$: For the given arrays, the value is: $\max(2\oplus 1,2\& 1) + \max(2\oplus 2,2\& 2) + \max(2\oplus 1,2\& 1) + \max(4\oplus 1,4\& 1) + \max(4\oplus 2,4\& 2) + \max(4\oplus 1,4\& 1) + \max(3\oplus 1,3\& 1) + \max(3\oplus 2,3\& 2) + \max(3\oplus 1,3\& 1)$
$= 3 + 2 + 3 + 5 + 6 + 5 + 2 + 2 + 2 = 30$.
|
{"inputs": ["3\n2\n3 4\n1 2\n1\n0\n0\n3\n2 4 3\n1 2 1"], "outputs": ["15\n0\n30"]}
| 729
| 48
|
coding
|
Solve the programming task below in a Python markdown code block.
When Valera has got some free time, he goes to the library to read some books. Today he's got t free minutes to read. That's why Valera took n books in the library and for each book he estimated the time he is going to need to read it. Let's number the books by integers from 1 to n. Valera needs a_{i} minutes to read the i-th book.
Valera decided to choose an arbitrary book with number i and read the books one by one, starting from this book. In other words, he will first read book number i, then book number i + 1, then book number i + 2 and so on. He continues the process until he either runs out of the free time or finishes reading the n-th book. Valera reads each book up to the end, that is, he doesn't start reading the book if he doesn't have enough free time to finish reading it.
Print the maximum number of books Valera can read.
-----Input-----
The first line contains two integers n and t (1 ≤ n ≤ 10^5; 1 ≤ t ≤ 10^9) — the number of books and the number of free minutes Valera's got. The second line contains a sequence of n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^4), where number a_{i} shows the number of minutes that the boy needs to read the i-th book.
-----Output-----
Print a single integer — the maximum number of books Valera can read.
-----Examples-----
Input
4 5
3 1 2 1
Output
3
Input
3 3
2 2 3
Output
1
|
{"inputs": ["1 3\n5\n", "1 3\n5\n", "1 10\n4\n", "1 10\n4\n", "2 10\n6 4\n", "2 10\n6 4\n", "2 10\n6 6\n", "2 11\n6 6\n"], "outputs": ["0\n", "0\n", "1\n", "1\n", "2\n", "2\n", "1\n", "1\n"]}
| 381
| 116
|
coding
|
Solve the programming task below in a Python markdown code block.
Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division.
To improve his division skills, Oleg came up with $t$ pairs of integers $p_i$ and $q_i$ and for each pair decided to find the greatest integer $x_i$, such that: $p_i$ is divisible by $x_i$; $x_i$ is not divisible by $q_i$. Oleg is really good at division and managed to find all the answers quickly, how about you?
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 50$) — the number of pairs.
Each of the following $t$ lines contains two integers $p_i$ and $q_i$ ($1 \le p_i \le 10^{18}$; $2 \le q_i \le 10^{9}$) — the $i$-th pair of integers.
-----Output-----
Print $t$ integers: the $i$-th integer is the largest $x_i$ such that $p_i$ is divisible by $x_i$, but $x_i$ is not divisible by $q_i$.
One can show that there is always at least one value of $x_i$ satisfying the divisibility conditions for the given constraints.
-----Example-----
Input
3
10 4
12 6
179 822
Output
10
4
179
-----Note-----
For the first pair, where $p_1 = 10$ and $q_1 = 4$, the answer is $x_1 = 10$, since it is the greatest divisor of $10$ and $10$ is not divisible by $4$.
For the second pair, where $p_2 = 12$ and $q_2 = 6$, note that $12$ is not a valid $x_2$, since $12$ is divisible by $q_2 = 6$; $6$ is not valid $x_2$ as well: $6$ is also divisible by $q_2 = 6$. The next available divisor of $p_2 = 12$ is $4$, which is the answer, since $4$ is not divisible by $6$.
|
{"inputs": ["1\n5 5\n", "1\n5 6\n", "1\n6 12\n", "1\n9 17\n", "1\n5 12\n", "1\n6 17\n", "1\n95775579 43432\n", "1\n95775579 67436\n"], "outputs": ["1\n", "5\n", "6\n", "9\n", "5\n", "6\n", "95775579\n", "95775579\n"]}
| 513
| 142
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There is a tree (i.e., a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. Each node has a value associated with it, and the root of the tree is node 0.
To represent this tree, you are given an integer array nums and a 2D array edges. Each nums[i] represents the ith node's value, and each edges[j] = [uj, vj] represents an edge between nodes uj and vj in the tree.
Two values x and y are coprime if gcd(x, y) == 1 where gcd(x, y) is the greatest common divisor of x and y.
An ancestor of a node i is any other node on the shortest path from node i to the root. A node is not considered an ancestor of itself.
Return an array ans of size n, where ans[i] is the closest ancestor to node i such that nums[i] and nums[ans[i]] are coprime, or -1 if there is no such ancestor.
Please complete the following python code precisely:
```python
class Solution:
def getCoprimes(self, nums: List[int], edges: List[List[int]]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]) == [-1,0,0,1]\n assert candidate(nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]) == [-1,0,-1,0,0,0,-1]\n\n\ncheck(Solution().getCoprimes)"}
| 284
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
Dinesh is very fond of sweets recently his aunt Riya gifted him an array $a$ of sweets of size $N$. The ith sweet is of the type $a[i]$. His mother told him that he can choose one type of sweet in a day and eat at most 2 sweets of that type. Since he has to eat all the sweets as quickly as possible because his cousins are arriving. Find out the minimum number of days in which he can eat all the sweets gifted by his aunt Riya.
-----Input:-----
- First-line will contain $N$, the number of sweets.
- The next line will contain $N$ space integers denoting the type of sweets.
-----Output:-----
Output the minimum number of days in which he can eat all the sweets.
-----Constraints-----
- $1 \leq N \leq 10000$
- $1 \leq a[i] \leq 10^3$
-----Sample Input:-----
3
1 2 2
-----Sample Output:-----
2
|
{"inputs": ["3\n1 2 2"], "outputs": ["2"]}
| 231
| 18
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given three integers k, p_{a} and p_{b}.
You will construct a sequence with the following algorithm: Initially, start with the empty sequence. Each second, you do the following. With probability p_{a} / (p_{a} + p_{b}), add 'a' to the end of the sequence. Otherwise (with probability p_{b} / (p_{a} + p_{b})), add 'b' to the end of the sequence.
You stop once there are at least k subsequences that form 'ab'. Determine the expected number of times 'ab' is a subsequence in the resulting sequence. It can be shown that this can be represented by P / Q, where P and Q are coprime integers, and $Q \neq 0 \operatorname{mod}(10^{9} + 7)$. Print the value of $P \cdot Q^{-1} \operatorname{mod}(10^{9} + 7)$.
-----Input-----
The first line will contain three integers integer k, p_{a}, p_{b} (1 ≤ k ≤ 1 000, 1 ≤ p_{a}, p_{b} ≤ 1 000 000).
-----Output-----
Print a single integer, the answer to the problem.
-----Examples-----
Input
1 1 1
Output
2
Input
3 1 4
Output
370000006
-----Note-----
The first sample, we will keep appending to our sequence until we get the subsequence 'ab' at least once. For instance, we get the sequence 'ab' with probability 1/4, 'bbab' with probability 1/16, and 'aab' with probability 1/8. Note, it's impossible for us to end with a sequence like 'aabab', since we would have stopped our algorithm once we had the prefix 'aab'.
The expected amount of times that 'ab' will occur across all valid sequences is 2.
For the second sample, the answer is equal to $\frac{341}{100}$.
|
{"inputs": ["1 1 1\n", "3 1 4\n", "1 1 2\n", "3 1 2\n", "3 1 1\n", "1 1 1\n", "3 1 4\n", "4 78149 46740\n"], "outputs": ["2\n", "370000006\n", "500000005", "722222231", "250000006", "2\n", "370000006\n", "604608981"]}
| 471
| 154
|
coding
|
Solve the programming task below in a Python markdown code block.
Sasha is a very happy guy, that's why he is always on the move. There are $n$ cities in the country where Sasha lives. They are all located on one straight line, and for convenience, they are numbered from $1$ to $n$ in increasing order. The distance between any two adjacent cities is equal to $1$ kilometer. Since all roads in the country are directed, it's possible to reach the city $y$ from the city $x$ only if $x < y$.
Once Sasha decided to go on a trip around the country and to visit all $n$ cities. He will move with the help of his car, Cheetah-2677. The tank capacity of this model is $v$ liters, and it spends exactly $1$ liter of fuel for $1$ kilometer of the way. At the beginning of the journey, the tank is empty. Sasha is located in the city with the number $1$ and wants to get to the city with the number $n$. There is a gas station in each city. In the $i$-th city, the price of $1$ liter of fuel is $i$ dollars. It is obvious that at any moment of time, the tank can contain at most $v$ liters of fuel.
Sasha doesn't like to waste money, that's why he wants to know what is the minimum amount of money is needed to finish the trip if he can buy fuel in any city he wants. Help him to figure it out!
-----Input-----
The first line contains two integers $n$ and $v$ ($2 \le n \le 100$, $1 \le v \le 100$) — the number of cities in the country and the capacity of the tank.
-----Output-----
Print one integer — the minimum amount of money that is needed to finish the trip.
-----Examples-----
Input
4 2
Output
4
Input
7 6
Output
6
-----Note-----
In the first example, Sasha can buy $2$ liters for $2$ dollars ($1$ dollar per liter) in the first city, drive to the second city, spend $1$ liter of fuel on it, then buy $1$ liter for $2$ dollars in the second city and then drive to the $4$-th city. Therefore, the answer is $1+1+2=4$.
In the second example, the capacity of the tank allows to fill the tank completely in the first city, and drive to the last city without stops in other cities.
|
{"inputs": ["4 2\n", "7 6\n", "9 5\n", "9 5\n", "5 5\n", "7 5\n", "4 1\n", "9 1\n"], "outputs": ["4\n", "6\n", "14\n", "14 \n", "4\n", "7\n", "6\n", "36\n"]}
| 557
| 90
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
Given a string s, return true if it is a palindrome, or false otherwise.
Please complete the following python code precisely:
```python
class Solution:
def isPalindrome(self, s: str) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"race a car\") == False\n assert candidate(s = \" \") == True\n\n\ncheck(Solution().isPalindrome)"}
| 103
| 43
|
coding
|
Solve the programming task below in a Python markdown code block.
In this exercise, a string is passed to a method and a new string has to be returned with the first character of each word in the string.
For example:
```
"This Is A Test" ==> "TIAT"
```
Also feel free to reuse/extend the following starter code:
```python
def make_string(s):
```
|
{"functional": "_inputs = [['sees eyes xray yoat'], ['brown eyes are nice'], ['cars are very nice'], ['kaks de gan has a big head']]\n_outputs = [['sexy'], ['bean'], ['cavn'], ['kdghabh']]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(make_string(*i), o[0])"}
| 81
| 194
|
coding
|
Solve the programming task below in a Python markdown code block.
It's now the season of TAKOYAKI FESTIVAL!
This year, N takoyaki (a ball-shaped food with a piece of octopus inside) will be served. The deliciousness of the i-th takoyaki is d_i.
As is commonly known, when you eat two takoyaki of deliciousness x and y together, you restore x \times y health points.
There are \frac{N \times (N - 1)}{2} ways to choose two from the N takoyaki served in the festival. For each of these choices, find the health points restored from eating the two takoyaki, then compute the sum of these \frac{N \times (N - 1)}{2} values.
-----Constraints-----
- All values in input are integers.
- 2 \leq N \leq 50
- 0 \leq d_i \leq 100
-----Input-----
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
-----Output-----
Print the sum of the health points restored from eating two takoyaki over all possible choices of two takoyaki from the N takoyaki served.
-----Sample Input-----
3
3 1 2
-----Sample Output-----
11
There are three possible choices:
- Eat the first and second takoyaki. You will restore 3 health points.
- Eat the second and third takoyaki. You will restore 2 health points.
- Eat the first and third takoyaki. You will restore 6 health points.
The sum of these values is 11.
|
{"inputs": ["3\n3 1 3", "3\n3 1 5", "3\n1 1 5", "3\n1 1 8", "3\n0 1 8", "3\n0 1 2", "3\n0 1 1", "3\n1 1 1"], "outputs": ["15\n", "23\n", "11\n", "17\n", "8\n", "2\n", "1\n", "3\n"]}
| 360
| 114
|
coding
|
Solve the programming task below in a Python markdown code block.
Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.
A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.
Input
The first and single line contains string s (1 ≤ |s| ≤ 15).
Output
Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.
Examples
Input
abccaa
Output
YES
Input
abbcca
Output
NO
Input
abcda
Output
YES
|
{"inputs": ["c\n", "a\n", "b\n", "z\n", "d\n", "`\n", "e\n", "{\n"], "outputs": ["YES\n", "YES\n", "YES\n", "YES\n", "YES\n", "YES\n", "YES\n", "YES\n"]}
| 182
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
Given are two sequences a=\{a_0,\ldots,a_{N-1}\} and b=\{b_0,\ldots,b_{N-1}\} of N non-negative integers each.
Snuke will choose an integer k such that 0 \leq k < N and an integer x not less than 0, to make a new sequence of length N, a'=\{a_0',\ldots,a_{N-1}'\}, as follows:
- a_i'= a_{i+k \mod N}\ XOR \ x
Find all pairs (k,x) such that a' will be equal to b.What is \mbox{ XOR }?
The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:
- When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)
-----Constraints-----
- 1 \leq N \leq 2 \times 10^5
- 0 \leq a_i,b_i < 2^{30}
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
a_0 a_1 ... a_{N-1}
b_0 b_1 ... b_{N-1}
-----Output-----
Print all pairs (k, x) such that a' and b will be equal, using one line for each pair, in ascending order of k (ascending order of x for pairs with the same k).
If there are no such pairs, the output should be empty.
-----Sample Input-----
3
0 2 1
1 2 3
-----Sample Output-----
1 3
If (k,x)=(1,3),
- a_0'=(a_1\ XOR \ 3)=1
- a_1'=(a_2\ XOR \ 3)=2
- a_2'=(a_0\ XOR \ 3)=3
and we have a' = b.
|
{"inputs": ["2\n1 2\n0 0\n", "3\n0 2 1\n2 0 3", "3\n0 2 1\n2 1 0", "3\n0 2 0\n1 3 3", "3\n1 0 1\n2 2 3", "3\n0 2 1\n0 1 3", "3\n0 0 1\n2 3 2", "3\n1 0 1\n2 3 2"], "outputs": ["", "0 2\n", "1 0\n", "1 3\n", "2 3\n", "2 1\n", "1 2\n", "0 3\n"]}
| 528
| 167
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef recently learned about concept of periodicity of strings. A string is said to have a period P, if P divides N and for each i, the i-th of character of the string is same as i-Pth character (provided it exists), e.g. "abab" has a period P = 2, It also has a period of P = 4, but it doesn't have a period of 1 or 3.
Chef wants to construct a string of length N that is a palindrome and has a period P. It's guaranteed that N is divisible by P. This string can only contain character 'a' or 'b'. Chef doesn't like the strings that contain all a's or all b's.
Given the values of N, P, can you construct one such palindromic string that Chef likes? If it's impossible to do so, output "impossible" (without quotes)
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The only line of each test case contains two space separated integers N, P.
-----Output-----
For each test case, output a single line containing the answer of the problem, i.e. the valid string if it exists otherwise "impossible" (without quotes). If there are more than possible answers, you can output any.
-----Constraints-----
- 1 ≤ T ≤ 20
- 1 ≤ P, N ≤ 105
-----Subtasks-----
- Subtask #1 (25 points) : P = N
- Subtask #2 (75 points) : No additional constraints
-----Example-----
Input
5
3 1
2 2
3 3
4 4
6 3
Output
impossible
impossible
aba
abba
abaaba
-----Explanation-----
Example 1: The only strings possible are either aaa or bbb, which Chef doesn't like. So, the answer is impossible.
Example 2: There are four possible strings, aa, ab, ba, bb. Only aa and bb are palindromic, but Chef doesn't like these strings. Hence, the answer is impossible.
Example 4: The string abba is a palindrome and has a period of 4.
Example 5: The string abaaba is a palindrome and has a period of length 3.
|
{"inputs": ["5\n3 1\n2 2\n3 3\n4 4\n6 3"], "outputs": ["impossible\nimpossible\naba\nabba\nabaaba"]}
| 504
| 44
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an integer N.
Construct a permutation P of length N such that
For all i (1 ≤ i ≤ N-1), i divides abs(P_{i+1}-P_{i}).
Recall that a permutation of length N is an array where every integer from 1 to N occurs exactly once.
It can be proven that for the given constraints at least one such P always exists.
------ Input Format ------
- The first line of input contains a single integer T, denoting the number of test cases. The description of T test cases follow.
- The only line of each test case contains an integer N - the length of the array to be constructed.
------ Output Format ------
For each test case, output a single line containing N space-separated integers P_{1}, P_{2}, \dots, P_{N}, denoting the elements of the array P.
If there exist multiple such arrays, print any.
------ Constraints ------
$1 ≤ T ≤ 5 \cdot 10^{4}$
$2 ≤ N ≤ 10^{5}$
- The sum of $N$ over all test cases does not exceed $10^{5}$.
----- Sample Input 1 ------
2
2
3
----- Sample Output 1 ------
1 2
2 1 3
----- explanation 1 ------
Test case 1: A possible array satisfying all the conditions is $[1, 2]$:
- For $i=1$: $abs(A_{2}-A_{1})=abs(2-1)=1$ is divisible by $1$.
Test case 2: A possible array satisfying all the conditions is $[2, 1, 3]$:
- For $i=1$: $abs(A_{2}-A_{1})=abs(1-2)=1$ is divisible by $1$.
- For $i=2$: $abs(A_{3}-A_{2})=abs(3-1)=2$ is divisible by $2$.
|
{"inputs": ["2\n2\n3\n"], "outputs": ["1 2\n2 1 3\n"]}
| 437
| 26
|
coding
|
Solve the programming task below in a Python markdown code block.
When you divide the successive powers of `10` by `13` you get the following remainders of the integer divisions:
`1, 10, 9, 12, 3, 4`.
Then the whole pattern repeats.
Hence the following method:
Multiply the right most digit of the number with the left most number
in the sequence shown above, the second right most digit to the second
left most digit of the number in the sequence. The cycle goes on and you sum all these products. Repeat this process until the sequence of sums is stationary.
...........................................................................
Example: What is the remainder when `1234567` is divided by `13`?
`7×1 + 6×10 + 5×9 + 4×12 + 3×3 + 2×4 + 1×1 = 178`
We repeat the process with 178:
`8x1 + 7x10 + 1x9 = 87`
and again with 87:
`7x1 + 8x10 = 87`
...........................................................................
From now on the sequence is stationary and the remainder of `1234567` by `13` is
the same as the remainder of `87` by `13`: `9`
Call `thirt` the function which processes this sequence of operations on an integer `n (>=0)`. `thirt` will return the stationary number.
`thirt(1234567)` calculates 178, then 87, then 87 and returns `87`.
`thirt(321)` calculates 48, 48 and returns `48`
Also feel free to reuse/extend the following starter code:
```python
def thirt(n):
```
|
{"functional": "_inputs = [[8529], [85299258], [5634], [1111111111], [987654321]]\n_outputs = [[79], [31], [57], [71], [30]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(thirt(*i), o[0])"}
| 413
| 213
|
coding
|
Solve the programming task below in a Python markdown code block.
You have to create a function named reverseIt.
Write your function so that in the case a string or a number is passed in as the data , you will return the data in reverse order. If the data is any other type, return it as it is.
Examples of inputs and subsequent outputs:
```
"Hello" -> "olleH"
"314159" -> "951413"
[1,2,3] -> [1,2,3]
```
Also feel free to reuse/extend the following starter code:
```python
def reverse_it(data):
```
|
{"functional": "_inputs = [['Hello'], [314159], ['314159'], [[]], [{}], [True], [[1, 2, 3]]]\n_outputs = [['olleH'], [951413], ['951413'], [[]], [{}], [True], [[1, 2, 3]]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(reverse_it(*i), o[0])"}
| 138
| 221
|
coding
|
Solve the programming task below in a Python markdown code block.
Neo has a complex matrix script. The matrix script is a $N$ X $\mbox{M}$ grid of strings. It consists of alphanumeric characters, spaces and symbols (!,@,#,$,%,&).
To decode the script, Neo needs to read each column and select only the alphanumeric characters and connect them. Neo reads the column from top to bottom and starts reading from the leftmost column.
If there are symbols or spaces between two alphanumeric characters of the decoded script, then Neo replaces them with a single space '' for better readability.
Neo feels that there is no need to use 'if' conditions for decoding.
Alphanumeric characters consist of: [A-Z, a-z, and 0-9].
Input Format
The first line contains space-separated integers $N$ (rows) and $\mbox{M}$ (columns) respectively.
The next $N$ lines contain the row elements of the matrix script.
Constraints
$0<N,M<100$
Note: A $\mbox{o}$ score will be awarded for using 'if' conditions in your code.
Output Format
Print the decoded matrix script.
Sample Input 0
7 3
Tsi
h%x
i #
sM
$a
#t%
ir!
Sample Output 0
This is Matrix# %!
Explanation 0
The decoded script is:
This$#is% Matrix# %!
Neo replaces the symbols or spaces between two alphanumeric characters with a single space ' ' for better readability.
So, the final decoded script is:
This is Matrix# %!
|
{"inputs": ["7 3\nTsi\nh%x\ni #\nsM \n$a \n#t%\nir!\n"], "outputs": ["This is Matrix# %!\n"]}
| 341
| 45
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer num. Rearrange the digits of num such that its value is minimized and it does not contain any leading zeros.
Return the rearranged number with minimal value.
Note that the sign of the number does not change after rearranging the digits.
Please complete the following python code precisely:
```python
class Solution:
def smallestNumber(self, num: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(num = 310) == 103\n assert candidate(num = -7605) == -7650\n\n\ncheck(Solution().smallestNumber)"}
| 100
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
Tatyana is a big sports fan and she likes volleyball a lot! She writes down the final scores of the game after it has ended in her notebook.
If you are not familiar with the rules of volleyball, here's a brief:
2 teams play in total
During the course of the game, each team gets points, and thus increases its score by 1.
The initial score is 0 for both teams.
The game ends when
One of the teams gets 25 points and another team has < 24 points ( strictly less than 24).
If the score ties at 24:24, the teams continue to play until the absolute difference between the scores is 2.
Given the final score of a game in the format A:B i.e., the first team has scored A points and the second has scored B points, can you print the number of different sequences of getting points by teams that leads to this final score?
Input Format
The first line contains A and the second line contains B.
Constraints
0 ≤ A , B ≤ 10^{9}
Output Format
Output the number of different sequences of getting points by the teams that leads to the final score A : B. Final means that the game should be over after this score is reached. If the number is larger than 10^{9}+7, output number modulo 10^{9} + 7. Print 0 if no such volleyball game ends with the given score.
Example input #00
3
25
Example output #00
2925
Example input #01
24
17
Example output #01
0
Explanation #01
There's no game of volleyball that ends with a score of 24 : 17.
|
{"inputs": ["3\n25\n", "24\n17\n"], "outputs": ["2925\n", "0\n"]}
| 392
| 32
|
coding
|
Solve the programming task below in a Python markdown code block.
Shohag has an integer sequence $a_1, a_2, \ldots, a_n$. He can perform the following operation any number of times (possibly, zero):
Select any positive integer $k$ (it can be different in different operations).
Choose any position in the sequence (possibly the beginning or end of the sequence, or in between any two elements) and insert $k$ into the sequence at this position.
This way, the sequence $a$ changes, and the next operation is performed on this changed sequence.
For example, if $a=[3,3,4]$ and he selects $k = 2$, then after the operation he can obtain one of the sequences $[\underline{2},3,3,4]$, $[3,\underline{2},3,4]$, $[3,3,\underline{2},4]$, or $[3,3,4,\underline{2}]$.
Shohag wants this sequence to satisfy the following condition: for each $1 \le i \le |a|$, $a_i \le i$. Here, $|a|$ denotes the size of $a$.
Help him to find the minimum number of operations that he has to perform to achieve this goal. We can show that under the constraints of the problem it's always possible to achieve this goal in a finite number of operations.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 200$) — the number of test cases.
The first line of each test case contains a single integer $n$ ($1 \le n \le 100$) — the initial length of the sequence.
The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — the elements of the sequence.
-----Output-----
For each test case, print a single integer — the minimum number of operations needed to perform to achieve the goal mentioned in the statement.
-----Examples-----
Input
4
3
1 3 4
5
1 2 5 7 4
1
1
3
69 6969 696969
Output
1
3
0
696966
-----Note-----
In the first test case, we have to perform at least one operation, as $a_2=3>2$. We can perform the operation $[1, 3, 4] \rightarrow [1, \underline{2}, 3, 4]$ (the newly inserted element is underlined), now the condition is satisfied.
In the second test case, Shohag can perform the following operations:
$[1, 2, 5, 7, 4] \rightarrow [1, 2, \underline{3}, 5, 7, 4] \rightarrow [1, 2, 3, \underline{4}, 5, 7, 4] \rightarrow [1, 2, 3, 4, 5, \underline{3}, 7, 4]$.
In the third test case, the sequence already satisfies the condition.
|
{"inputs": ["4\n3\n1 3 4\n5\n1 2 5 7 4\n1\n1\n3\n69 6969 696969\n", "4\n3\n1 3 4\n5\n1 2 5 7 4\n1\n1\n3\n69 6969 718045\n", "4\n3\n1 3 4\n5\n1 2 5 7 1\n1\n1\n3\n69 6969 718045\n", "4\n3\n1 1 4\n5\n1 2 5 7 1\n1\n1\n3\n69 6969 718045\n", "4\n3\n1 3 4\n5\n1 2 5 7 4\n1\n1\n3\n69 6969 696969\n", "4\n3\n1 3 4\n5\n1 2 5 7 4\n1\n1\n3\n69 6969 1227775\n", "4\n3\n1 3 4\n5\n2 2 5 7 4\n1\n1\n3\n69 6338 1999809\n", "4\n3\n1 3 4\n5\n1 2 5 7 4\n1\n1\n3\n69 6338 1227775\n"], "outputs": ["1\n3\n0\n696966\n", "1\n3\n0\n718042\n", "1\n3\n0\n718042\n", "1\n3\n0\n718042\n", "1\n3\n0\n696966\n", "1\n3\n0\n1227772\n", "1\n3\n0\n1999806\n", "1\n3\n0\n1227772\n"]}
| 707
| 492
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a bracket sequence consisting of $n$ characters '(' and/or )'. You perform several operations with it.
During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.
The prefix is considered good if one of the following two conditions is satisfied:
this prefix is a regular bracket sequence;
this prefix is a palindrome of length at least two.
A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.
The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.
You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. The next $2t$ lines describe test cases.
The first line of the test case contains one integer $n$ ($1 \le n \le 5 \cdot 10^5$) — the length of the bracket sequence.
The second line of the test case contains $n$ characters '(' and/or ')' — the bracket sequence itself.
It is guaranteed that the sum of $n$ over all test cases do not exceed $5 \cdot 10^5$ ($\sum n \le 5 \cdot 10^5$).
-----Output-----
For each test case, print two integers $c$ and $r$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations.
-----Examples-----
Input
5
2
()
3
())
4
((((
5
)((()
6
)((()(
Output
1 0
1 1
2 0
1 0
1 1
-----Note-----
None
|
{"inputs": ["1\n14\n()(((())((()))\n", "1\n15\n((((()))))(((((\n", "1\n16\n((((()))))((((((\n", "1\n18\n()()())(())(())(()\n", "5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()(\n", "5\n3\n)()\n8\n)()()(((\n4\n(()(\n5\n(())(\n6\n))((()\n", "8\n3\n)()\n8\n)()()(((\n4\n(()(\n5\n(())(\n6\n))((()\n5\n))())\n1\n)\n2\n)(\n"], "outputs": ["7 0\n", "7 1\n", "8 0\n", "6 0\n", "1 0\n1 1\n2 0\n1 0\n1 1\n", "1 0\n3 1\n1 2\n2 1\n3 0\n", "1 0\n3 1\n1 2\n2 1\n3 0\n2 1\n0 1\n0 2\n"]}
| 508
| 279
|
coding
|
Solve the programming task below in a Python markdown code block.
To make a paper airplane, one has to use a rectangular piece of paper. From a sheet of standard size you can make $s$ airplanes.
A group of $k$ people decided to make $n$ airplanes each. They are going to buy several packs of paper, each of them containing $p$ sheets, and then distribute the sheets between the people. Each person should have enough sheets to make $n$ airplanes. How many packs should they buy?
-----Input-----
The only line contains four integers $k$, $n$, $s$, $p$ ($1 \le k, n, s, p \le 10^4$) — the number of people, the number of airplanes each should make, the number of airplanes that can be made using one sheet and the number of sheets in one pack, respectively.
-----Output-----
Print a single integer — the minimum number of packs they should buy.
-----Examples-----
Input
5 3 2 3
Output
4
Input
5 3 100 1
Output
5
-----Note-----
In the first sample they have to buy $4$ packs of paper: there will be $12$ sheets in total, and giving $2$ sheets to each person is enough to suit everyone's needs.
In the second sample they have to buy a pack for each person as they can't share sheets.
|
{"inputs": ["5 3 2 3\n", "1 1 1 1\n", "1 2 1 2\n", "1 1 2 2\n", "1 2 1 2\n", "1 1 1 1\n", "1 1 2 2\n", "5 3 2 1\n"], "outputs": ["4\n", "1\n", "1\n", "1\n", "1\n", "1\n", "1\n", "10\n"]}
| 302
| 119
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
Please complete the following python code precisely:
```python
class Solution:
def containsDuplicate(self, nums: List[int]) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,2,3,1]) == True\n assert candidate(nums = [1,2,3,4]) == False\n assert candidate(nums = [1,1,1,3,3,4,3,2,4,2]) == True\n\n\ncheck(Solution().containsDuplicate)"}
| 76
| 82
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef recently realized that he needs a haircut, and went to his favorite hair salon. At the salon, he found N customers waiting for their haircuts. From his past experience, Chef knows that the salon takes M minutes per customer. Only one person can get their haircut at a time.
For how many minutes will Chef have to wait before he can get his haircut?
------ Input Format ------
- The first line of input contains a single integer T, denoting the number of test cases. The description of T test cases follows.
- The first and only line of each test case contains two space-separated integers N and M, as described in the problem.
------ Output Format ------
For each test case, print a single line containing one integer — the number of minutes that Chef will have to wait before he can get his haircut.
------ Constraints ------
$1 ≤ T ≤ 1000$
$0 ≤ N ≤ 1000$
$1 ≤ M ≤ 1000$
------ subtasks ------
Subtask #1 (100 points): Original constraints
----- Sample Input 1 ------
2
2 15
0 15
----- Sample Output 1 ------
30
0
----- explanation 1 ------
Test case $1$: There are $2$ customers waiting for the haircut and the salon will take $15$ minutes for each customer, hence Chef will have to wait for $30$ minutes before he can get his haircut.
Test case $2$: There are $0$ customers waiting for the haircut, therefore the Chef will not have wait to get the haircut.
|
{"inputs": ["2\n2 15\n0 15\n"], "outputs": ["30\n0\n"]}
| 349
| 27
|
coding
|
Solve the programming task below in a Python markdown code block.
Winnie-the-Pooh likes honey very much! That is why he decided to visit his friends. Winnie has got three best friends: Rabbit, Owl and Eeyore, each of them lives in his own house. There are winding paths between each pair of houses. The length of a path between Rabbit's and Owl's houses is a meters, between Rabbit's and Eeyore's house is b meters, between Owl's and Eeyore's house is c meters.
For enjoying his life and singing merry songs Winnie-the-Pooh should have a meal n times a day. Now he is in the Rabbit's house and has a meal for the first time. Each time when in the friend's house where Winnie is now the supply of honey is about to end, Winnie leaves that house. If Winnie has not had a meal the required amount of times, he comes out from the house and goes to someone else of his two friends. For this he chooses one of two adjacent paths, arrives to the house on the other end and visits his friend. You may assume that when Winnie is eating in one of his friend's house, the supply of honey in other friend's houses recover (most probably, they go to the supply store).
Winnie-the-Pooh does not like physical activity. He wants to have a meal n times, traveling minimum possible distance. Help him to find this distance.
-----Input-----
First line contains an integer n (1 ≤ n ≤ 100) — number of visits.
Second line contains an integer a (1 ≤ a ≤ 100) — distance between Rabbit's and Owl's houses.
Third line contains an integer b (1 ≤ b ≤ 100) — distance between Rabbit's and Eeyore's houses.
Fourth line contains an integer c (1 ≤ c ≤ 100) — distance between Owl's and Eeyore's houses.
-----Output-----
Output one number — minimum distance in meters Winnie must go through to have a meal n times.
-----Examples-----
Input
3
2
3
1
Output
3
Input
1
2
3
5
Output
0
-----Note-----
In the first test case the optimal path for Winnie is the following: first have a meal in Rabbit's house, then in Owl's house, then in Eeyore's house. Thus he will pass the distance 2 + 1 = 3.
In the second test case Winnie has a meal in Rabbit's house and that is for him. So he doesn't have to walk anywhere at all.
|
{"inputs": ["3\n2\n3\n1\n", "1\n2\n3\n5\n", "9\n9\n7\n5\n", "1\n2\n2\n1\n", "1\n1\n1\n1\n", "2\n1\n1\n3\n", "1\n3\n2\n1\n", "1\n5\n6\n1\n"], "outputs": ["3\n", "0\n", "42\n", "0\n", "0\n", "1\n", "0\n", "0\n"]}
| 555
| 119
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given a string queryIP, return "IPv4" if IP is a valid IPv4 address, "IPv6" if IP is a valid IPv6 address or "Neither" if IP is not a correct IP of any type.
A valid IPv4 address is an IP in the form "x1.x2.x3.x4" where 0 <= xi <= 255 and xi cannot contain leading zeros. For example, "192.168.1.1" and "192.168.1.0" are valid IPv4 addresses while "192.168.01.1", "192.168.1.00", and "192.168@1.1" are invalid IPv4 addresses.
A valid IPv6 address is an IP in the form "x1:x2:x3:x4:x5:x6:x7:x8" where:
1 <= xi.length <= 4
xi is a hexadecimal string which may contain digits, lowercase English letter ('a' to 'f') and upper-case English letters ('A' to 'F').
Leading zeros are allowed in xi.
For example, "2001:0db8:85a3:0000:0000:8a2e:0370:7334" and "2001:db8:85a3:0:0:8A2E:0370:7334" are valid IPv6 addresses, while "2001:0db8:85a3::8A2E:037j:7334" and "02001:0db8:85a3:0000:0000:8a2e:0370:7334" are invalid IPv6 addresses.
Please complete the following python code precisely:
```python
class Solution:
def validIPAddress(self, queryIP: str) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(queryIP = \"172.16.254.1\") == \"IPv4\"\n assert candidate(queryIP = \"2001:0db8:85a3:0:0:8A2E:0370:7334\") == \"IPv6\"\n assert candidate(queryIP = \"256.256.256.256\") == \"Neither\"\n\n\ncheck(Solution().validIPAddress)"}
| 457
| 119
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given two integer sequences of length N: a_1,a_2,..,a_N and b_1,b_2,..,b_N. Determine if we can repeat the following operation zero or more times so that the sequences a and b become equal.
Operation: Choose two integers i and j (possibly the same) between 1 and N (inclusive), then perform the following two actions simultaneously:
* Add 2 to a_i.
* Add 1 to b_j.
Constraints
* 1 ≤ N ≤ 10 000
* 0 ≤ a_i,b_i ≤ 10^9 (1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 .. a_N
b_1 b_2 .. b_N
Output
If we can repeat the operation zero or more times so that the sequences a and b become equal, print `Yes`; otherwise, print `No`.
Examples
Input
3
1 2 3
5 2 2
Output
Yes
Input
5
3 1 4 1 5
2 7 1 8 2
Output
No
Input
5
2 7 1 8 2
3 1 4 1 5
Output
No
|
{"inputs": ["3\n1 2 2\n5 2 2", "3\n1 2 2\n4 2 2", "3\n1 2 3\n4 2 2", "3\n0 2 3\n4 2 2", "3\n1 2 1\n4 2 2", "3\n0 2 2\n4 2 2", "3\n0 2 2\n7 2 2", "3\n0 0 2\n7 2 2"], "outputs": ["Yes\n", "Yes\n", "Yes\n", "Yes\n", "Yes\n", "Yes\n", "Yes\n", "Yes\n"]}
| 302
| 158
|
coding
|
Solve the programming task below in a Python markdown code block.
The robot is placed in the top left corner of a grid, consisting of $n$ rows and $m$ columns, in a cell $(1, 1)$.
In one step, it can move into a cell, adjacent by a side to the current one:
$(x, y) \rightarrow (x, y + 1)$;
$(x, y) \rightarrow (x + 1, y)$;
$(x, y) \rightarrow (x, y - 1)$;
$(x, y) \rightarrow (x - 1, y)$.
The robot can't move outside the grid.
The cell $(s_x, s_y)$ contains a deadly laser. If the robot comes into some cell that has distance less than or equal to $d$ to the laser, it gets evaporated. The distance between two cells $(x_1, y_1)$ and $(x_2, y_2)$ is $|x_1 - x_2| + |y_1 - y_2|$.
Print the smallest number of steps that the robot can take to reach the cell $(n, m)$ without getting evaporated or moving outside the grid. If it's not possible to reach the cell $(n, m)$, print -1.
The laser is neither in the starting cell, nor in the ending cell. The starting cell always has distance greater than $d$ to the laser.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^4$) — the number of testcases.
The only line of each testcase contains five integers $n, m, s_x, s_y, d$ ($2 \le n, m \le 1000$; $1 \le s_x \le n$; $1 \le s_y \le m$; $0 \le d \le n + m$) — the size of the grid, the cell that contains the laser and the evaporating distance of the laser.
The laser is neither in the starting cell, nor in the ending cell ($(s_x, s_y) \neq (1, 1)$ and $(s_x, s_y) \neq (n, m)$). The starting cell $(1, 1)$ always has distance greater than $d$ to the laser ($|s_x - 1| + |s_y - 1| > d$).
-----Output-----
For each testcase, print a single integer. If it's possible to reach the cell $(n, m)$ from $(1, 1)$ without getting evaporated or moving outside the grid, then print the smallest amount of steps it can take the robot to reach it. Otherwise, print -1.
-----Examples-----
Input
3
2 3 1 3 0
2 3 1 3 1
5 5 3 4 1
Output
3
-1
8
-----Note-----
None
|
{"inputs": ["1\n2 3 1 3 0\n", "1\n2 3 1 3 1\n", "1\n776 123 5 7 3\n", "1\n1000 1000 99 99 2\n", "1\n1000 1000 99 9 21\n", "1\n1000 1000 10 10 0\n", "2\n2 3 1 3 0\n2 3 1 3 1\n", "2\n3 3 2 2 1\n5 5 3 3 1\n"], "outputs": ["3\n", "-1\n", "897\n", "1998\n", "1998\n", "1998\n", "3\n-1\n", "-1\n8\n"]}
| 636
| 214
|
coding
|
Solve the programming task below in a Python markdown code block.
Polycarpus takes part in the "Field of Wonders" TV show. The participants of the show have to guess a hidden word as fast as possible. Initially all the letters of the word are hidden.
The game consists of several turns. At each turn the participant tells a letter and the TV show host responds if there is such letter in the word or not. If there is such letter then the host reveals all such letters. For example, if the hidden word is "abacaba" and the player tells the letter "a", the host will reveal letters at all positions, occupied by "a": 1, 3, 5 and 7 (positions are numbered from left to right starting from 1).
Polycarpus knows m words of exactly the same length as the hidden word. The hidden word is also known to him and appears as one of these m words.
At current moment a number of turns have already been made and some letters (possibly zero) of the hidden word are already revealed. Previously Polycarp has told exactly the letters which are currently revealed.
It is Polycarpus' turn. He wants to tell a letter in such a way, that the TV show host will assuredly reveal at least one more letter. Polycarpus cannot tell the letters, which are already revealed.
Your task is to help Polycarpus and find out the number of letters he can tell so that the show host will assuredly reveal at least one of the remaining letters.
-----Input-----
The first line contains one integer n (1 ≤ n ≤ 50) — the length of the hidden word.
The following line describes already revealed letters. It contains the string of length n, which consists of lowercase Latin letters and symbols "*". If there is a letter at some position, then this letter was already revealed. If the position contains symbol "*", then the letter at this position has not been revealed yet. It is guaranteed, that at least one letter is still closed.
The third line contains an integer m (1 ≤ m ≤ 1000) — the number of words of length n, which Polycarpus knows. The following m lines contain the words themselves — n-letter strings of lowercase Latin letters. All words are distinct.
It is guaranteed that the hidden word appears as one of the given m words. Before the current move Polycarp has told exactly the letters which are currently revealed.
-----Output-----
Output the single integer — the number of letters Polycarpus can tell so that the TV show host definitely reveals at least one more letter. It is possible that this number is zero.
-----Examples-----
Input
4
a**d
2
abcd
acbd
Output
2
Input
5
lo*er
2
lover
loser
Output
0
Input
3
a*a
2
aaa
aba
Output
1
-----Note-----
In the first example Polycarpus can tell letters "b" and "c", which assuredly will be revealed.
The second example contains no letters which can be told as it is not clear, which of the letters "v" or "s" is located at the third position of the hidden word.
In the third example Polycarpus exactly knows that the hidden word is "aba", because in case it was "aaa", then the second letter "a" would have already been revealed in one of previous turns.
|
{"inputs": ["1\n*\n1\na\n", "1\n*\n1\nz\n", "1\n*\n1\na\n", "1\n*\n1\nz\n", "1\n*\n1\ny\n", "1\n*\n1\nb\n", "1\n*\n2\na\nz\n", "2\n**\n1\naa\n"], "outputs": ["1\n", "1\n", "1\n", "1\n", "1\n", "1\n", "0\n", "1\n"]}
| 717
| 121
|
coding
|
Solve the programming task below in a Python markdown code block.
Manipulating numbers is at the core of a programmer's job. To test how well you know their properties, you are asked to solve the following problem.
You are given $n$ non-negative integers $a_1$, $a_2$, ..., $a_n$. You want to know whether it's possible to construct a new integer using all the digits of these numbers such that it would be divisible by $3$. You can reorder the digits as you want. The resulting number can contain leading zeros.
For example, consider the numbers $50,40,90$ from which you have to construct a new integer as described above. Numerous arrangements of digits are possible; but we have illustrated one below.
Complete the function canConstruct which takes an integer array as input and return "Yes" or "No" based on whether or not the required integer can be formed.
Input Format
The first line contains a single integer ${t}}$ denoting the number of queries. The following lines describe the queries.
Each query is described in two lines. The first of these lines contains a single integer $n$. The second contains $n$ space-separated integers $a_1$, $a_2$, ..., $a_n$.
Constraints
$1\leq t\leq100$
$1\leq n\leq100$
$1\leq a_i\leq10^9$
Subtasks
For 33.33% of the total score:
$n=1$
$1\leq a_1\leq10^6$
Output Format
For each query, print a single line containing "Yes" if it's possible to construct such integer and "No" otherwise.
Sample Input 0
3
1
9
3
40 50 90
2
1 4
Sample Output 0
Yes
Yes
No
Explanation 0
In the first example, $\mbox{9}$ is divisible by $3$, so the answer is "Yes".
In the second example you can construct the number ${005490}$ which is divisible by $3$, so the answer is "Yes". Note that there may be other numbers you can construct, some of which are shown in the challenge statement.
In the third example, the only possible numbers are ${14}$ and ${41}$, but both of them are not divisible by $3$, so the answer is "No".
|
{"inputs": ["3\n1\n9\n3\n40 50 90\n2\n1 4\n"], "outputs": ["Yes\nYes\nNo\n"]}
| 530
| 39
|
coding
|
Solve the programming task below in a Python markdown code block.
Given N, count how many permutations of [1, 2, 3, ..., N] satisfy the following property.
Let P1, P2, ..., PN denote the permutation. The property we want to satisfy is that there exists an i between 2 and n-1 (inclusive) such that
- Pj > Pj + 1 ∀ i ≤ j ≤ N - 1.
- Pj > Pj - 1 ∀ 2 ≤ j ≤ i.
-----Input-----
First line contains T, the number of test cases. Each test case consists of N in one line.
-----Output-----
For each test case, output the answer modulo 109+7.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ N ≤ 109
-----Subtasks-----
- Subtask #1(40 points): 1 ≤ N ≤ 1000
- Subtask #2(60 points): original constraints
-----Example-----
Input:
2
2
3
Output:
0
2
-----Explanation-----
Test case 1:
No permutation satisfies.
Test case 2:
Permutations [1, 3, 2] and [2, 3, 1] satisfy the property.
|
{"inputs": ["2\n2\n3"], "outputs": ["0\n2"]}
| 281
| 18
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer n, return true if it is a power of three. Otherwise, return false.
An integer n is a power of three, if there exists an integer x such that n == 3x.
Please complete the following python code precisely:
```python
class Solution:
def isPowerOfThree(self, n: int) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 27) == True\n assert candidate(n = 0) == False\n assert candidate(n = 9) == True\n assert candidate(n = 45) == False\n\n\ncheck(Solution().isPowerOfThree)"}
| 92
| 67
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
We define the conversion array conver of an array arr as follows:
conver[i] = arr[i] + max(arr[0..i]) where max(arr[0..i]) is the maximum value of arr[j] over 0 <= j <= i.
We also define the score of an array arr as the sum of the values of the conversion array of arr.
Given a 0-indexed integer array nums of length n, return an array ans of length n where ans[i] is the score of the prefix nums[0..i].
Please complete the following python code precisely:
```python
class Solution:
def findPrefixScore(self, nums: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [2,3,7,5,10]) == [4,10,24,36,56]\n assert candidate(nums = [1,1,2,4,8,16]) == [2,4,8,16,32,64]\n\n\ncheck(Solution().findPrefixScore)"}
| 161
| 91
|
coding
|
Solve the programming task below in a Python markdown code block.
Taking into consideration the [3.5 edition rules](http://www.dandwiki.com/wiki/SRD:Ability_Scores#Table:_Ability_Modifiers_and_Bonus_Spells), your goal is to build a function that takes an ability score (worry not about validation: it is always going to be a non negative integer), will return:
* attribute modifier, as indicated on the table of the above link;
* maximum spell level for the spells you can cast (-1 for no spells at all) with that score;
* the eventual extra spells you might get (as an array/list, with elements representing extra spells for 1st, 2nd,... spell level in order; empty array for no extra spells).
The result needs to be an object (associative array in PHP), as shown in the examples:
```python
char_attribute(0) == {"modifier": 0, "maximum_spell_level": -1, "extra_spells": []}
char_attribute(1) == {"modifier": -5, "maximum_spell_level": -1, "extra_spells": []}
char_attribute(5) == {"modifier": -3, "maximum_spell_level": -1, "extra_spells": []}
char_attribute(10) == {"modifier": 0, "maximum_spell_level": 0, "extra_spells": []}
char_attribute(20) == {"modifier": +5, "maximum_spell_level": 9, "extra_spells": [2,1,1,1,1]}
```
*Note: I didn't explain things in detail and just pointed out to the table on purpose, as my goal is also to train the pattern recognition skills of whoever is going to take this challenges, so do not complain about a summary description. Thanks :)*
In the same series:
* [D&D Character generator #1: attribute modifiers and spells](https://www.codewars.com/kata/d-and-d-character-generator-number-1-attribute-modifiers-and-spells/)
* [D&D Character generator #2: psion power points](https://www.codewars.com/kata/d-and-d-character-generator-number-2-psion-power-points/)
* [D&D Character generator #3: carrying capacity](https://www.codewars.com/kata/d-and-d-character-generator-number-3-carrying-capacity/)
Also feel free to reuse/extend the following starter code:
```python
def char_attribute(score):
```
|
{"functional": "_inputs = [[0], [1], [5], [10], [20]]\n_outputs = [[{'modifier': 0, 'maximum_spell_level': -1, 'extra_spells': []}], [{'modifier': -5, 'maximum_spell_level': -1, 'extra_spells': []}], [{'modifier': -3, 'maximum_spell_level': -1, 'extra_spells': []}], [{'modifier': 0, 'maximum_spell_level': 0, 'extra_spells': []}], [{'modifier': 5, 'maximum_spell_level': 9, 'extra_spells': [2, 1, 1, 1, 1]}]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(char_attribute(*i), o[0])"}
| 520
| 285
|
coding
|
Solve the programming task below in a Python markdown code block.
A circular array of length N is defined as follows: N integers A_{1},A_{2},…,A_{N} are placed in a circle in such a way that for each 1 ≤ i < N, A_{i} and A_{i+1} are adjacent, and A_{1} and A_{N} are also adjacent.
You are given a circular array A of length N. At the end of each second, the following changes are executed in the array: If A_{i} > 0 then the elements which are adjacent to A_{i}, will get incremented by 1, for all 1 ≤ i ≤ N.
For example, consider the array A = [0, 0, 0, 2, 0, 0, 0, 5].
Initially A_{4} and A_{8} are greater than zero. So after one second, A_{3}, A_{5}, A_{1} and A_{7} will get incremented by 1. Hence the array will become A = [1, 0, 1, 2, 1, 0, 1, 5].
After two seconds, the array becomes A = [2, 2, 2, 4, 2, 2, 2, 7]. Note that the value of A_{4} has become 4, because both, A_{3} and A_{5} were greater than zero after one second.
What will be the sum of elements present in the array A after K seconds?
------ Input Format ------
- The first line will contain T, number of testcases. Then T testcases follow.
- The first line of each testcase contains 2 space separated integers N and K.
- The second line of each testcase line contains N integers A_{1}, A_{2}, \dots, A_{N}.
------ Output Format ------
For each testcase, output in a single line containing the sum of the all the elements present in the array A after K seconds.
------ Constraints ------
$1 ≤ T ≤ 10^{4}$
$3 ≤ N ≤ 10^{5}$
$0 ≤ A_{i} ≤ 10^{6}$
$0 ≤ K ≤ 10^{9}$
- Sum of $N$ over all test cases does not exceed $10^{6}$.
----- Sample Input 1 ------
4
6 1
0 1 0 1 0 0
3 0
0 1 2
8 2
0 0 0 2 0 0 0 5
3 10
1 2 3
----- Sample Output 1 ------
6
3
23
66
----- explanation 1 ------
Test Case 1: After one second, the array will become $A = [1, 1, 2, 1, 1, 0]$. So the sum of elements present in the array is = $1 + 1 + 2 + 1 + 1 + 0 = 6$.
Test Case 2: No change will be executed in the array as $K = 0$. So the required sum will be equal to 3.
|
{"inputs": ["4\n6 1\n0 1 0 1 0 0\n3 0\n0 1 2\n8 2\n0 0 0 2 0 0 0 5\n3 10\n1 2 3"], "outputs": ["6\n3\n23\n66"]}
| 702
| 77
|
coding
|
Solve the programming task below in a Python markdown code block.
Ivan is collecting coins. There are only $N$ different collectible coins, Ivan has $K$ of them. He will be celebrating his birthday soon, so all his $M$ freinds decided to gift him coins. They all agreed to three terms: Everyone must gift as many coins as others. All coins given to Ivan must be different. Not less than $L$ coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
-----Input-----
The only line of input contains 4 integers $N$, $M$, $K$, $L$ ($1 \le K \le N \le 10^{18}$; $1 \le M, \,\, L \le 10^{18}$) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
-----Output-----
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
-----Examples-----
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
-----Note-----
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
|
{"inputs": ["2 1 1 1\n", "7 4 1 6\n", "4 4 2 2\n", "5 2 2 3\n", "5 3 2 1\n", "5 4 3 2\n", "1 1 1 1\n", "7 4 1 4\n"], "outputs": ["2", "-1", "1", "-1", "1", "-1", "-1", "-1"]}
| 410
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Mobile Display Keystrokes
Do you remember the old mobile display keyboards? Do you also remember how inconvenient it was to write on it?
Well, here you have to calculate how much keystrokes you have to do for a specific word.
This is the layout:
Return the amount of keystrokes of input str (! only letters, digits and special characters in lowercase included in layout without whitespaces !)
e.g:
mobileKeyboard("123") => 3 (1+1+1)
mobileKeyboard("abc") => 9 (2+3+4)
mobileKeyboard("codewars") => 26 (4+4+2+3+2+2+4+5)
Also feel free to reuse/extend the following starter code:
```python
def mobile_keyboard(s):
```
|
{"functional": "_inputs = [[''], ['123'], ['codewars'], ['zruf'], ['thisisasms'], ['longwordwhichdontreallymakessense']]\n_outputs = [[0], [3], [26], [16], [37], [107]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(mobile_keyboard(*i), o[0])"}
| 177
| 204
|
coding
|
Solve the programming task below in a Python markdown code block.
A disease is spreading through ChefLand!
The disease spreads as follows:
At the end of day 0, a single person is infected with the disease.
During the next 10 days, the number of infected people doubles each day, until the disease has spread to all people in ChefLand.
From day 11 onwards, the number of infected people triples each day, until the disease has spread to all people in ChefLand.
You are given the population of ChefLand N and a day D. How many people in ChefLand are infected at the end of day D?
------ Input Format ------
- The first line of input contains a single integer T, denoting the number of test cases. The description of T test cases follows.
- Each test case consists of a single line containing two space-separated integers N and D — the population of ChefLand and the day for which you need to find the number of infected people, respectively.
------ Output Format ------
- For each test case, print one line containing a single integer — the number of infected people in ChefLand at the end of day D.
------ Constraints ------
$1 ≤ T ≤ 300$
$1 ≤ N ≤ 10^{8}$
$0 ≤ D ≤ 10^{8}$
------ subtasks ------
Subtask 1 (30 points): $D ≤ 20$
Subtask 2 (70 points): Original constraints
----- Sample Input 1 ------
4
100 3
2000 10
6000 11
10 11
----- Sample Output 1 ------
8
1024
3072
10
----- explanation 1 ------
Test Case 1:
- At the end of day $1$, the number of infected people is $2 \times 1 = 2$.
- At the end of day $2$, the number of infected people is $2 \times 2 = 4$.
- At the end of day $3$, the number of infected people is $2 \times 4 = 8$.
Test Case 2: Following the rules in the statement, it can be seen that at the end of day $10$, the total number of infected people is $1024$.
Test Case 3: Note that starting at day $11$, the number of infected people triples each day, $3 \times 1024 = 3072$.
Test Case 4: At the end of day $3$, the number of infected people is $8$. Since there are only $10$ people in ChefLand (which is less than $2 \times 8 = 16$), at the end of day $4$ all people in ChefLand are infected and thus the number of infected people is $10$ for all days from day $4$ onwards, including day $11$.
|
{"inputs": ["4\n100 3\n2000 10\n6000 11\n10 11"], "outputs": ["8\n1024\n3072\n10"]}
| 631
| 53
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a function that accepts a string, and returns true if it is in the form of a phone number. Assume that any integer from 0-9 in any of the spots will produce a valid phone number.
Only worry about the following format:
(123) 456-7890 (don't forget the space after the close parentheses)
Examples:
```
validPhoneNumber("(123) 456-7890") => returns true
validPhoneNumber("(1111)555 2345") => returns false
validPhoneNumber("(098) 123 4567") => returns false
```
Also feel free to reuse/extend the following starter code:
```python
def validPhoneNumber(phoneNumber):
```
|
{"functional": "_inputs = [['(123) 456-7890'], ['(1111)555 2345'], ['(098) 123 4567'], ['(123)456-7890'], ['abc(123)456-7890'], ['(123)456-7890abc'], ['abc(123)456-7890abc'], ['abc(123) 456-7890'], ['(123) 456-7890abc'], ['abc(123) 456-7890abc']]\n_outputs = [[True], [False], [False], [False], [False], [False], [False], [False], [False], [False]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(validPhoneNumber(*i), o[0])"}
| 185
| 342
|
coding
|
Solve the programming task below in a Python markdown code block.
Find the union of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$.
Constraints
* $1 \leq n, m \leq 200,000$
* $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$
* $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ... \; a_{n-1}$
$m$
$b_0 \; b_1 \; ... \; b_{m-1}$
Elements of $A$ and $B$ are given in ascending order respectively. There are no duplicate elements in each set.
Output
Print elements in the union in ascending order. Print an element in a line.
Example
Input
3
1 5 8
2
5 9
Output
1
5
8
9
|
{"inputs": ["3\n1 5 8\n2\n5 8", "3\n1 3 8\n2\n5 8", "3\n1 5 8\n2\n4 9", "3\n1 6 8\n2\n5 8", "3\n1 3 8\n2\n2 8", "3\n1 5 8\n2\n3 9", "3\n2 3 8\n2\n5 8", "3\n1 3 8\n2\n3 8"], "outputs": ["1\n5\n8\n", "1\n3\n5\n8\n", "1\n4\n5\n8\n9\n", "1\n5\n6\n8\n", "1\n2\n3\n8\n", "1\n3\n5\n8\n9\n", "2\n3\n5\n8\n", "1\n3\n8\n"]}
| 273
| 206
|
coding
|
Solve the programming task below in a Python markdown code block.
Polycarp bought a new expensive painting and decided to show it to his $n$ friends. He hung it in his room. $n$ of his friends entered and exited there one by one. At one moment there was no more than one person in the room. In other words, the first friend entered and left first, then the second, and so on.
It is known that at the beginning (before visiting friends) a picture hung in the room. At the end (after the $n$-th friend) it turned out that it disappeared. At what exact moment it disappeared — there is no information.
Polycarp asked his friends one by one. He asked each one if there was a picture when he entered the room. Each friend answered one of three:
no (response encoded with 0);
yes (response encoded as 1);
can't remember (response is encoded with ?).
Everyone except the thief either doesn't remember or told the truth. The thief can say anything (any of the three options).
Polycarp cannot understand who the thief is. He asks you to find out the number of those who can be considered a thief according to the answers.
-----Input-----
The first number $t$ ($1 \le t \le 10^4$) — the number of test cases in the test.
The following is a description of test cases.
The first line of each test case contains one string $s$ (length does not exceed $2 \cdot 10^5$) — a description of the friends' answers, where $s_i$ indicates the answer of the $i$-th friend. Each character in the string is either 0 or 1 or ?.
The given regularity is described in the actual situation. In particular, on the basis of answers, at least one friend can be suspected of stealing a painting.
It is guaranteed that the sum of string lengths over the entire input data set does not exceed $2 \cdot 10^5$.
-----Output-----
Output one positive (strictly more zero) number – the number of people who could steal the picture based on the data shown.
-----Examples-----
Input
8
0
1
1110000
?????
1?1??0?0
0?0???
??11
??0??
Output
1
1
2
5
4
1
1
3
-----Note-----
In the first case, the answer is $1$ since we had exactly $1$ friend.
The second case is similar to the first.
In the third case, the suspects are the third and fourth friends (we count from one). It can be shown that no one else could be the thief.
In the fourth case, we know absolutely nothing, so we suspect everyone.
|
{"inputs": ["1\n??????????????????????????????\n", "8\n0\n1\n1110000\n?????\n1?1??0?0\n0?0???\n??11\n??0??\n"], "outputs": ["30\n", "1\n1\n2\n5\n4\n1\n1\n3\n"]}
| 594
| 85
|
coding
|
Solve the programming task below in a Python markdown code block.
A dragon symbolizes wisdom, power and wealth. On Lunar New Year's Day, people model a dragon with bamboo strips and clothes, raise them with rods, and hold the rods high and low to resemble a flying dragon.
A performer holding the rod low is represented by a 1, while one holding it high is represented by a 2. Thus, the line of performers can be represented by a sequence a1, a2, ..., an.
Little Tommy is among them. He would like to choose an interval [l, r] (1 ≤ l ≤ r ≤ n), then reverse al, al + 1, ..., ar so that the length of the longest non-decreasing subsequence of the new sequence is maximum.
A non-decreasing subsequence is a sequence of indices p1, p2, ..., pk, such that p1 < p2 < ... < pk and ap1 ≤ ap2 ≤ ... ≤ apk. The length of the subsequence is k.
Input
The first line contains an integer n (1 ≤ n ≤ 2000), denoting the length of the original sequence.
The second line contains n space-separated integers, describing the original sequence a1, a2, ..., an (1 ≤ ai ≤ 2, i = 1, 2, ..., n).
Output
Print a single integer, which means the maximum possible length of the longest non-decreasing subsequence of the new sequence.
Examples
Input
4
1 2 1 2
Output
4
Input
10
1 1 2 2 2 1 1 2 2 1
Output
9
Note
In the first example, after reversing [2, 3], the array will become [1, 1, 2, 2], where the length of the longest non-decreasing subsequence is 4.
In the second example, after reversing [3, 7], the array will become [1, 1, 1, 1, 2, 2, 2, 2, 2, 1], where the length of the longest non-decreasing subsequence is 9.
|
{"inputs": ["1\n2\n", "2\n1 2\n", "2\n2 1\n", "2\n1 1\n", "2\n2 2\n", "3\n1 2 1\n", "3\n2 1 2\n", "3\n1 1 1\n"], "outputs": ["1\n", "2\n", "2\n", "2\n", "2\n", "3\n", "3\n", "3\n"]}
| 462
| 106
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef is the financial incharge of Chefland and one of his duties is identifying if any company has gained a monopolistic advantage in the market.
There are exactly 3 companies in the market each of whose revenues are denoted by R_{1}, R_{2} and R_{3} respectively. A company is said to have a monopolistic advantage if its revenue is strictly greater than the sum of the revenues of its competitors.
Given the revenue of the 3 companies, help Chef determine if any of them has a monopolistic advantage.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- Each test case consists of a single line of input containing three space separated integers R_{1}, R_{2} and R_{3} denoting the revenue of the three companies respectively.
------ Output Format ------
For each test case, output \texttt{YES} if any of the companies has a monopolistic advantage over its competitors, else output \texttt{NO}.
You may print each character of the string in uppercase or lowercase (for example, the strings \texttt{YeS}, \texttt{yEs}, \texttt{yes} and \texttt{YES} will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ R_{1}, R_{2}, R_{3} ≤ 10$
----- Sample Input 1 ------
4
1 1 1
1 2 4
2 10 3
1 2 3
----- Sample Output 1 ------
No
Yes
Yes
No
----- explanation 1 ------
Test case 1: All the companies have equal revenue so none have a monopolistic advantage.
Test case 2: The third company has a monopolistic advantage as $1 + 2 < 4$.
Test case 3: The second company has a monopolistic advantage as $2 + 3 < 10$.
|
{"inputs": ["4\n1 1 1\n1 2 4\n2 10 3\n1 2 3\n"], "outputs": ["No\nYes\nYes\nNo\n"]}
| 437
| 45
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an m x n integer matrix grid and an array queries of size k.
Find an array answer of size k such that for each integer queries[i] you start in the top left cell of the matrix and repeat the following process:
If queries[i] is strictly greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any adjacent cell in all 4 directions: up, down, left, and right.
Otherwise, you do not get any points, and you end this process.
After the process, answer[i] is the maximum number of points you can get. Note that for each query you are allowed to visit the same cell multiple times.
Return the resulting array answer.
Please complete the following python code precisely:
```python
class Solution:
def maxPoints(self, grid: List[List[int]], queries: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]) == [5,8,1]\n assert candidate(grid = [[5,2,1],[1,1,2]], queries = [3]) == [0]\n\n\ncheck(Solution().maxPoints)"}
| 215
| 89
|
coding
|
Solve the programming task below in a Python markdown code block.
------Read problems statements in Hindi,
Mandarin chinese
, Russian and Vietnamese as well. ------
At ShareChat, there are are plenty of interesting problems to solve. Here is one of them.
Given integers $A$, $B$ and $N$, you should calculate the [GCD] of $A^{N} + B^{N}$ and $|A - B|$. (Assume that $GCD(0, a) = a$ for any positive integer $a$). Since this number could be very large, compute it modulo $1000000007$ ($10^{9} + 7$).
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains three space-separated integers $A$, $B$ and $N$.
------ Output ------
For each test case, print a single line containing one integer — the required GCD modulo $10^{9} + 7$.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ A, B, N ≤ 10^{12}$
$B ≤ A$
------ Subtasks ------
Subtask #1 (10 points): $1 ≤ A, B, N ≤ 10$
Subtask #2 (40 points): $1 ≤ A, B, N ≤ 10^{9}$
Subtask #3 (50 points): original constraints
----- Sample Input 1 ------
2
10 1 1
9 1 5
----- Sample Output 1 ------
1
2
----- explanation 1 ------
Example case 1: $GCD(10^{1} + 1^{1}, 10 - 1) = GCD(11, 9) = 1$
Example case 2: $GCD(9^{5} + 1^{5}, 9 - 1) = GCD(59050, 8) = 2$
|
{"inputs": ["2\n10 1 1\n9 1 5"], "outputs": ["1\n2"]}
| 468
| 27
|
coding
|
Solve the programming task below in a Python markdown code block.
A new agent called Killjoy invented a virus COVID-2069 that infects accounts on Codeforces. Each account has a rating, described by an integer (it can possibly be negative or very large).
Killjoy's account is already infected and has a rating equal to $x$. Its rating is constant. There are $n$ accounts except hers, numbered from $1$ to $n$. The $i$-th account's initial rating is $a_i$. Any infected account (initially the only infected account is Killjoy's) instantly infects any uninfected account if their ratings are equal. This can happen at the beginning (before any rating changes) and after each contest. If an account is infected, it can not be healed.
Contests are regularly held on Codeforces. In each contest, any of these $n$ accounts (including infected ones) can participate. Killjoy can't participate. After each contest ratings are changed this way: each participant's rating is changed by an integer, but the sum of all changes must be equal to zero. New ratings can be any integer.
Find out the minimal number of contests needed to infect all accounts. You can choose which accounts will participate in each contest and how the ratings will change.
It can be proven that all accounts can be infected in some finite number of contests.
-----Input-----
The first line contains a single integer $t$ $(1 \le t \le 100)$ — the number of test cases. The next $2t$ lines contain the descriptions of all test cases.
The first line of each test case contains two integers $n$ and $x$ ($2 \le n \le 10^3$, $-4000 \le x \le 4000$) — the number of accounts on Codeforces and the rating of Killjoy's account.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ $(-4000 \le a_i \le 4000)$ — the ratings of other accounts.
-----Output-----
For each test case output the minimal number of contests needed to infect all accounts.
-----Example-----
Input
3
2 69
68 70
6 4
4 4 4 4 4 4
9 38
-21 83 50 -59 -77 15 -71 -78 20
Output
1
0
2
-----Note-----
In the first test case it's possible to make all ratings equal to $69$. First account's rating will increase by $1$, and second account's rating will decrease by $1$, so the sum of all changes will be equal to zero.
In the second test case all accounts will be instantly infected, because all ratings (including Killjoy's account's rating) are equal to $4$.
|
{"inputs": ["1\n2 2\n0 5\n", "1\n2 2\n0 5\n", "1\n2 2\n0 8\n", "1\n2 2\n0 0\n", "1\n2 2\n1 8\n", "1\n2 4\n0 0\n", "1\n2 1\n0 0\n", "1\n2 2\n-1 0\n"], "outputs": ["2\n", "2\n", "2\n", "2\n", "2\n", "2\n", "2\n", "2\n"]}
| 632
| 135
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef likes to play with array elements. His teacher has given him an array problem. But now he is busy as Christmas is coming. So, he needs your help. Can you help him to solve this problem.
You are given an array $(A1,A2,A3……AN)$ of length $N$. You have to create an another array using the given array in the following ways:
For each valid i, the ith element of the output array will be the sum of the ith element and (A[i])th element if $A[i]$ is less equal $N$.
Other wise for each valid i following the step below
i) Divide the value of $A[i]$ by 2 untill it will be less than$N$.
ii) then find the difference ($D$) between $N$ and $A[i]$.
iii) the ith element of the output array will be $Dth$ element.
-----Input:-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A1,A2,…,AN$.
-----Output:-----
- For each testcase, print new array in each line.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^5$
- $1\leq A1,A2.....AN \leq 10^7$
-----Sample Input:-----
2
5
2 4 5 7 9
4
5 4 2 3
-----Sample Output:-----
6 11 14 4 2
4 7 6 5
-----EXPLANATION:-----
For 1st test case: A1 = 2+4 =6, A2 = 4+7 =11 , A3 = 5+9 =14 , A4 > N (5) ,So A4/2 = 3 then A4 = A[5 -3] , A4=A[2]=4, And A5 =A[1]=2. Then array becomes 6,11,14,4,2.
|
{"inputs": ["2\n5\n2 4 5 7 9\n4\n5 4 2 3"], "outputs": ["6 11 14 4 2\n4 7 6 5"]}
| 508
| 52
|
coding
|
Solve the programming task below in a Python markdown code block.
The knight is standing in front of a long and narrow hallway. A princess is waiting at the end of it.
In a hallway there are three doors: a red door, a green door and a blue door. The doors are placed one after another, however, possibly in a different order. To proceed to the next door, the knight must first open the door before.
Each door can be only opened with a key of the corresponding color. So three keys: a red key, a green key and a blue key — are also placed somewhere in the hallway. To open the door, the knight should first pick up the key of its color.
The knight has a map of the hallway. It can be transcribed as a string, consisting of six characters:
R, G, B — denoting red, green and blue doors, respectively;
r, g, b — denoting red, green and blue keys, respectively.
Each of these six characters appears in the string exactly once.
The knight is standing at the beginning of the hallway — on the left on the map.
Given a map of the hallway, determine if the knight can open all doors and meet the princess at the end of the hallway.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 720$) — the number of testcases.
Each testcase consists of a single string. Each character is one of R, G, B (for the doors), r, g, b (for the keys), and each of them appears exactly once.
-----Output-----
For each testcase, print YES if the knight can open all doors. Otherwise, print NO.
-----Examples-----
Input
4
rgbBRG
RgbrBG
bBrRgG
rgRGBb
Output
YES
NO
YES
NO
-----Note-----
In the first testcase, the knight first collects all keys, then opens all doors with them.
In the second testcase, there is a red door right in front of the knight, but he doesn't have a key for it.
In the third testcase, the key to each door is in front of each respective door, so the knight collects the key and uses it immediately three times.
In the fourth testcase, the knight can't open the blue door.
|
{"inputs": ["4\nrgbBRG\nRgbrBG\nbBrRgG\nrgRGBb\n"], "outputs": ["YES\nNO\nYES\nNO\n"]}
| 482
| 39
|
coding
|
Solve the programming task below in a Python markdown code block.
Polycarpus works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consists of some number of words (that don't contain WUB). To make the dubstep remix of this song, Polycarpus inserts a certain number of words "WUB" before the first word of the song (the number may be zero), after the last word (the number may be zero), and between words (at least one between any pair of neighbouring words), and then the boy glues together all the words, including "WUB", in one string and plays the song at the club.
For example, a song with words "I AM X" can transform into a dubstep remix as "WUBWUBIWUBAMWUBWUBX" and cannot transform into "WUBWUBIAMWUBX".
Recently, Jonny has heard Polycarpus's new dubstep track, but since he isn't into modern music, he decided to find out what was the initial song that Polycarpus remixed. Help Jonny restore the original song.
## Input
The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters
## Output
Return the words of the initial song that Polycarpus used to make a dubsteb remix. Separate the words with a space.
## Examples
```python
song_decoder("WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB")
# => WE ARE THE CHAMPIONS MY FRIEND
```
Also feel free to reuse/extend the following starter code:
```python
def song_decoder(song):
```
|
{"functional": "_inputs = [['AWUBBWUBC'], ['AWUBWUBWUBBWUBWUBWUBC'], ['WUBAWUBBWUBCWUB'], ['RWUBWUBWUBLWUB'], ['WUBJKDWUBWUBWBIRAQKFWUBWUBYEWUBWUBWUBWVWUBWUB'], ['WUBKSDHEMIXUJWUBWUBRWUBWUBWUBSWUBWUBWUBHWUBWUBWUB'], ['QWUBQQWUBWUBWUBIWUBWUBWWWUBWUBWUBJOPJPBRH'], ['WUBWUBOWUBWUBWUBIPVCQAFWYWUBWUBWUBQWUBWUBWUBXHDKCPYKCTWWYWUBWUBWUBVWUBWUBWUBFZWUBWUB'], ['WUBYYRTSMNWUWUBWUBWUBCWUBWUBWUBCWUBWUBWUBFSYUINDWOBVWUBWUBWUBFWUBWUBWUBAUWUBWUBWUBVWUBWUBWUBJB'], ['AWUBWUBWUB'], ['AWUBBWUBCWUBD'], ['WUBWWUBWUBWUBUWUBWUBBWUB'], ['WUWUBBWWUBUB'], ['WUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUABWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUB'], ['U'], ['WUWUB'], ['UBWUB'], ['WUWUBUBWUBUWUB'], ['WUBWWUBAWUB'], ['WUUUUU'], ['WUBWUBA']]\n_outputs = [['A B C'], ['A B C'], ['A B C'], ['R L'], ['JKD WBIRAQKF YE WV'], ['KSDHEMIXUJ R S H'], ['Q QQ I WW JOPJPBRH'], ['O IPVCQAFWY Q XHDKCPYKCTWWY V FZ'], ['YYRTSMNWU C C FSYUINDWOBV F AU V JB'], ['A'], ['A B C D'], ['W U B'], ['WU BW UB'], ['WUAB'], ['U'], ['WU'], ['UB'], ['WU UB U'], ['W A'], ['WUUUUU'], ['A']]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(song_decoder(*i), o[0])"}
| 404
| 752
|
coding
|
Solve the programming task below in a Python markdown code block.
Fafa owns a company that works on huge projects. There are n employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.
Fafa finds doing this every time is very tiring for him. So, he decided to choose the best l employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader.
Given the number of employees n, find in how many ways Fafa could choose the number of team leaders l in such a way that it is possible to divide employees between them evenly.
-----Input-----
The input consists of a single line containing a positive integer n (2 ≤ n ≤ 10^5) — the number of employees in Fafa's company.
-----Output-----
Print a single integer representing the answer to the problem.
-----Examples-----
Input
2
Output
1
Input
10
Output
3
-----Note-----
In the second sample Fafa has 3 ways: choose only 1 employee as a team leader with 9 employees under his responsibility. choose 2 employees as team leaders with 4 employees under the responsibility of each of them. choose 5 employees as team leaders with 1 employee under the responsibility of each of them.
|
{"inputs": ["2\n", "3\n", "4\n", "6\n", "9\n", "4\n", "3\n", "6\n"], "outputs": ["1\n", "1\n", "2\n", "3\n", "2\n", "2", "1", "3"]}
| 368
| 67
|
coding
|
Solve the programming task below in a Python markdown code block.
Let's call a sequence $b_1, b_2, b_3 \dots, b_{k - 1}, b_k$ almost increasing if $$\min(b_1, b_2) \le \min(b_2, b_3) \le \dots \le \min(b_{k - 1}, b_k).$$ In particular, any sequence with no more than two elements is almost increasing.
You are given a sequence of integers $a_1, a_2, \dots, a_n$. Calculate the length of its longest almost increasing subsequence.
You'll be given $t$ test cases. Solve each test case independently.
Reminder: a subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of independent test cases.
The first line of each test case contains a single integer $n$ ($2 \le n \le 5 \cdot 10^5$) — the length of the sequence $a$.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$) — the sequence itself.
It's guaranteed that the total sum of $n$ over all test cases doesn't exceed $5 \cdot 10^5$.
-----Output-----
For each test case, print one integer — the length of the longest almost increasing subsequence.
-----Examples-----
Input
3
8
1 2 7 3 2 1 2 3
2
2 1
7
4 1 5 2 6 3 7
Output
6
2
7
-----Note-----
In the first test case, one of the optimal answers is subsequence $1, 2, 7, 2, 2, 3$.
In the second and third test cases, the whole sequence $a$ is already almost increasing.
|
{"inputs": ["3\n8\n1 2 7 3 2 1 2 3\n2\n2 1\n7\n4 1 5 2 6 3 7\n", "3\n8\n1 2 7 3 2 1 2 5\n2\n2 1\n7\n4 1 5 2 6 3 7\n", "3\n8\n1 2 7 6 2 1 1 3\n2\n2 1\n7\n4 1 5 2 6 3 7\n", "3\n8\n1 2 7 1 2 1 1 3\n2\n2 1\n7\n4 1 5 2 6 3 7\n", "3\n8\n1 2 7 6 2 1 4 4\n2\n2 1\n7\n7 3 3 2 6 3 7\n", "3\n8\n1 2 7 1 2 1 1 3\n2\n2 1\n7\n4 1 5 2 6 1 7\n", "3\n8\n1 2 1 3 1 1 2 7\n2\n2 1\n7\n4 1 5 2 4 3 7\n", "3\n8\n1 2 5 6 2 1 1 5\n2\n2 1\n7\n1 1 6 2 1 6 7\n"], "outputs": ["6\n2\n7\n", "6\n2\n7\n", "5\n2\n7\n", "7\n2\n7\n", "6\n2\n6\n", "7\n2\n6\n", "8\n2\n7\n", "5\n2\n6\n"]}
| 461
| 422
|
coding
|
Solve the programming task below in a Python markdown code block.
The chef is trying to decode some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
4
1
2
3
4
-----Sample Output:-----
1
12
3
123
45
6
1234
567
89
10
-----EXPLANATION:-----
No need, else pattern can be decode easily.
|
{"inputs": ["4\n1\n2\n3\n4"], "outputs": ["1\n12\n3\n123\n45\n6\n1234\n567\n89\n10"]}
| 207
| 49
|
coding
|
Solve the programming task below in a Python markdown code block.
There is an integer sequence A of length N whose values are unknown.
Given is an integer sequence B of length N-1 which is known to satisfy the following:
B_i \geq \max(A_i, A_{i+1})
Find the maximum possible sum of the elements of A.
-----Constraints-----
- All values in input are integers.
- 2 \leq N \leq 100
- 0 \leq B_i \leq 10^5
-----Input-----
Input is given from Standard Input in the following format:
N
B_1 B_2 ... B_{N-1}
-----Output-----
Print the maximum possible sum of the elements of A.
-----Sample Input-----
3
2 5
-----Sample Output-----
9
A can be, for example, ( 2 , 1 , 5 ), ( -1 , -2 , -3 ), or ( 2 , 2 , 5 ). Among those candidates, A = ( 2 , 2 , 5 ) has the maximum possible sum.
|
{"inputs": ["2\n5", "2\n4", "2\n1", "2\n0", "2\n2", "2\n6", "2\n9", "2\n3"], "outputs": ["10\n", "8\n", "2\n", "0\n", "4\n", "12\n", "18\n", "6"]}
| 236
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
Given an integer, take the (mean) average of each pair of consecutive digits. Repeat this process until you have a single integer, then return that integer. e.g.
Note: if the average of two digits is not an integer, round the result **up** (e.g. the average of 8 and 9 will be 9)
## Examples
```
digitsAverage(246) ==> 4
original: 2 4 6
\ / \ /
1st iter: 3 5
\ /
2nd iter: 4
digitsAverage(89) ==> 9
original: 8 9
\ /
1st iter: 9
```
p.s. for a bigger challenge, check out the [one line version](https://www.codewars.com/kata/one-line-task-digits-average) of this kata by myjinxin2015!
Also feel free to reuse/extend the following starter code:
```python
def digits_average(input):
```
|
{"functional": "_inputs = [[246], [89], [2], [245], [345], [346], [3700]]\n_outputs = [[4], [9], [2], [4], [5], [5], [4]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(digits_average(*i), o[0])"}
| 240
| 202
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
Given an array $A$ of size $N$. Find the maximum value of the expression $a * b + a - b$ where $a$ and $b$ are $2$ distinct elements of the array.
------ Input: ------
First line will contain $T$, number of testcases. Then the testcases follow.
Each testcase contains of two lines of input.
First line will contain $N$, number of elements of the array.
Second line contains $N$ space separated integers, elements of the array $A$.
------ Output: ------
For each testcase, output in a single line answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 20$
$2 ≤ N ≤ 10^{5}$
$-10^{9} ≤ A_{i} ≤ 10^{9}$
----- Sample Input 1 ------
2
2
2 2
3
5 3 2
----- Sample Output 1 ------
4
17
----- explanation 1 ------
Case 1: Only possible pair is $[2, 2]$ for which answer = $2 * 2 + 2 - 2$ = $4$.
Case 2: There are six possible pairs.
For pairs $[2, 3]$ and $[3, 2]$, answer = $2 * 3 + max(2 - 3, 3 - 2)$ = $7$
For pairs $[3, 5]$ and $[5, 3]$ answer = $5 * 3 + max(3 - 5, 5 - 3)$ = $17$ and
For the pairs $[2, 5]$ and $[5, 2]$, answer = $2 * 5 + max(2 - 5, 5 - 2)$ = $13$.
So final answer is maximum of $\{7, 17, 13\}$ = $17$.
|
{"inputs": ["2\n2 \n2 2\n3\n5 3 2"], "outputs": ["4\n17"]}
| 461
| 31
|
coding
|
Solve the programming task below in a Python markdown code block.
Beppa and her circle of geek friends keep up to date on a group chat in the instant messaging app SwerChat$^{\text{TM}}$.
The group has $n$ members, excluding Beppa. Each of those members has a unique ID between $1$ and $n$. When a user opens a group chat, SwerChat$^{\text{TM}}$ displays the list of other members of that group, sorted by decreasing times of last seen online (so the member who opened the chat most recently is the first of the list). However, the times of last seen are not displayed.
Today, Beppa has been busy all day: she has only opened the group chat twice, once at 9:00 and once at 22:00. Both times, she wrote down the list of members in the order they appeared at that time. Now she wonders: what is the minimum number of other members that must have been online at least once between 9:00 and 22:00?
Beppa is sure that no two members are ever online at the same time and no members are online when Beppa opens the group chat at 9:00 and 22:00.
-----Input-----
Each test contains multiple test cases. The first line contains an integer $t$ ($1 \leq t \leq 10000$) — the number of test cases. The descriptions of the $t$ test cases follow.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 10^5$) — the number of members of the group excluding Beppa.
The second line contains $n$ integers $a_1, \, a_2, \, \dots, \, a_n$ ($1 \le a_i \le n$) — the list of IDs of the members, sorted by decreasing times of last seen online at 9:00.
The third line contains $n$ integers $b_1, \, b_2, \, \dots, \, b_n$ ($1 \le b_i \le n$) — the list of IDs of the members, sorted by decreasing times of last seen online at 22:00.
For all $1\le i < j\le n$, it is guaranteed that $a_i \ne a_j$ and $b_i \ne b_j$.
It is also guaranteed that the sum of the values of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case, print the minimum number of members that must have been online between 9:00 and 22:00.
-----Examples-----
Input
4
5
1 4 2 5 3
4 5 1 2 3
6
1 2 3 4 5 6
1 2 3 4 5 6
8
8 2 4 7 1 6 5 3
5 6 1 4 8 2 7 3
1
1
1
Output
2
0
4
0
-----Note-----
In the first test case, members $4, 5$ must have been online between 9:00 and 22:00.
In the second test case, it is possible that nobody has been online between 9:00 and 22:00.
|
{"inputs": ["4\n5\n1 4 2 5 3\n4 5 1 2 3\n6\n1 2 3 4 5 6\n1 2 3 4 5 6\n8\n8 2 4 7 1 6 5 3\n5 6 1 4 8 2 7 3\n1\n1\n1\n"], "outputs": ["2\n0\n4\n0\n"]}
| 762
| 108
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a function
```python
alternate_sort(l)
```
that combines the elements of an array by sorting the elements ascending by their **absolute value** and outputs negative and non-negative integers alternatingly (starting with the negative value, if any).
E.g.
```python
alternate_sort([5, -42, 2, -3, -4, 8, -9,]) == [-3, 2, -4, 5, -9, 8, -42]
alternate_sort([5, -42, 2, -3, -4, 8, 9]) == [-3, 2, -4, 5, -42, 8, 9]
alternate_sort([5, 2, -3, -4, 8, -9]) == [-3, 2, -4, 5, -9, 8]
alternate_sort([5, 2, 9, 3, 8, 4]) == [2, 3, 4, 5, 8, 9]
```
Also feel free to reuse/extend the following starter code:
```python
def alternate_sort(l):
```
|
{"functional": "_inputs = [[[5, 2, -3, -9, -4, 8]], [[5, -42, 2, -3, -4, 8, 9]], [[5, -42, 8, 2, -3, -4, 9]], [[5, -42, -8, 2, -3, -4, -9]], [[5, 2, 3, 4, 8, 9]], [[-5, -2, -3, -4, -8, -9]], [[-5, -2, 3, 4, -8, 0, -9]], [[-5, -2, 3, 9, 4, -2, -8, 0, 9, -9]]]\n_outputs = [[[-3, 2, -4, 5, -9, 8]], [[-3, 2, -4, 5, -42, 8, 9]], [[-3, 2, -4, 5, -42, 8, 9]], [[-3, 2, -4, 5, -8, -9, -42]], [[2, 3, 4, 5, 8, 9]], [[-2, -3, -4, -5, -8, -9]], [[-2, 0, -5, 3, -8, 4, -9]], [[-2, 0, -2, 3, -5, 4, -8, 9, -9, 9]]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(alternate_sort(*i), o[0])"}
| 265
| 502
|
coding
|
Solve the programming task below in a Python markdown code block.
A `bouncy number` is a positive integer whose digits neither increase nor decrease. For example, 1235 is an increasing number, 5321 is a decreasing number, and 2351 is a bouncy number. By definition, all numbers under 100 are non-bouncy, and 101 is the first bouncy number.
Determining if a number is bouncy is easy, but counting all bouncy numbers with N digits can be challenging for large values of N. To complete this kata, you must write a function that takes a number N and return the count of bouncy numbers with N digits. For example, a "4 digit" number includes zero-padded, smaller numbers, such as 0001, 0002, up to 9999.
For clarification, the bouncy numbers between 100 and 125 are: 101, 102, 103, 104, 105, 106, 107, 108, 109, 120, and 121.
Also feel free to reuse/extend the following starter code:
```python
def bouncy_count(n):
```
|
{"functional": "_inputs = [[0], [1], [2], [3], [4], [5], [6], [10], [20], [50]]\n_outputs = [[0], [0], [0], [525], [8325], [95046], [987048], [9999722967], [99999999999959940181], [99999999999999999999999999999999999999912040301674]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(bouncy_count(*i), o[0])"}
| 284
| 303
|
coding
|
Solve the programming task below in a Python markdown code block.
Polycarpus adores TV series. Right now he is ready to finish watching a season of a popular sitcom "Graph Theory". In total, the season has n episodes, numbered with integers from 1 to n.
Polycarpus watches episodes not one by one but in a random order. He has already watched all the episodes except for one. Which episode has Polycaprus forgotten to watch?
-----Input-----
The first line of the input contains integer n (2 ≤ n ≤ 100000) — the number of episodes in a season. Assume that the episodes are numbered by integers from 1 to n.
The second line contains n - 1 integer a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ n) — the numbers of episodes that Polycarpus has watched. All values of a_{i} are distinct.
-----Output-----
Print the number of the episode that Polycarpus hasn't watched.
-----Examples-----
Input
10
3 8 10 1 7 9 6 5 2
Output
4
|
{"inputs": ["2\n1\n", "2\n2\n", "2\n1\n", "2\n2\n", "3\n1 2\n", "3\n1 3\n", "3\n2 3\n", "3\n2 1\n"], "outputs": ["2\n", "1\n", " 2", " 1", "3\n", "2\n", "1\n", "3\n"]}
| 249
| 96
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
There are N chairs placed in circular order. Some of the chairs are empty while others have a child sitting in it. You are required to change the places of the children so that all the children sit next to each other (i.e. they form a connected segment). You can do that by doing the following operation a number of times:
Choose a child and tell him to walk around the circle in clockwise order or anti-clockwise order until he finds the first empty chair, and tell him to sit there.
What is the minimum number of operations required to make all children sit next to each other?
------ Input ------
The first line contains T, the number of test-cases.
The first line of each test-case contains N, the number of chairs.
The second line of each test-case contains a binary string of length N. If the i-th character is 1 then the i-th chair has a child initially. Otherwise (i.e. the i-th character is 0) it's empty.
------ Output ------
For each test case, output a single line containing a single integer donating minimum number of operations needed.
------ Constraints ------
$1 ≤ T ≤ 5,000$
$1 ≤ sum of N in all test-cases ≤ 10^{6}$
$at least one chair will be occupied$
----- Sample Input 1 ------
1
8
10001010
----- Sample Output 1 ------
2
----- explanation 1 ------
The initial configuration is:
1
0 0
1 0
0 0
1
We can tell the child who is boldened to move counter-clockwise, and the new configuration will be:
0
1 0
1 0
0 0
1
because he has moved to the first empty chair on his way.
Now, we again tell him to move counter-clockwise, and now the new configuration will be:
0
0 0
1 0
1 0
1
because he moved counter-clockwise, found an occupied chair, and hence kept moving. The next chair was vacant, and he sat down there.
Note that, in this example, we moved the same child twice, but this need not be the case. We can move different children in different moves.
You can check that this is the best we can do, and 2 is the minimum.
|
{"inputs": ["1\n8\n10001010"], "outputs": ["2"]}
| 531
| 23
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer array nums, return the number of non-empty subarrays with the leftmost element of the subarray not larger than other elements in the subarray.
A subarray is a contiguous part of an array.
Please complete the following python code precisely:
```python
class Solution:
def validSubarrays(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,4,2,5,3]) == 11\n assert candidate(nums = [3,2,1]) == 3\n assert candidate(nums = [2,2,2]) == 6\n\n\ncheck(Solution().validSubarrays)"}
| 94
| 73
|
coding
|
Solve the programming task below in a Python markdown code block.
Nick is interested in prime numbers. Once he read about Goldbach problem. It states that every even integer greater than 2 can be expressed as the sum of two primes. That got Nick's attention and he decided to invent a problem of his own and call it Noldbach problem. Since Nick is interested only in prime numbers, Noldbach problem states that at least k prime numbers from 2 to n inclusively can be expressed as the sum of three integer numbers: two neighboring prime numbers and 1. For example, 19 = 7 + 11 + 1, or 13 = 5 + 7 + 1.
Two prime numbers are called neighboring if there are no other prime numbers between them.
You are to help Nick, and find out if he is right or wrong.
Input
The first line of the input contains two integers n (2 ≤ n ≤ 1000) and k (0 ≤ k ≤ 1000).
Output
Output YES if at least k prime numbers from 2 to n inclusively can be expressed as it was described above. Otherwise output NO.
Examples
Input
27 2
Output
YES
Input
45 7
Output
NO
Note
In the first sample the answer is YES since at least two numbers can be expressed as it was described (for example, 13 and 19). In the second sample the answer is NO since it is impossible to express 7 prime numbers from 2 to 45 in the desired form.
|
{"inputs": ["2 0\n", "4 7\n", "9 0\n", "2 9\n", "3 7\n", "8 0\n", "3 4\n", "3 0\n"], "outputs": ["YES\n", "NO\n", "YES\n", "NO\n", "NO\n", "YES\n", "NO\n", "YES\n"]}
| 334
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
Chef and his friend Chefu decided to go on a trip. The trip takes place over the next $N$ days (numbered 1 through $N$). There are $K$ different places Chef and Chefu could visit (numbered 1 through $K$). They have written a sequence $A_{1}, A_{2}, \ldots, A_{N}$ which denotes the plan of the trip during these $N$ days; however, the plan is not completed yet. For each valid $i$, they want to visit the place $A_{i}$ on the $i$-th day, but if $A_{i} = -1$, then they haven't decided which place to visit on that day.
Chef and his friend do not want to visit the same place two days in a row, but they can visit a place more than once in total. It is not necessary to visit all the places during the trip. Determine whether it is possible to complete the plan in such a way that this condition is satisfied. If it is possible, find one way of completing the plan.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $K$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, print a line containing the string "YES" if it's possible the complete the plan or "NO" otherwise.
If it's possible to complete the plan, print a second line containing $N$ space-separated integers denoting the sequence $A_{1}, A_{2}, \ldots, A_{N}$ after completing the plan. If there is more than one solution, you may print any one.
------ Constraints ------
$1 ≤ T ≤ 1,000$
$1 ≤ N ≤ 10^{5}$
$2 ≤ K ≤ 10^{5}$
$1 ≤ A_{i} ≤ K$ or $A_{i} = -1$ for each valid $i$
if $A_{i} \neq -1$ and $A_{i+1} \neq -1$, then $A_{i} \neq A_{i+1}$, for each valid $i$
the sum of $N$ over all test cases does not exceed $10^{6}$
------ Subtasks ------
Subtask #1 (30 points):
$N ≤ 1,000$
$K = 2$
the sum of $N$ over all test cases does not exceed $10,000$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
5
5 3
-1 -1 -1 -1 -1
4 5
1 2 3 5
3 2
1 -1 2
4 2
1 -1 -1 1
6 4
-1 -1 4 -1 2 -1
----- Sample Output 1 ------
YES
1 2 1 2 1
YES
1 2 3 5
NO
NO
YES
1 2 4 1 2 1
|
{"inputs": ["5\n5 3\n-1 -1 -1 -1 -1\n4 5\n1 2 3 5\n3 2\n1 -1 2\n4 2\n1 -1 -1 1\n6 4\n-1 -1 4 -1 2 -1"], "outputs": ["YES\n1 2 1 2 1\nYES\n1 2 3 5\nNO\nNO\nYES\n1 2 4 1 2 1"]}
| 768
| 116
|
coding
|
Solve the programming task below in a Python markdown code block.
Snark and Philip are preparing the problemset for the upcoming pre-qualification round for semi-quarter-finals. They have a bank of n problems, and they want to select any non-empty subset of it as a problemset.
k experienced teams are participating in the contest. Some of these teams already know some of the problems. To make the contest interesting for them, each of the teams should know at most half of the selected problems.
Determine if Snark and Philip can make an interesting problemset!
-----Input-----
The first line contains two integers n, k (1 ≤ n ≤ 10^5, 1 ≤ k ≤ 4) — the number of problems and the number of experienced teams.
Each of the next n lines contains k integers, each equal to 0 or 1. The j-th number in the i-th line is 1 if j-th team knows i-th problem and 0 otherwise.
-----Output-----
Print "YES" (quotes for clarity), if it is possible to make an interesting problemset, and "NO" otherwise.
You can print each character either upper- or lowercase ("YeS" and "yes" are valid when the answer is "YES").
-----Examples-----
Input
5 3
1 0 1
1 1 0
1 0 0
1 0 0
1 0 0
Output
NO
Input
3 2
1 0
1 1
0 1
Output
YES
-----Note-----
In the first example you can't make any interesting problemset, because the first team knows all problems.
In the second example you can choose the first and the third problems.
|
{"inputs": ["1 1\n0\n", "1 1\n1\n", "1 1\n0\n", "1 1\n1\n", "1 2\n0 0\n", "2 1\n0\n0\n", "1 2\n0 1\n", "1 2\n0 0\n"], "outputs": ["YES\n", "NO\n", "YES\n", "NO\n", "YES\n", "YES\n", "NO\n", "YES\n"]}
| 362
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Abhi and his friends (Shanky,Anku and Pandey) love to play with strings. Abhi invented a simple game. He will give a string S to his friends. Shanky and Anku will play the game while Pandey is just a spectator. Shanky will traverse the string from beginning (left to right) while Anku will traverse from last (right to left). Both have to find the first character they encounter during their traversal,that appears only once in the entire string. Winner will be one whose character is alphabetically more superior(has higher ASCII value). When it is not possible to decide the winner by comparing their characters, Pandey will be the winner.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case contains a string S having only lowercase alphabets ( a..z ).
-----Output-----
For each test case, output a single line containing "SHANKY" if Shanky is the winner or "ANKU" if Anku is the winner or "PANDEY" if the winner is Pandey. Output your answer without quotes.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 < |S| ≤ 10^5
-----Example-----
Input:
3
google
breakraekb
aman
Output:
SHANKY
PANDEY
ANKU
-----Explanation-----
Example case 2. Both Shanky and Anku can not find any such character. Hence it is not possible to decide the winner between these two. So Pandey is the winner.
|
{"inputs": ["3\ngoogle\nbreakraekb\naman"], "outputs": ["SHANKY\nPANDEY\nANKU"]}
| 353
| 32
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has to travel to another place. For this, he can avail any one of two cab services.
The first cab service charges X rupees.
The second cab service charges Y rupees.
Chef wants to spend the minimum amount of money. Which cab service should Chef take?
------ Input Format ------
- The first line will contain T - the number of test cases. Then the test cases follow.
- The first and only line of each test case contains two integers X and Y - the prices of first and second cab services respectively.
------ Output Format ------
For each test case, output FIRST if the first cab service is cheaper, output SECOND if the second cab service is cheaper, output ANY if both cab services have the same price.
You may print each character of FIRST, SECOND and ANY in uppercase or lowercase (for example, any, aNy, Any will be considered identical).
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ X, Y ≤ 100$
----- Sample Input 1 ------
3
30 65
42 42
90 50
----- Sample Output 1 ------
FIRST
ANY
SECOND
----- explanation 1 ------
Test case $1$: The first cab service is cheaper than the second cab service.
Test case $2$: Both the cab services have the same price.
Test case $3$: The second cab service is cheaper than the first cab service.
|
{"inputs": ["3\n30 65\n42 42\n90 50\n"], "outputs": ["FIRST\nANY\nSECOND\n"]}
| 313
| 36
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef wants to appear in a competitive exam. To take the exam, there are following requirements:
Minimum age limit is X (i.e. Age should be greater than or equal to X).
Age should be strictly less than Y.
Chef's current Age is A. Find whether he is currently eligible to take the exam or not.
------ Input Format ------
- First line will contain T, number of test cases. Then the test cases follow.
- Each test case consists of a single line of input, containing three integers X, Y, and A as mentioned in the statement.
------ Output Format ------
For each test case, output YES if Chef is eligible to give the exam, NO otherwise.
You may print each character of the string in uppercase or lowercase (for example, the strings YES, yEs, yes, and yeS will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$20 ≤ X < Y ≤ 40$
$10 ≤ A ≤ 50$
----- Sample Input 1 ------
5
21 34 30
25 31 31
22 29 25
20 40 15
28 29 28
----- Sample Output 1 ------
YES
NO
YES
NO
YES
----- explanation 1 ------
Test case $1$: The age of Chef is $30$. His age satisfies the minimum age limit as $30 ≥ 21$. Also, it is less than the upper limit as $30 < 34$. Thus, Chef is eligible to take the exam.
Test case $2$: The age of Chef is $31$. His age satisfies the minimum age limit as $31 ≥ 25$. But, it is not less than the upper limit as $31 \nless 31$. Thus, Chef is not eligible to take the exam.
Test case $3$: The age of Chef is $25$. His age satisfies the minimum age limit as $25 ≥ 22$. Also, it is less than the upper limit as $25 < 29$. Thus, Chef is eligible to take the exam.
Test case $4$: The age of Chef is $15$. His age does not satisfy the minimum age limit as $15 < 20$. Thus, Chef is not eligible to take the exam.
|
{"inputs": ["5\n21 34 30\n25 31 31\n22 29 25\n20 40 15\n28 29 28\n"], "outputs": ["YES\nNO\nYES\nNO\nYES\n"]}
| 523
| 67
|
coding
|
Solve the programming task below in a Python markdown code block.
Number of tanka
Wishing to die in the spring under the flowers
This is one of the famous tanka poems that Saigyo Hoshi wrote. Tanka is a type of waka poem that has been popular in Japan for a long time, and most of it consists of five phrases and thirty-one sounds of 5, 7, 5, 7, and 7.
By the way, the number 57577 consists of two types, 5 and 7. Such a positive integer whose decimal notation consists of exactly two types of numbers is called a tanka number. For example, 10, 12, 57577, 25252 are tanka numbers, but 5, 11, 123, 20180701 are not tanka songs.
A positive integer N is given. Find the Nth smallest tanka number.
Input
The input consists of up to 100 datasets. Each dataset is represented in the following format.
> N
The integer N satisfies 1 ≤ N ≤ 1018.
The end of the input is represented by a single zero line.
Output
For each dataset, output the Nth smallest tanka number on one line.
Sample Input
1
2
3
390
1124
1546
314159265358979323
0
Output for the Sample Input
Ten
12
13
2020
25252
57577
7744444777744474777777774774744777747477444774744744
Example
Input
1
2
3
390
1124
1546
314159265358979323
0
Output
10
12
13
2020
25252
57577
7744444777744474777777774774744777747477444774744744
|
{"inputs": ["1\n2\n5\n390\n216\n442\n877438609014957\n0", "1\n2\n5\n390\n216\n763\n877438609014957\n0", "1\n2\n5\n390\n216\n442\n3724086920287233\n0", "1\n2\n5\n390\n216\n763\n1563679537664695\n0", "1\n3\n5\n390\n216\n763\n1563679537664695\n0", "1\n3\n6\n19\n216\n291\n34091156012094062\n0", "1\n3\n6\n19\n216\n291\n45420024717148297\n0", "1\n6\n6\n19\n216\n291\n45420024717148297\n0"], "outputs": ["10\n12\n15\n2020\n599\n2777\n31311111133131133111311331311311333131313131\n", "10\n12\n15\n2020\n599\n7979\n31311111133131133111311331311311333131313131\n", "10\n12\n15\n2020\n599\n2777\n3553553333533553335535555555553353335353535335\n", "10\n12\n15\n2020\n599\n7979\n177711171711171111177177111717171111177777711\n", "10\n13\n15\n2020\n599\n7979\n177711171711171111177177111717171111177777711\n", "10\n13\n16\n30\n599\n884\n5552555255255522555225522222525252552225222252252\n", "10\n13\n16\n30\n599\n884\n9999799797977797997797997999979779779777779797779\n", "10\n16\n16\n30\n599\n884\n9999799797977797997797997999979779779777779797779\n"]}
| 537
| 878
|
coding
|
Solve the programming task below in a Python markdown code block.
You throw a ball vertically upwards with an initial speed `v (in km per hour)`. The height `h` of the ball at each time `t`
is given by `h = v*t - 0.5*g*t*t` where `g` is Earth's gravity `(g ~ 9.81 m/s**2)`. A device is recording at every **tenth
of second** the height of the ball.
For example with `v = 15 km/h` the device gets something of the following form:
`(0, 0.0), (1, 0.367...), (2, 0.637...), (3, 0.808...), (4, 0.881..) ...`
where the first number is the time in tenth of second and the second number the height in meter.
# Task
Write a function `max_ball` with parameter `v (in km per hour)` that returns the `time in tenth of second`
of the maximum height recorded by the device.
# Examples:
`max_ball(15) should return 4`
`max_ball(25) should return 7`
# Notes
- Remember to convert the velocity from km/h to m/s or from m/s in km/h when necessary.
- The maximum height recorded by the device is not necessarily the maximum height reached by the ball.
Also feel free to reuse/extend the following starter code:
```python
def max_ball(v0):
```
|
{"functional": "_inputs = [[37], [45], [99], [85], [136], [52], [16], [127], [137], [14]]\n_outputs = [[10], [13], [28], [24], [39], [15], [5], [36], [39], [4]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(max_ball(*i), o[0])"}
| 331
| 229
|
coding
|
Solve the programming task below in a Python markdown code block.
Tanya wants to go on a journey across the cities of Berland. There are $n$ cities situated along the main railroad line of Berland, and these cities are numbered from $1$ to $n$.
Tanya plans her journey as follows. First of all, she will choose some city $c_1$ to start her journey. She will visit it, and after that go to some other city $c_2 > c_1$, then to some other city $c_3 > c_2$, and so on, until she chooses to end her journey in some city $c_k > c_{k - 1}$. So, the sequence of visited cities $[c_1, c_2, \dots, c_k]$ should be strictly increasing.
There are some additional constraints on the sequence of cities Tanya visits. Each city $i$ has a beauty value $b_i$ associated with it. If there is only one city in Tanya's journey, these beauty values imply no additional constraints. But if there are multiple cities in the sequence, then for any pair of adjacent cities $c_i$ and $c_{i + 1}$, the condition $c_{i + 1} - c_i = b_{c_{i + 1}} - b_{c_i}$ must hold.
For example, if $n = 8$ and $b = [3, 4, 4, 6, 6, 7, 8, 9]$, there are several three possible ways to plan a journey: $c = [1, 2, 4]$; $c = [3, 5, 6, 8]$; $c = [7]$ (a journey consisting of one city is also valid).
There are some additional ways to plan a journey that are not listed above.
Tanya wants her journey to be as beautiful as possible. The beauty value of the whole journey is the sum of beauty values over all visited cities. Can you help her to choose the optimal plan, that is, to maximize the beauty value of the journey?
-----Input-----
The first line contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of cities in Berland.
The second line contains $n$ integers $b_1$, $b_2$, ..., $b_n$ ($1 \le b_i \le 4 \cdot 10^5$), where $b_i$ is the beauty value of the $i$-th city.
-----Output-----
Print one integer — the maximum beauty of a journey Tanya can choose.
-----Examples-----
Input
6
10 7 1 9 10 15
Output
26
Input
1
400000
Output
400000
Input
7
8 9 26 11 12 29 14
Output
55
-----Note-----
The optimal journey plan in the first example is $c = [2, 4, 5]$.
The optimal journey plan in the second example is $c = [1]$.
The optimal journey plan in the third example is $c = [3, 6]$.
|
{"inputs": ["2\n2 1\n", "2\n1 1\n", "3\n3 6 5\n", "3\n1 1 2\n", "1\n400000\n", "6\n1 1 1 2 3 4\n", "6\n1 1 1 1 1 2\n", "2\n399999 400000\n"], "outputs": ["2\n", "1\n", "8\n", "3\n", "400000\n", "10\n", "3\n", "799999\n"]}
| 708
| 146
|
coding
|
Solve the programming task below in a Python markdown code block.
Tunnel formula
One day while exploring an abandoned mine, you found a long formula S written in the mine. If you like large numbers, you decide to take out the choke and add `(` or `)` so that the result of the formula calculation is as large as possible. If it has to be a mathematical formula even after adding it, how many can it be at the maximum?
There is enough space between the letters, and you can add as many `(` or `)` as you like. If the final formula is a formula, you may write `(` or `)` so that the correspondence of the first parenthesis is broken (see Sample 2). Also, here, <expr> defined by the following BNF is called a mathematical formula. All numbers in the formula are single digits.
<expr> :: = "(" <expr> ")"
| <term> "+" <term>
| <term> "-" <term>
<term> :: = <digit> | <expr>
<digit> :: = "0" | "1" | "2" | "3" | "4"
| "5" | "6" | "7" | "8" | "9"
Constraints
* 3 ≤ | S | ≤ 200
S represents a mathematical formula.
Input Format
Input is given from standard input in the following format.
S
Output Format
Output the answer as an integer.
Sample Input 1
1- (2 + 3-4 + 5)
Sample Output 1
Five
1- (2 + 3- (4 + 5)) is the maximum.
Sample Input 2
1- (2 + 3 + 4)
Sample Output 2
0
(1- (2 + 3) + 4) is the maximum.
Sample Input 3
1- (2 + 3)
Sample Output 3
-Four
Note that 1- (2) + (3) is not the formula here.
Example
Input
1-(2+3-4+5)
Output
5
|
{"inputs": ["0-(2+3-4+5)", "0-(2+3-3+5)", "2-(2+3-4+5)", "1-(3+2-4+5)", "2-(2-3+4+5)", "0-(3+4-4+5)", "3+(2-4-4+5)", "2-(2+2-4+5)"], "outputs": ["4\n", "3\n", "6\n", "5\n", "12\n", "2\n", "10\n", "7\n"]}
| 443
| 129
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a method named `getExponent(n,p)` that returns the largest integer exponent `x` such that p^(x) evenly divides `n`. if `p<=1` the method should return `null`/`None` (throw an `ArgumentOutOfRange` exception in C#).
Also feel free to reuse/extend the following starter code:
```python
def get_exponent(n, p):
```
|
{"functional": "_inputs = [[27, 3]]\n_outputs = [[3]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(get_exponent(*i), o[0])"}
| 97
| 159
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array A_{1}, A_{2}, \dots, A_{N} of length N. You can perform the following operation any number of times (possibly 0 times) :
Choose any two indices i and j and replace either A_{i} or A_{j} with \gcd(A_{i},A_{j}).
Find the minimum possible sum (ie. A_{1} + A_{2} + \dots + A_{N}) that you can achieve, and output that.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- The first line of each test case contains an integer N - the length of the array A.
- The second line of each test case contains N space-separated integers A_{1},A_{2},\ldots,A_{N}.
------ Output Format ------
For each test case, output on a new line the minimum sum of the array that can be achieved.
------ Constraints ------
$1 ≤ T ≤ 100$
$2 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 10^{9}$
- The sum of $N$ over all test cases won't exceed $3 * 10^{5}$.
------ subtasks ------
Subtask 1 (10 points): $1 ≤ M ≤ 10$
Subtask 2 (20 points): The sum of $N$ across all test cases won't exceed $20$.
Subtask 3 (70 points): No further constraints.
----- Sample Input 1 ------
2
2
5 10
3
2 2 6
----- Sample Output 1 ------
10
6
----- explanation 1 ------
Test case $1$: Choose $i=1,j=2$ and replace $A_{2}$ with $\gcd(5,10)=5$.
Test case $2$: Choose $i=1,j=3$ and replace $A_{3}$ with $\gcd(2,6)=2$.
|
{"inputs": ["2\n2\n5 10\n3\n2 2 6\n"], "outputs": ["10\n6\n"]}
| 454
| 32
|
coding
|
Solve the programming task below in a Python markdown code block.
Bears love candies and games involving eating them. Limak and Bob play the following game. Limak eats 1 candy, then Bob eats 2 candies, then Limak eats 3 candies, then Bob eats 4 candies, and so on. Once someone can't eat what he is supposed to eat, he loses.
Limak can eat at most A candies in total (otherwise he would become sick), while Bob can eat at most B candies in total.
Who will win the game?
Print "Limak" or "Bob" accordingly.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The only line of each test case contains two integers A and B denoting the maximum possible number of candies Limak can eat and the maximum possible number of candies Bob can eat respectively.
-----Output-----
For each test case, output a single line containing one string — the name of the winner ("Limak" or "Bob" without the quotes).
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ A, B ≤ 1000
-----Example-----
Input:
10
3 2
4 2
1 1
1 2
1 3
9 3
9 11
9 12
9 1000
8 11
Output:
Bob
Limak
Limak
Bob
Bob
Limak
Limak
Bob
Bob
Bob
-----Explanation-----
Test case 1. We have A = 3 and B = 2. Limak eats 1 candy first, and then Bob eats 2 candies. Then Limak is supposed to eat 3 candies but that would mean 1 + 3 = 4 candies in total. It's impossible because he can eat at most A candies, so he loses. Bob wins, and so we print "Bob".
Test case 2. Now we have A = 4 and B = 2. Limak eats 1 candy first, and then Bob eats 2 candies, then Limak eats 3 candies (he has 1 + 3 = 4 candies in total, which is allowed because it doesn't exceed A). Now Bob should eat 4 candies but he can't eat even a single one (he already ate 2 candies). Bob loses and Limak is the winner.
Test case 8. We have A = 9 and B = 12. The game looks as follows:
- Limak eats 1 candy.
- Bob eats 2 candies.
- Limak eats 3 candies (4 in total).
- Bob eats 4 candies (6 in total).
- Limak eats 5 candies (9 in total).
- Bob eats 6 candies (12 in total).
- Limak is supposed to eat 7 candies but he can't — that would exceed A. Bob wins.
|
{"inputs": ["10\n3 2\n4 2\n1 1\n1 2\n1 3\n9 3\n9 11\n9 12\n9 1000\n8 11"], "outputs": ["Bob\nLimak\nLimak\nBob\nBob\nLimak\nLimak\nBob\nBob\nBob"]}
| 629
| 81
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
The diameter of a tree is the number of edges in the longest path in that tree.
There is an undirected tree of n nodes labeled from 0 to n - 1. You are given a 2D array edges where edges.length == n - 1 and edges[i] = [ai, bi] indicates that there is an undirected edge between nodes ai and bi in the tree.
Return the diameter of the tree.
Please complete the following python code precisely:
```python
class Solution:
def treeDiameter(self, edges: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(edges = [[0,1],[0,2]]) == 2\n assert candidate(edges = [[0,1],[1,2],[2,3],[1,4],[4,5]]) == 4\n\n\ncheck(Solution().treeDiameter)"}
| 138
| 68
|
coding
|
Solve the programming task below in a Python markdown code block.
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018.
Input
First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing subsequences.
Next n lines contains one integer ai (1 ≤ ai ≤ n) each — elements of sequence. All values ai are different.
Output
Print one integer — the answer to the problem.
Examples
Input
5 2
1
2
3
5
4
Output
7
|
{"inputs": ["1 0\n1\n", "1 1\n1\n", "1 2\n1\n", "1 4\n1\n", "1 7\n1\n", "1 3\n1\n", "2 1\n1\n2\n", "2 1\n2\n1\n"], "outputs": ["1\n", "0\n", "0\n", "0\n", "0\n", "0\n", "1\n", "0\n"]}
| 157
| 106
|
coding
|
Solve the programming task below in a Python markdown code block.
For a positive integer n, we denote the integer obtained by reversing the decimal notation of n (without leading zeroes) by rev(n). For example, rev(123) = 321 and rev(4000) = 4.
You are given a positive integer D. How many positive integers N satisfy rev(N) = N + D?
Constraints
* D is an integer.
* 1 ≤ D < 10^9
Input
Input is given from Standard Input in the following format:
D
Output
Print the number of the positive integers N such that rev(N) = N + D.
Examples
Input
63
Output
2
Input
75
Output
0
Input
864197532
Output
1920
|
{"inputs": ["9", "8", "3", "6", "5", "7", "1", "2"], "outputs": ["8\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 181
| 62
|
coding
|
Solve the programming task below in a Python markdown code block.
You play your favourite game yet another time. You chose the character you didn't play before. It has $str$ points of strength and $int$ points of intelligence. Also, at start, the character has $exp$ free experience points you can invest either in strength or in intelligence (by investing one point you can either raise strength by $1$ or raise intelligence by $1$).
Since you'd like to make some fun you want to create a jock character, so it has more strength than intelligence points (resulting strength is strictly greater than the resulting intelligence).
Calculate the number of different character builds you can create (for the purpose of replayability) if you must invest all free points. Two character builds are different if their strength and/or intellect are different.
-----Input-----
The first line contains the single integer $T$ ($1 \le T \le 100$) — the number of queries. Next $T$ lines contain descriptions of queries — one per line.
This line contains three integers $str$, $int$ and $exp$ ($1 \le str, int \le 10^8$, $0 \le exp \le 10^8$) — the initial strength and intelligence of the character and the number of free points, respectively.
-----Output-----
Print $T$ integers — one per query. For each query print the number of different character builds you can create.
-----Example-----
Input
4
5 3 4
2 1 0
3 5 5
4 10 6
Output
3
1
2
0
-----Note-----
In the first query there are only three appropriate character builds: $(str = 7, int = 5)$, $(8, 4)$ and $(9, 3)$. All other builds are either too smart or don't use all free points.
In the second query there is only one possible build: $(2, 1)$.
In the third query there are two appropriate builds: $(7, 6)$, $(8, 5)$.
In the fourth query all builds have too much brains.
|
{"inputs": ["4\n9 3 8\n2 1 1\n1 5 5\n4 0 4\n", "4\n1 4 8\n4 0 0\n1 5 5\n8 1 6\n", "4\n9 3 8\n2 1 1\n1 5 1\n4 0 4\n", "4\n8 4 8\n2 1 1\n1 5 5\n8 1 6\n", "4\n1 4 8\n4 0 0\n1 5 5\n8 1 1\n", "4\n1 4 8\n6 0 0\n1 5 5\n8 1 1\n", "4\n5 3 4\n2 1 0\n3 5 5\n4 10 6\n", "4\n5 3 4\n2 1 0\n1 5 5\n4 10 6\n"], "outputs": ["7\n1\n1\n4\n", "3\n1\n1\n7\n", "7\n1\n0\n4\n", "6\n1\n1\n7\n", "3\n1\n1\n2\n", "3\n1\n1\n2\n", "3\n1\n2\n0\n", "3\n1\n1\n0\n"]}
| 456
| 312
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an array of strings words. Each element of words consists of two lowercase English letters.
Create the longest possible palindrome by selecting some elements from words and concatenating them in any order. Each element can be selected at most once.
Return the length of the longest palindrome that you can create. If it is impossible to create any palindrome, return 0.
A palindrome is a string that reads the same forward and backward.
Please complete the following python code precisely:
```python
class Solution:
def longestPalindrome(self, words: List[str]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(words = [\"lc\",\"cl\",\"gg\"]) == 6\n assert candidate(words = [\"ab\",\"ty\",\"yt\",\"lc\",\"cl\",\"ab\"]) == 8\n assert candidate(words = [\"cc\",\"ll\",\"xx\"]) == 2\n\n\ncheck(Solution().longestPalindrome)"}
| 134
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
The only difference between easy and hard versions is the length of the string.
You are given a string $s$ and a string $t$, both consisting only of lowercase Latin letters. It is guaranteed that $t$ can be obtained from $s$ by removing some (possibly, zero) number of characters (not necessary contiguous) from $s$ without changing order of remaining characters (in other words, it is guaranteed that $t$ is a subsequence of $s$).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from $s$ of maximum possible length such that after removing this substring $t$ will remain a subsequence of $s$.
If you want to remove the substring $s[l;r]$ then the string $s$ will be transformed to $s_1 s_2 \dots s_{l-1} s_{r+1} s_{r+2} \dots s_{|s|-1} s_{|s|}$ (where $|s|$ is the length of $s$).
Your task is to find the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Input-----
The first line of the input contains one string $s$ consisting of at least $1$ and at most $2 \cdot 10^5$ lowercase Latin letters.
The second line of the input contains one string $t$ consisting of at least $1$ and at most $2 \cdot 10^5$ lowercase Latin letters.
It is guaranteed that $t$ is a subsequence of $s$.
-----Output-----
Print one integer — the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$.
-----Examples-----
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3
|
{"inputs": ["m\nm\n", "m\nm\n", "td\nt\n", "aa\na\n", "td\nt\n", "aa\na\n", "dt\nt\n", "ct\nt\n"], "outputs": ["0\n", "0\n", "1\n", "1\n", "1\n", "1\n", "1\n", "1\n"]}
| 481
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
How can you tell an extrovert from an
introvert at NSA? Va gur ryringbef,
gur rkgebireg ybbxf ng gur BGURE thl'f fubrf.
I found this joke on USENET, but the punchline is scrambled. Maybe you can decipher it?
According to Wikipedia, ROT13 (http://en.wikipedia.org/wiki/ROT13) is frequently used to obfuscate jokes on USENET.
Hint: For this task you're only supposed to substitue characters. Not spaces, punctuation, numbers etc.
Test examples:
```
rot13("EBG13 rknzcyr.") == "ROT13 example.";
rot13("This is my first ROT13 excercise!" == "Guvf vf zl svefg EBG13 rkprepvfr!"
```
Also feel free to reuse/extend the following starter code:
```python
def rot13(message):
```
|
{"functional": "_inputs = [['EBG13 rknzcyr.'], [\"How can you tell an extrovert from an\\nintrovert at NSA? Va gur ryringbef,\\ngur rkgebireg ybbxf ng gur BGURE thl'f fubrf.\"], ['123'], ['Guvf vf npghnyyl gur svefg xngn V rire znqr. Gunaxf sbe svavfuvat vg! :)'], ['@[`{']]\n_outputs = [['ROT13 example.'], [\"Ubj pna lbh gryy na rkgebireg sebz na\\nvagebireg ng AFN? In the elevators,\\nthe extrovert looks at the OTHER guy's shoes.\"], ['123'], ['This is actually the first kata I ever made. Thanks for finishing it! :)'], ['@[`{']]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(rot13(*i), o[0])"}
| 215
| 341
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given a string columnTitle that represents the column title as appears in an Excel sheet, return its corresponding column number.
For example:
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
Please complete the following python code precisely:
```python
class Solution:
def titleToNumber(self, columnTitle: str) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(columnTitle = \"A\") == 1\n assert candidate(columnTitle = \"AB\") == 28\n assert candidate(columnTitle = \"ZY\") == 701\n\n\ncheck(Solution().titleToNumber)"}
| 110
| 62
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a string S of length N consisting of ( and ). Your task is to insert some number of ( and ) into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
- () is a correct bracket sequence.
- If X is a correct bracket sequence, the concatenation of (, X and ) in this order is also a correct bracket sequence.
- If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
- Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
-----Constraints-----
- The length of S is N.
- 1 ≤ N ≤ 100
- S consists of ( and ).
-----Input-----
Input is given from Standard Input in the following format:
N
S
-----Output-----
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of ( and ) into S.
-----Sample Input-----
3
())
-----Sample Output-----
(())
|
{"inputs": ["3\n)()", "3\n)))", "3\n))(", "3\n(()", "3\n())", "3\n())\n", "6\n)())))", "6\n())())"], "outputs": ["()()\n", "((()))\n", "(())()\n", "(())\n", "(())", "(())\n", "(((()())))\n", "((())())\n"]}
| 254
| 93
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.