task_type
stringclasses 1
value | problem
stringlengths 261
3.34k
| answer
stringlengths 35
6.15k
| problem_tokens
int64 62
774
| answer_tokens
int64 12
2.04k
|
|---|---|---|---|---|
coding
|
Solve the programming task below in a Python markdown code block.
There are N boxes arranged in a circle. The i-th box contains A_i stones.
Determine whether it is possible to remove all the stones from the boxes by repeatedly performing the following operation:
* Select one box. Let the box be the i-th box. Then, for each j from 1 through N, remove exactly j stones from the (i+j)-th box. Here, the (N+k)-th box is identified with the k-th box.
Note that the operation cannot be performed if there is a box that does not contain enough number of stones to be removed.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If it is possible to remove all the stones from the boxes, print `YES`. Otherwise, print `NO`.
Examples
Input
5
4 5 1 2 3
Output
YES
Input
5
6 9 12 10 8
Output
YES
Input
4
1 2 3 1
Output
NO
|
{"inputs": ["4\n2 2 3 1", "4\n2 2 3 2", "4\n2 1 3 2", "4\n4 1 3 2", "4\n4 1 3 0", "4\n4 1 3 1", "4\n4 1 6 2", "4\n0 1 9 6"], "outputs": ["NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n"]}
| 268
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
Remember the movie with David Bowie: 'The Labyrinth'?
You can remember your childhood here: https://www.youtube.com/watch?v=2dgmgub8mHw
In this scene the girl is faced with two 'Knights" and two doors. One door leads the castle where the Goblin King and her kid brother is, the other leads to certain death. She can ask the 'Knights' a question to find out which door is the right one to go in. But...
One of them always tells the truth, and the other one always lies.
In this Kata one of the 'Knights' is on a coffee break, leaving the other one to watch the doors. You have to determine if the one there is the Knight(Truth teller) or Knave(Liar) based off of what he ```says```
Create a function:
```
def knight_or_knave(says):
# returns if knight or knave
```
Your function should determine if the input '''says''' is True or False and then return:
```'Knight!'``` if True or ```'Knave! Do not trust.'``` if False
Input will be either boolean values, or strings.
The strings will be simple statements that will be either true or false, or evaluate to True or False.
See example test cases for, well... examples
You will porbably need to ```eval(says)```
But note: Eval is evil, and is only here for this Kata as a game.
And remember the number one rule of The Labyrinth, even if it is easy, Don't ever say 'that was easy.'
Also feel free to reuse/extend the following starter code:
```python
def knight_or_knave(said):
```
|
{"functional": "_inputs = [[True], [False], ['4+2==5'], ['2+2==4'], ['not True and False or False or False'], ['3 is 3'], ['True'], ['not True'], ['2+2==5'], ['4+1==5'], ['4 is 3'], ['9+2==3'], ['105+30076==30181'], ['3 is 3 is 3 is 9'], ['False'], ['\"orange\" is not \"red\"'], ['4 is \"blue\"'], ['True is not False']]\n_outputs = [['Knight!'], ['Knave! Do not trust.'], ['Knave! Do not trust.'], ['Knight!'], ['Knave! Do not trust.'], ['Knight!'], ['Knight!'], ['Knave! Do not trust.'], ['Knave! Do not trust.'], ['Knight!'], ['Knave! Do not trust.'], ['Knave! Do not trust.'], ['Knight!'], ['Knave! Do not trust.'], ['Knave! Do not trust.'], ['Knight!'], ['Knave! Do not trust.'], ['Knight!']]\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(knight_or_knave(*i), o[0])"}
| 376
| 399
|
coding
|
Solve the programming task below in a Python markdown code block.
Given few numbers, you need to print out the digits that are not being used.
Example:
```python
unused_digits(12, 34, 56, 78) # "09"
unused_digits(2015, 8, 26) # "3479"
```
Note:
- Result string should be sorted
- The test case won't pass Integer with leading zero
Also feel free to reuse/extend the following starter code:
```python
def unused_digits(*args):
```
|
{"functional": "_inputs = [[12, 34, 56, 78], [2015, 8, 26], [276, 575], [643], [864, 896, 744], [364, 500, 715, 730], [93, 10, 11, 40], [1, 11, 111, 1111, 11111], [9, 87, 654, 3210]]\n_outputs = [['09'], ['3479'], ['013489'], ['0125789'], ['01235'], ['289'], ['25678'], ['023456789'], ['']]\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(unused_digits(*i), o[0])"}
| 125
| 346
|
coding
|
Solve the programming task below in a Python markdown code block.
A soldier wants to buy w bananas in the shop. He has to pay k dollars for the first banana, 2k dollars for the second one and so on (in other words, he has to pay i·k dollars for the i-th banana).
He has n dollars. How many dollars does he have to borrow from his friend soldier to buy w bananas?
-----Input-----
The first line contains three positive integers k, n, w (1 ≤ k, w ≤ 1000, 0 ≤ n ≤ 10^9), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants.
-----Output-----
Output one integer — the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.
-----Examples-----
Input
3 17 4
Output
13
|
{"inputs": ["1 2 1\n", "1 1 1\n", "1 5 6\n", "1 5 6\n", "1 2 1\n", "1 1 1\n", "1 0 1\n", "3 0 4\n"], "outputs": ["0", "0", "16", "16\n", "0\n", "0\n", "1\n", "30\n"]}
| 202
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Given an array of integers, calculate the ratios of its elements that are positive, negative, and zero. Print the decimal value of each fraction on a new line with $6$ places after the decimal.
Note: This challenge introduces precision problems. The test cases are scaled to six decimal places, though answers with absolute error of up to $10^{-4}$ are acceptable.
Example
$arr=[1,1,0,-1,-1]$
There are $n=5$ elements, two positive, two negative and one zero. Their ratios are $\frac25=0.40000$, $\frac25=0.40000$ and $\frac15=0.200000$. Results are printed as:
0.400000
0.400000
0.200000
Function Description
Complete the plusMinus function in the editor below.
plusMinus has the following parameter(s):
int arr[n]: an array of integers
Print
Print the ratios of positive, negative and zero values in the array. Each value should be printed on a separate line with $6$ digits after the decimal. The function should not return a value.
Input Format
The first line contains an integer, $n$, the size of the array.
The second line contains $n$ space-separated integers that describe $arr[n]$.
Constraints
$0 < n \leq100$
$-100\leq arr[i]\leq100$
Output Format
Print the following $3$ lines, each to $6$ decimals:
proportion of positive values
proportion of negative values
proportion of zeros
Sample Input
STDIN Function
----- --------
6 arr[] size n = 6
-4 3 -9 0 4 1 arr = [-4, 3, -9, 0, 4, 1]
Sample Output
0.500000
0.333333
0.166667
Explanation
There are $3$ positive numbers, $2$ negative numbers, and $1$ zero in the array.
The proportions of occurrence are positive: $\frac{3}{6}=0.500000$, negative: $\frac{2}{6}=0.333333$ and zeros: $\frac{1}{6}=0.166667$.
|
{"inputs": ["6 \n-4 3 -9 0 4 1\n"], "outputs": ["0.500000\n0.333333\n0.166667\n"]}
| 556
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
Two players (numbered $\mbox{1}$ and $2$) are playing a game of Tower Breakers! The rules of the game are as follows:
Player $\mbox{1}$ always moves first.
Initially there are $N$ towers of various heights.
The players move in alternating turns. In each turn, a player must choose a tower of height $\mbox{X}$ and break it down into $\mathbf{Y}$ towers, each of height $\mbox{z}$. The numbers $\mathbf{Y}$ and $\mbox{z}$ must satisfy $Y\times Z=X$ and $Y>1$.
If the current player is unable to make any move, they lose the game.
Given the value of $N$ and the respective height values for all towers, can you determine who will win, assuming both players always move optimally? If the first player wins, print $\mbox{1}$; otherwise, print $2$.
Input Format
The first line contains an integer, $\mathbf{T}$, denoting the number of test cases.
The $2T$ subsequent lines define the test cases. Each test case is described by two lines:
An integer, $N$, denoting the number of towers.
$N$ space-separated integers, $h_0,h_1,\ldots,h_{N-1}$, where each $h_i$ describes the height of tower $\boldsymbol{i}$.
Constraints
$1\leq T\leq200$
$1\leq N\leq100$
$1\leq h_i\leq10^5$
Output Format
For each test case, print a single integer denoting the winner (i.e., either $\mbox{1}$ or $2$) on a new line.
Sample Input
2
2
1 2
3
1 2 3
Sample Output
1
2
Explanation
In the first test case, the first player simply breaks down the second tower of height $2$ into two towers of height $\mbox{1}$ and wins.
In the second test case, there are only two possible moves:
Break the second tower into $2$ towers of height $\mbox{1}$.
Break the third tower into $3$ towers of height $\mbox{1}$.
Whichever move player $\mbox{1}$ makes, player $2$ can make the other move and win the game.
|
{"inputs": ["2\n2 \n1 2\n3 \n1 2 3\n"], "outputs": ["1\n2\n"]}
| 534
| 32
|
coding
|
Solve the programming task below in a Python markdown code block.
Santa Claus decided to disassemble his keyboard to clean it. After he returned all the keys back, he suddenly realized that some pairs of keys took each other's place! That is, Santa suspects that each key is either on its place, or on the place of another key, which is located exactly where the first key should be.
In order to make sure that he's right and restore the correct order of keys, Santa typed his favorite patter looking only to his keyboard.
You are given the Santa's favorite patter and the string he actually typed. Determine which pairs of keys could be mixed. Each key must occur in pairs at most once.
-----Input-----
The input consists of only two strings s and t denoting the favorite Santa's patter and the resulting string. s and t are not empty and have the same length, which is at most 1000. Both strings consist only of lowercase English letters.
-----Output-----
If Santa is wrong, and there is no way to divide some of keys into pairs and swap keys in each pair so that the keyboard will be fixed, print «-1» (without quotes).
Otherwise, the first line of output should contain the only integer k (k ≥ 0) — the number of pairs of keys that should be swapped. The following k lines should contain two space-separated letters each, denoting the keys which should be swapped. All printed letters must be distinct.
If there are several possible answers, print any of them. You are free to choose the order of the pairs and the order of keys in a pair.
Each letter must occur at most once. Santa considers the keyboard to be fixed if he can print his favorite patter without mistakes.
-----Examples-----
Input
helloworld
ehoolwlroz
Output
3
h e
l o
d z
Input
hastalavistababy
hastalavistababy
Output
0
Input
merrychristmas
christmasmerry
Output
-1
|
{"inputs": ["a\nz\n", "y\ny\n", "z\nz\n", "a\nz\n", "z\na\n", "z\nz\n", "y\ny\n", "z\na\n"], "outputs": ["1\na z\n", "0\n", "0\n", "1\na z\n", "1\nz a\n", "0\n", "0\n", "1\nz a\n"]}
| 422
| 98
|
coding
|
Solve the programming task below in a Python markdown code block.
A (1-indexed) binary string S of length N is called a *xor palindrome* if the value of S_{i} \oplus S_{(N + 1 - i)} is the same for all 1 ≤ i ≤ N.
For example, 0, 1111 and 0101 are xor palindromes, while 1110 and 110101 are not.
You are given a binary string S of length N. Determine if it is possible to rearrange it to form a xor palindrome or not.
------ 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 the binary string S.
- The second line of each test case contains the binary string S containing 0s and 1s only.
------ Output Format ------
For each test case, output \texttt{YES} if it is possible to rearrange S to convert it into a xor palindrome. Otherwise output \texttt{NO}.
You may print each character of \texttt{YES} and \texttt{NO} in uppercase or lowercase (for example, \texttt{yes}, \texttt{yEs}, \texttt{Yes} will be considered identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 10^{5}$
$S$ is a binary string, i.e, contains only the characters $0$ and $1$
- It is guaranteed that the sum of $N$ over all test cases does not exceed $2 \cdot 10^{5}$.
------ subtasks ------
Subtask #1 (100 points): Original constraints
----- Sample Input 1 ------
4
2
00
4
0011
3
001
4
0001
----- Sample Output 1 ------
YES
YES
YES
NO
----- explanation 1 ------
Test case $1$: $\texttt{00}$ is already a xor palindrome. [The value of $S_{i} \oplus S_{(N + 1 - i)}$ is $0$ for all $1 ≤ i ≤ N$.]
Test case $2$: $\texttt{0011}$ is already a xor palindrome. [The value of $S_{i} \oplus S_{(N + 1 - i)}$ is $1$ for all $1 ≤ i ≤ N$.]
Test case $3$: $\texttt{001}$ can be rearranged to form $\texttt{010}$ which is a xor palindrome. [The value of $S_{i} \oplus S_{(N + 1 - i)}$ is $0$ for all $1 ≤ i ≤ N$.]
Test case $4$: It can be proved that $\texttt{0001}$ can not be rearranged to form a xor palindrome.
|
{"inputs": ["4\n2\n00\n4\n0011\n3\n001\n4\n0001\n"], "outputs": ["YES\nYES\nYES\nNO\n"]}
| 665
| 45
|
coding
|
Solve the programming task below in a Python markdown code block.
This problem differs from one which was on the online contest.
The sequence a1, a2, ..., an is called increasing, if ai < ai + 1 for i < n.
The sequence s1, s2, ..., sk is called the subsequence of the sequence a1, a2, ..., an, if there exist such a set of indexes 1 ≤ i1 < i2 < ... < ik ≤ n that aij = sj. In other words, the sequence s can be derived from the sequence a by crossing out some elements.
You are given two sequences of integer numbers. You are to find their longest common increasing subsequence, i.e. an increasing sequence of maximum length that is the subsequence of both sequences.
Input
The first line contains an integer n (1 ≤ n ≤ 500) — the length of the first sequence. The second line contains n space-separated integers from the range [0, 109] — elements of the first sequence. The third line contains an integer m (1 ≤ m ≤ 500) — the length of the second sequence. The fourth line contains m space-separated integers from the range [0, 109] — elements of the second sequence.
Output
In the first line output k — the length of the longest common increasing subsequence. In the second line output the subsequence itself. Separate the elements with a space. If there are several solutions, output any.
Examples
Input
7
2 3 1 6 5 4 6
4
1 3 5 6
Output
3
3 5 6
Input
5
1 2 0 2 1
3
1 0 1
Output
2
0 1
|
{"inputs": ["1\n7\n2\n7 9\n", "1\n6\n2\n7 9\n", "1\n6\n2\n7 16\n", "2\n6 10\n3\n6 3 3\n", "2\n1 10\n3\n6 3 3\n", "2\n2 10\n3\n6 3 3\n", "2\n5 2\n4\n8 8 0 4\n", "2\n5 2\n4\n8 8 0 8\n"], "outputs": ["1\n7 \n", "0\n\n", "0\n\n", "1\n6 \n", "0\n\n", "0\n\n", "0\n\n", "0\n\n"]}
| 382
| 174
|
coding
|
Solve the programming task below in a Python markdown code block.
# Story&Task
There are three parties in parliament. The "Conservative Party", the "Reformist Party", and a group of independants.
You are a member of the “Conservative Party” and you party is trying to pass a bill. The “Reformist Party” is trying to block it.
In order for a bill to pass, it must have a majority vote, meaning that more than half of all members must approve of a bill before it is passed . The "Conservatives" and "Reformists" always vote the same as other members of thier parties, meaning that all the members of each party will all vote yes, or all vote no .
However, independants vote individually, and the independant vote is often the determining factor as to whether a bill gets passed or not.
Your task is to find the minimum number of independents that have to vote for your party's (the Conservative Party's) bill so that it is passed .
In each test case the makeup of the Parliament will be different . In some cases your party may make up the majority of parliament, and in others it may make up the minority. If your party is the majority, you may find that you do not neeed any independants to vote in favor of your bill in order for it to pass . If your party is the minority, it may be possible that there are not enough independants for your bill to be passed . If it is impossible for your bill to pass, return `-1`.
# Input/Output
- `[input]` integer `totalMembers`
The total number of members.
- `[input]` integer `conservativePartyMembers`
The number of members in the Conservative Party.
- `[input]` integer `reformistPartyMembers`
The number of members in the Reformist Party.
- `[output]` an integer
The minimum number of independent members that have to vote as you wish so that the bill is passed, or `-1` if you can't pass it anyway.
# Example
For `n = 8, m = 3 and k = 3`, the output should be `2`.
It means:
```
Conservative Party member --> 3
Reformist Party member --> 3
the independent members --> 8 - 3 - 3 = 2
If 2 independent members change their minds
3 + 2 > 3
the bill will be passed.
If 1 independent members change their minds
perhaps the bill will be failed
(If the other independent members is against the bill).
3 + 1 <= 3 + 1
```
For `n = 13, m = 4 and k = 7`, the output should be `-1`.
```
Even if all 2 independent members support the bill
there are still not enough votes to pass the bill
4 + 2 < 7
So the output is -1
```
Also feel free to reuse/extend the following starter code:
```python
def pass_the_bill(total_members, conservative_party_members, reformist_party_members):
```
|
{"functional": "_inputs = [[8, 3, 3], [13, 4, 7], [7, 4, 3], [11, 4, 1], [11, 5, 1], [11, 6, 1], [11, 4, 4], [11, 5, 4], [11, 5, 5], [11, 4, 6], [11, 4, 5], [15, 9, 3], [16, 7, 8], [16, 8, 7], [16, 1, 8]]\n_outputs = [[2], [-1], [0], [2], [1], [0], [2], [1], [1], [-1], [2], [0], [-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(pass_the_bill(*i), o[0])"}
| 657
| 342
|
coding
|
Solve the programming task below in a Python markdown code block.
*This kata is based on [Project Euler Problem 539](https://projecteuler.net/problem=539)*
##Object
Find the last number between 1 and `n` (inclusive) that survives the elimination process
####How It Works
Start with the first number on the left then remove every other number moving right until you reach the the end, then from the numbers remaining start with the first number on the right and remove every other number moving left, repeat the process alternating between left and right until only one number remains which you return as the "last man standing"
##Example
given an input of `9` our set of numbers is `1 2 3 4 5 6 7 8 9`
start by removing from the left 2 4 6 8
1 3 5 7 9
then from the right 2 6
4 8
then the left again 6
2
until we end with `6` as the last man standing
**Note:** due to the randomness of the tests it is possible that you will get unlucky and a few of the tests will be really large, so try submitting 2 or 3 times.
As allways any feedback would be much appreciated
Also feel free to reuse/extend the following starter code:
```python
def last_man_standing(n):
```
|
{"functional": "_inputs = [[9], [10], [100], [1000], [50000]]\n_outputs = [[6], [8], [54], [510], [22358]]\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(last_man_standing(*i), o[0])"}
| 324
| 197
|
coding
|
Solve the programming task below in a Python markdown code block.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
-----Input-----
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 10^3.
-----Output-----
Output the given word after capitalization.
-----Examples-----
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac
|
{"inputs": ["a\n", "A\n", "z\n", "P\n", "z\n", "a\n", "P\n", "A\n"], "outputs": ["A\n", "A\n", "Z\n", "P\n", "Z\n", "A\n", "P\n", "A\n"]}
| 124
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
In this problem is used an extremely simplified version of HTML table markup. Please use the statement as a formal document and read it carefully.
A string is a bHTML table, if it satisfies the grammar:
TABLE ::= <table>ROWS</table>
ROWS ::= ROW | ROW ROWS
ROW ::= <tr>CELLS</tr>
CELLS ::= CELL | CELL CELLS
CELL ::= <td></td> | <td>TABLE</td>
Blanks in the grammar are only for purposes of illustration, in the given data there will be no spaces. The bHTML table is very similar to a simple regular HTML table in which meet only the following tags : "table", "tr", "td", all the tags are paired and the table contains at least one row and at least one cell in each row. Have a look at the sample tests as examples of tables.
As can be seen, the tables may be nested. You are given a table (which may contain other(s)). You need to write a program that analyzes all the tables and finds the number of cells in each of them. The tables are not required to be rectangular.
Input
For convenience, input data can be separated into non-empty lines in an arbitrary manner. The input data consist of no more than 10 lines. Combine (concatenate) all the input lines into one, to get a text representation s of the specified table. String s corresponds to the given grammar (the root element of grammar is TABLE), its length does not exceed 5000. Only lower case letters are used to write tags. There are no spaces in the given string s.
Output
Print the sizes of all the tables in the non-decreasing order.
Examples
Input
<table><tr><td></td></tr></table>
Output
1
Input
<table>
<tr>
<td>
<table><tr><td></td></tr><tr><td></
td
></tr><tr
><td></td></tr><tr><td></td></tr></table>
</td>
</tr>
</table>
Output
1 4
Input
<table><tr><td>
<table><tr><td>
<table><tr><td>
<table><tr><td></td><td></td>
</tr><tr><td></td></tr></table>
</td></tr></table>
</td></tr></table>
</td></tr></table>
Output
1 1 1 3
|
{"inputs": ["<table><tr><td></td></tr></table>\n", "<\nt\na\nble><tr><td></td>\n</\ntr>\n</\nt\nab\nle>\n", "<table><tr><td><table><tr><td></td></tr></table></td></tr></table>\n", "<table><tr><td></td></tr></table>\n", "<table><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table>\n", "<table><tr><td><table><tr><td></td><td></td></tr></table></td><td><table><tr><td></td></tr></table></td></tr></table>\n", "<table>\n<tr>\n<td>\n<table><tr><td></td></tr><tr><td></\ntd\n></tr><tr\n><td></td></tr><tr><td></td></tr></table>\n</td>\n</tr>\n</table>\n", "<table><tr><td><table><tr><td></td></tr></table></td></tr><tr><td><table><tr><td><table><tr><td></td></tr></table></td></tr></table></td></tr></table>\n"], "outputs": ["1 \n", "1 \n", "1 1 \n", "\n", "1 1 1 \n", "1 2 2 \n", "1 4 \n", "1 1 1 2 \n"]}
| 706
| 378
|
coding
|
Solve the programming task below in a Python markdown code block.
This contest, AtCoder Beginner Contest, is abbreviated as ABC.
When we refer to a specific round of ABC, a three-digit number is appended after ABC. For example, ABC680 is the 680th round of ABC.
What is the abbreviation for the N-th round of ABC? Write a program to output the answer.
-----Constraints-----
- 100 ≤ N ≤ 999
-----Input-----
Input is given from Standard Input in the following format:
N
-----Output-----
Print the abbreviation for the N-th round of ABC.
-----Sample Input-----
100
-----Sample Output-----
ABC100
The 100th round of ABC is ABC100.
|
{"inputs": ["7", "3", "4", "8", "9", "0", "1", "2"], "outputs": ["ABC7\n", "ABC3\n", "ABC4\n", "ABC8\n", "ABC9\n", "ABC0\n", "ABC1\n", "ABC2\n"]}
| 161
| 70
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are keeping the scores for a baseball game with strange rules. At the beginning of the game, you start with an empty record.
You are given a list of strings operations, where operations[i] is the ith operation you must apply to the record and is one of the following:
An integer x.
Record a new score of x.
'+'.
Record a new score that is the sum of the previous two scores.
'D'.
Record a new score that is the double of the previous score.
'C'.
Invalidate the previous score, removing it from the record.
Return the sum of all the scores on the record after applying all the operations.
The test cases are generated such that the answer and all intermediate calculations fit in a 32-bit integer and that all operations are valid.
Please complete the following python code precisely:
```python
class Solution:
def calPoints(self, operations: List[str]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(ops = [\"5\",\"2\",\"C\",\"D\",\"+\"]) == 30\n assert candidate(ops = [\"5\",\"-2\",\"4\",\"C\",\"D\",\"9\",\"+\",\"+\"]) == 27\n assert candidate(ops = [\"1\"]) == 1\n\n\ncheck(Solution().calPoints)"}
| 210
| 87
|
coding
|
Solve the programming task below in a Python markdown code block.
An array A of length N is said to be *pseudo-sorted* if it can be made non-decreasing after performing the following operation at most once.
Choose an i such that 1 ≤ i ≤ N-1 and swap A_{i} and A_{i+1}
Given an array A, determine if it is *pseudo-sorted* or not.
------ Input Format ------
- The first line contains a single integer T - the number of test cases. Then the test cases follow.
- The first line of each test case contains an integer N - the size of the array A.
- The second line of each test case contains N space-separated integers A_{1}, A_{2}, \dots, A_{N} denoting the array A.
------ Output Format ------
For each testcase, output YES if the array A is pseudo-sorted, NO otherwise.
You may print each character of YES and NO in uppercase or lowercase (for example, yes, yEs, Yes will be considered identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$2 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 10^{9}$
- Sum of $N$ over all test cases do not exceed $2 \cdot 10^{5}$
----- Sample Input 1 ------
3
5
3 5 7 8 9
4
1 3 2 3
3
3 2 1
----- Sample Output 1 ------
YES
YES
NO
----- explanation 1 ------
Test case 1: The array is already sorted in non-decreasing order.
Test case 2: We can choose $i = 2$ and swap $A_{2}$ and $A_{3}$. The resulting array will be $[1, 2, 3, 3]$, which is sorted in non-decreasing order.
Test case 3: It can be proven that the array cannot be sorted in non-decreasing order in at most one operation.
|
{"inputs": ["3\n5\n3 5 7 8 9\n4\n1 3 2 3\n3\n3 2 1\n"], "outputs": ["YES\nYES\nNO\n"]}
| 442
| 48
|
coding
|
Solve the programming task below in a Python markdown code block.
There are N gems. The value of the i-th gem is V_i.
You will choose some of these gems, possibly all or none, and get them.
However, you need to pay a cost of C_i to get the i-th gem.
Let X be the sum of the values of the gems obtained, and Y be the sum of the costs paid.
Find the maximum possible value of X-Y.
-----Constraints-----
- All values in input are integers.
- 1 \leq N \leq 20
- 1 \leq C_i, V_i \leq 50
-----Input-----
Input is given from Standard Input in the following format:
N
V_1 V_2 ... V_N
C_1 C_2 ... C_N
-----Output-----
Print the maximum possible value of X-Y.
-----Sample Input-----
3
10 2 5
6 3 4
-----Sample Output-----
5
If we choose the first and third gems, X = 10 + 5 = 15 and Y = 6 + 4 = 10.
We have X-Y = 5 here, which is the maximum possible value.
|
{"inputs": ["1\n1\n45", "1\n15\n0", "1\n56\n2", "1\n1\n50", "1\n1\n50\n", "1\n6\n-10", "1\n28\n-1", "1\n111\n2"], "outputs": ["0\n", "15\n", "54\n", "0", "0\n", "16\n", "29\n", "109\n"]}
| 262
| 111
|
coding
|
Solve the programming task below in a Python markdown code block.
Given two positive integers N and M, let S denote the set of all the arrays of size N such that each element of the array lies in the range [1, M]. Since there are M^{N} such arrays, the size of S is M^{N}.
Let X_{i} denote the [bitwise AND] of all elements of the i^{th} array in the set, where 1 ≤ i ≤ M^{N}.
Find the value \sum_{i = 1}^{M^{N}} X_{i}. Since the answer can be huge, output the answer modulo 998244353.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- The first and only line of each test case contains two integers N and M, the size of the array, and the maximum limit of elements.
------ Output Format ------
For each test case, print the value \sum_{i = 1}^{M^{N}} X_{i}. Since the answer can be huge, output the answer modulo 998244353.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 2\cdot10^{5}$
$1 ≤ M ≤ 10^{9}$
----- Sample Input 1 ------
2
2 2
2 3
----- Sample Output 1 ------
3
12
----- explanation 1 ------
Test case $1$: The set $S$ contains $\{[1,1], [1,2], [2,1], [2,2]\}$. The array $X = [1\& 1, 1\& 2, 2\& 1, 2\& 2] = [1, 0, 0, 2]$. Thus, sum of all elements of $X$ is $1+0+0+2 = 3$.
Test case $2$: The set $S$ contains $\{[1,1], [1,2], [1,3], [2,1], [2,2], [2,3], [3,1], [3,2], [3,3]\}$. The array $X = [1\& 1, 1\& 2, 1\& 3, 2\& 1, 2\& 2, 2\& 3, 3\& 1, 3\& 2, 3\& 3] = [1, 0, 1, 0, 2, 2, 1, 2, 3]$. Thus, sum of all elements of $X$ is $12$.
|
{"inputs": ["2\n2 2\n2 3\n"], "outputs": ["3\n12"]}
| 611
| 24
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a 0-indexed integer array nums whose length is a power of 2.
Apply the following algorithm on nums:
Let n be the length of nums. If n == 1, end the process. Otherwise, create a new 0-indexed integer array newNums of length n / 2.
For every even index i where 0 <= i < n / 2, assign the value of newNums[i] as min(nums[2 * i], nums[2 * i + 1]).
For every odd index i where 0 <= i < n / 2, assign the value of newNums[i] as max(nums[2 * i], nums[2 * i + 1]).
Replace the array nums with newNums.
Repeat the entire process starting from step 1.
Return the last number that remains in nums after applying the algorithm.
Please complete the following python code precisely:
```python
class Solution:
def minMaxGame(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,3,5,2,4,8,2,2]) == 1\n assert candidate(nums = [3]) == 3\n\n\ncheck(Solution().minMaxGame)"}
| 231
| 58
|
coding
|
Solve the programming task below in a Python markdown code block.
# Description:
Find the longest successive exclamation marks and question marks combination in the string. A successive exclamation marks and question marks combination must contains two part: a substring of "!" and a substring "?", they are adjacent.
If more than one result are found, return the one which at left side; If no such a combination found, return `""`.
# Examples
```
find("!!") === ""
find("!??") === "!??"
find("!?!!") === "?!!"
find("!!???!????") === "!!???"
find("!!???!?????") === "!?????"
find("!????!!!?") === "????!!!"
find("!?!!??!!!?") === "??!!!"
```
# Note
Please don't post issue about difficulty or duplicate. Because:
>[That's unfair on the kata creator. This is a valid kata and introduces new people to javascript some regex or loops, depending on how they tackle this problem. --matt c](https://www.codewars.com/kata/remove-exclamation-marks/discuss#57fabb625c9910c73000024e)
Also feel free to reuse/extend the following starter code:
```python
def find(s):
```
|
{"functional": "_inputs = [['!!'], ['!??'], ['!?!!'], ['!!???!????'], ['!!???!?????'], ['!????!!!?'], ['!?!!??!!!?']]\n_outputs = [[''], ['!??'], ['?!!'], ['!!???'], ['!?????'], ['????!!!'], ['??!!!']]\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(find(*i), o[0])"}
| 280
| 211
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the head of a linked list head, in which each node contains an integer value.
Between every pair of adjacent nodes, insert a new node with a value equal to the greatest common divisor of them.
Return the linked list after insertion.
The greatest common divisor of two numbers is the largest positive integer that evenly divides both numbers.
Please complete the following python code precisely:
```python
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:
```
|
{"functional": "def check(candidate):\n assert is_same_list(candidate(head = list_node([18,6,10,3])), list_node([18,6,6,2,10,1,3]))\n assert is_same_list(candidate(head = list_node([7])), list_node([7]))\n\n\ncheck(Solution().insertGreatestCommonDivisors)"}
| 161
| 85
|
coding
|
Solve the programming task below in a Python markdown code block.
We have had record hot temperatures this summer. To avoid heat stroke, you decided to buy a quantity of drinking water at the nearby supermarket. Two types of bottled water, 1 and 0.5 liter, are on sale at respective prices there. You have a definite quantity in your mind, but are willing to buy a quantity larger than that if: no combination of these bottles meets the quantity, or, the total price becomes lower.
Given the prices for each bottle of water and the total quantity needed, make a program to seek the lowest price to buy greater than or equal to the quantity required.
Input
The input is given in the following format.
$A$ $B$ $X$
The first line provides the prices for a 1-liter bottle $A$ ($1\leq A \leq 1000$), 500-milliliter bottle $B$ ($1 \leq B \leq 1000$), and the total water quantity needed $X$ ($1 \leq X \leq 20000$). All these values are given as integers, and the quantity of water in milliliters.
Output
Output the total price.
Examples
Input
180 100 2400
Output
460
Input
200 90 2018
Output
450
|
{"inputs": ["21 3 64", "21 0 64", "4 767 636", "7 770 636", "5 936 910", "15 90 456", "8 18 2018", "28 90 542"], "outputs": ["3\n", "0\n", "4\n", "7\n", "5\n", "15\n", "24\n", "28\n"]}
| 308
| 125
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an m x n matrix mat, return an array of all the elements of the array in a diagonal order.
Please complete the following python code precisely:
```python
class Solution:
def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(mat = [[1,2,3],[4,5,6],[7,8,9]]) == [1,2,4,7,5,3,6,8,9]\n assert candidate(mat = [[1,2],[3,4]]) == [1,2,3,4]\n\n\ncheck(Solution().findDiagonalOrder)"}
| 75
| 91
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array A containing N integers. Find if it is possible to choose exactly M elements from the array such that the MEX of the chosen elements is exactly K.
Recall that the *MEX* of an array is the smallest non-negative integer that does not belong to the array. For example, the *MEX* of [2, 2, 1] is 0 because 0 does not belong to the array, the *MEX* of [3, 1, 0, 1] is 2 because 0 and 1 belong to the array, but 2 does not.
------ Input Format ------
- The first line contains an integer T, denoting the number of test cases. The T test cases then follow:
- The first line of each test case contains an integer N, M, K, denoting the length of the array, the number of elements to be chosen, and the required MEX respectively.
- The second line of each test case contains N space-separated integers A_{1},A_{2},\ldots,A_{N}, denoting the elements of the array.
------ Output Format ------
For each test case, print YES if it is possible to choose M elements from the array A so that the MEX of the chosen elements is exactly K and 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 ≤ 100$
$1 ≤ N ≤ 100$
$1 ≤ M ≤ N$
$0 ≤ A_{i}, K ≤ N$
----- Sample Input 1 ------
6
5 4 2
0 1 3 0 3
2 1 2
0 1
3 3 3
0 1 2
4 3 3
2 0 4 3
5 4 2
0 2 1 2 5
6 5 2
0 1 0 2 0 3
----- Sample Output 1 ------
YES
NO
YES
NO
NO
YES
----- explanation 1 ------
Test case $1$: The chosen elements are $0, 1, 3, 0$ and $MEX([0, 1, 3, 0]) = 2$.
Test case $3$: The chosen elements are $0, 1, 2$ and $MEX([0, 1, 2]) = 3$.
Test case $6$: The chosen elements are $0, 1, 0, 0, 3$ and $MEX([0, 1, 0, 0, 3]) = 2$.
Test case $2, 4, 5$: There is no way to choose elements to obtain the required MEX.
|
{"inputs": ["6\n5 4 2\n0 1 3 0 3\n2 1 2\n0 1\n3 3 3\n0 1 2\n4 3 3\n2 0 4 3\n5 4 2\n0 2 1 2 5\n6 5 2\n0 1 0 2 0 3\n"], "outputs": ["YES\nNO\nYES\nNO\nNO\nYES\n"]}
| 635
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
At time 1, the first spectator stands. At time 2, the second spectator stands. ... At time k, the k-th spectator stands. At time k + 1, the (k + 1)-th spectator stands and the first spectator sits. At time k + 2, the (k + 2)-th spectator stands and the second spectator sits. ... At time n, the n-th spectator stands and the (n - k)-th spectator sits. At time n + 1, the (n + 1 - k)-th spectator sits. ... At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
-----Input-----
The first line contains three integers n, k, t (1 ≤ n ≤ 10^9, 1 ≤ k ≤ n, 1 ≤ t < n + k).
-----Output-----
Print single integer: how many spectators are standing at time t.
-----Examples-----
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
-----Note-----
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
At t = 0 ---------- $\Rightarrow$ number of standing spectators = 0. At t = 1 ^--------- $\Rightarrow$ number of standing spectators = 1. At t = 2 ^^-------- $\Rightarrow$ number of standing spectators = 2. At t = 3 ^^^------- $\Rightarrow$ number of standing spectators = 3. At t = 4 ^^^^------ $\Rightarrow$ number of standing spectators = 4. At t = 5 ^^^^^----- $\Rightarrow$ number of standing spectators = 5. At t = 6 -^^^^^---- $\Rightarrow$ number of standing spectators = 5. At t = 7 --^^^^^--- $\Rightarrow$ number of standing spectators = 5. At t = 8 ---^^^^^-- $\Rightarrow$ number of standing spectators = 5. At t = 9 ----^^^^^- $\Rightarrow$ number of standing spectators = 5. At t = 10 -----^^^^^ $\Rightarrow$ number of standing spectators = 5. At t = 11 ------^^^^ $\Rightarrow$ number of standing spectators = 4. At t = 12 -------^^^ $\Rightarrow$ number of standing spectators = 3. At t = 13 --------^^ $\Rightarrow$ number of standing spectators = 2. At t = 14 ---------^ $\Rightarrow$ number of standing spectators = 1. At t = 15 ---------- $\Rightarrow$ number of standing spectators = 0.
|
{"inputs": ["5 3 5\n", "3 2 4\n", "6 1 4\n", "2 2 3\n", "5 4 6\n", "2 1 2\n", "2 2 2\n", "5 5 6\n"], "outputs": ["3\n", "1\n", "1\n", "1\n", "3\n", "1\n", "2\n", "4\n"]}
| 666
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Alice, Bob and Charlie are bidding for an artifact at an auction.
Alice bids A rupees, Bob bids B rupees, and Charlie bids C rupees (where A, B, and C are distinct).
According to the rules of the auction, the person who bids the highest amount will win the auction.
Determine who will win the auction.
------ Input Format ------
- The first line contains a single integer T — the number of test cases. Then the test cases follow.
- The first and only line of each test case contains three integers A, B, and C, — the amount bid by Alice, Bob, and Charlie respectively.
------ Output Format ------
For each test case, output who (out of Alice, Bob, and Charlie) will win the auction.
You may print each character of Alice, Bob, and Charlie in uppercase or lowercase (for example, ALICE, aliCe, aLIcE will be considered identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ A, B, C ≤ 1000$
$A$, $B$, and $C$ are distinct.
----- Sample Input 1 ------
4
200 100 400
155 1000 566
736 234 470
124 67 2
----- Sample Output 1 ------
Charlie
Bob
Alice
Alice
----- explanation 1 ------
Test Case $1$: Charlie wins the auction since he bid the highest amount.
Test Case $2$: Bob wins the auction since he bid the highest amount.
Test Case $3$: Alice wins the auction since she bid the highest amount.
Test Case $4$: Alice wins the auction since she bid the highest amount.
|
{"inputs": ["4\n200 100 400\n155 1000 566\n736 234 470\n124 67 2\n"], "outputs": ["Charlie\nBob\nAlice\nAlice\n"]}
| 392
| 66
|
coding
|
Solve the programming task below in a Python markdown code block.
How much bigger is a 16-inch pizza compared to an 8-inch pizza? A more pragmatic question is: How many 8-inch pizzas "fit" in a 16-incher?
The answer, as it turns out, is exactly four 8-inch pizzas. For sizes that don't correspond to a round number of 8-inchers, you must round the number of slices (one 8-inch pizza = 8 slices), e.g.:
```python
how_many_pizzas(16) -> "pizzas: 4, slices: 0"
how_many_pizzas(12) -> "pizzas: 2, slices: 2"
how_many_pizzas(8) -> "pizzas: 1, slices: 0"
how_many_pizzas(6) -> "pizzas: 0, slices: 4"
how_many_pizzas(0) -> "pizzas: 0, slices: 0"
```
Get coding quick, so you can choose the ideal size for your next meal!
Also feel free to reuse/extend the following starter code:
```python
def how_many_pizzas(n):
```
|
{"functional": "_inputs = [[16], [12], [8], [6], [0]]\n_outputs = [['pizzas: 4, slices: 0'], ['pizzas: 2, slices: 2'], ['pizzas: 1, slices: 0'], ['pizzas: 0, slices: 4'], ['pizzas: 0, slices: 0']]\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(how_many_pizzas(*i), o[0])"}
| 254
| 228
|
coding
|
Solve the programming task below in a Python markdown code block.
In this kata the function returns an array/list like the one passed to it but with its nth element removed (with `0 <= n <= array/list.length - 1`). The function is already written for you and the basic tests pass, but random tests fail. Your task is to figure out why and fix it.
Good luck!
~~~if:javascript
Some good reading: [MDN Docs about arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
~~~
~~~if:python
Some good reading: [Python Docs about lists](https://docs.python.org/3/tutorial/datastructures.html)
~~~
~~~if:coffeescript
Some good reading: [CoffeeScript docs](http://coffeescript.org/)
~~~
Also feel free to reuse/extend the following starter code:
```python
def remove_nth_element(lst, n):
```
|
{"functional": "_inputs = [[[9, 7, 6, 9], 0]]\n_outputs = [[[7, 6, 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(remove_nth_element(*i), o[0])"}
| 201
| 173
|
coding
|
Solve the programming task below in a Python markdown code block.
Sonya was unable to think of a story for this problem, so here comes the formal description.
You are given the array containing n positive integers. At one turn you can pick any element and increase or decrease it by 1. The goal is the make the array strictly increasing by making the minimum possible number of operations. You are allowed to change elements in any way, they can become negative or equal to 0.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 3000) — the length of the array.
Next line contains n integer ai (1 ≤ ai ≤ 109).
Output
Print the minimum number of operation required to make the array strictly increasing.
Examples
Input
7
2 1 5 11 5 9 11
Output
9
Input
5
5 4 3 2 1
Output
12
Note
In the first sample, the array is going to look as follows:
2 3 5 6 7 9 11
|2 - 2| + |1 - 3| + |5 - 5| + |11 - 6| + |5 - 7| + |9 - 9| + |11 - 11| = 9
And for the second sample:
1 2 3 4 5
|5 - 1| + |4 - 2| + |3 - 3| + |2 - 4| + |1 - 5| = 12
|
{"inputs": ["1\n1\n", "1\n0\n", "1\n2\n", "1\n4\n", "1\n5\n", "1\n1000\n", "1\n1001\n", "1\n0001\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 346
| 95
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Mandarin], [Russian], and [Vietnamese] as well.
You are given a positive integer N. You have to print exactly N + 1 positive integers
satisfying the following conditions:
Exactly one value should appear twice, all the remaining values should appear only once.
Sum of all these values should be equal to 2^{N}.
You have to print the values in non-decreasing order. If there are multiple solutions, you can print any of them.
------ Input Format ------
- 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 integer N.
------ Output Format ------
For each test case, print a single line containing N + 1 positive integers in non-decreasing order that satisfy the given conditions. If there are multiple solutions, you may print any of them.
------ Constraints ------
$1 ≤T ≤60$
$1 ≤N ≤60$
------ subtasks ------
Subtask 1 (100 points): Original constraints
----- Sample Input 1 ------
2
3
4
----- Sample Output 1 ------
1 2 2 3
1 2 3 3 7
----- explanation 1 ------
Test Case $1$: $2$ is repeated twice and the remaining elements occurred only once and the sum of all the elements is equal to $8$, which is $2^{3}$.
Test Case $2$: $3$ is repeated twice and the remaining elements occurred only once and the sum of all the elements is equal to $16$, which is $2^{4}$.
|
{"inputs": ["2\n3\n4\n"], "outputs": ["1 2 2 3\n1 2 3 3 7"]}
| 371
| 33
|
coding
|
Solve the programming task below in a Python markdown code block.
Manao is taking part in a quiz. The quiz consists of n consecutive questions. A correct answer gives one point to the player. The game also has a counter of consecutive correct answers. When the player answers a question correctly, the number on this counter increases by 1. If the player answers a question incorrectly, the counter is reset, that is, the number on it reduces to 0. If after an answer the counter reaches the number k, then it is reset, and the player's score is doubled. Note that in this case, first 1 point is added to the player's score, and then the total score is doubled. At the beginning of the game, both the player's score and the counter of consecutive correct answers are set to zero.
Manao remembers that he has answered exactly m questions correctly. But he does not remember the order in which the questions came. He's trying to figure out what his minimum score may be. Help him and compute the remainder of the corresponding number after division by 1000000009 (10^9 + 9).
-----Input-----
The single line contains three space-separated integers n, m and k (2 ≤ k ≤ n ≤ 10^9; 0 ≤ m ≤ n).
-----Output-----
Print a single integer — the remainder from division of Manao's minimum possible score in the quiz by 1000000009 (10^9 + 9).
-----Examples-----
Input
5 3 2
Output
3
Input
5 4 2
Output
6
-----Note-----
Sample 1. Manao answered 3 questions out of 5, and his score would double for each two consecutive correct answers. If Manao had answered the first, third and fifth questions, he would have scored as much as 3 points.
Sample 2. Now Manao answered 4 questions. The minimum possible score is obtained when the only wrong answer is to the question 4.
Also note that you are asked to minimize the score and not the remainder of the score modulo 1000000009. For example, if Manao could obtain either 2000000000 or 2000000020 points, the answer is 2000000000 mod 1000000009, even though 2000000020 mod 1000000009 is a smaller number.
|
{"inputs": ["5 3 2\n", "5 4 2\n", "2 0 2\n", "2 1 2\n", "2 2 2\n", "3 2 2\n", "3 3 2\n", "2 2 2\n"], "outputs": ["3\n", "6\n", "0\n", "1\n", "4\n", "2\n", "5\n", "4\n"]}
| 552
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Your dad doesn't really *get* punctuation, and he's always putting extra commas in when he posts. You can tolerate the run-on sentences, as he does actually talk like that, but those extra commas have to go!
Write a function called ```dadFilter``` that takes a string as argument and returns a string with the extraneous commas removed. The returned string should not end with a comma or any trailing whitespace.
Also feel free to reuse/extend the following starter code:
```python
def dad_filter(string):
```
|
{"functional": "_inputs = [['all this,,,, used to be trees,,,,,,'], ['Listen,,,, kid,,,,,,'], ['Luke,,,,,,,,, I am your father,,,,,,,,, '], [\"i,, don't believe this round earth,,, show me evadence!!\"], [\"Dead or alive,,,, you're coming with me,,, \"]]\n_outputs = [['all this, used to be trees'], ['Listen, kid'], ['Luke, I am your father'], [\"i, don't believe this round earth, show me evadence!!\"], [\"Dead or alive, you're coming with me\"]]\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(dad_filter(*i), o[0])"}
| 119
| 267
|
coding
|
Solve the programming task below in a Python markdown code block.
IIST is thinking of acquiring some land nearby to build its new state of the art labs. The land it has chosen incidentaly has some abandoned college buildings which IIST wants to use. The administration decide the value of the building based on the amount of work that has to be done to get it in shape (lower amount of work, higher value). The security experts want to tear down some of the buildings and use the bricks to build a boundary wall.
The director has chosen you to write a program which determines the buildings which needs to be demolished to maximise the value while fulfilling the above criterion.
Input Format:
The first line contains the number of test cases, T.
The next T cases contains information about hypothetical plots.
Each test case starts with a single integer n, 2 ≤ n ≤ 15, the number of abandoned buildings in the plot. The buildings are identified by consecutive integers 1 to n. Each of the subsequent lines contains 4 integers x_i , y_i , v_i , l_i that describe a single building. (x_i, y_i) is the position of the building in the plane, v_i is its value, and l_i is the length of boundary wall that can be built using the bricks from the building. v_i and l_i are between 0 and 10,000.
Output Format:
For each test case, compute a subset of the buildings such that, using the bricks from the buildings from that subset, the remaining buildings can be enclosed in a single boundary. Find the subset with a minimum value. If more than one such minimum-value subset exists, choose one with the smallest number of buildings.
Display, as shown below, the identity of each building to be demolished, and the length of the excess boundary (accurate to two fractional digits).
Sample Input:
2
6
0 0 8 3
1 4 3 2
2 1 7 1
4 1 2 3
3 5 4 6
2 3 9 8
3
3 0 10 2
5 5 20 25
7 -3 30 32
Sample Output:
2 4 5
3.16
2
15.00
|
{"inputs": ["2\n6\n0 0 8 3\n1 4 3 2\n2 1 7 1\n4 1 2 3\n3 5 4 6\n2 3 9 8\n3\n3 0 10 2\n5 5 20 25\n7 -3 30 32"], "outputs": ["2 4 5\n3.16\n2\n15.00"]}
| 494
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements [Bengali] and [Vietnamese] as well.
Ghayeeth is a math teacher. He likes playing games, so he invented a new game which he wants to play against his student Siroj. The rules of the game are as follows:
Initially, Ghayeeth writes the numbers $A_{1}, A_{2}, \dots, A_{N}$ on a whiteboard and a number $Z=0$ on a piece of paper.
Ghayeeth and Siroj alternate turns; Ghayeeth goes first.
In each turn, the current player must pick a number that is currently written on the whiteboard, add it to $Z$ and erase it from the whiteboard.
After each turn, if there is no pair of positive integers $(a, b)$ such that $Z = a^{2} - b^{2}$, then the last player who made a move loses the game.
Otherwise, if there are no more numbers on the whiteboard, the last player who made a move wins the game.
Help Ghayeeth determine the winner of this game.
------ 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 $A_{1}, A_{2}, \dots, A_{N}$.
------ Output ------
For each test case, print a single line containing the string "Ghayeeth" or "Siroj" (without quotes) — the name of the winner.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ N ≤ 300$
$5 ≤ A_{i} ≤ 100,000$ for each valid $i$
----- Sample Input 1 ------
2
3
7 9 11
2
13 15
----- Sample Output 1 ------
Ghayeeth
Siroj
|
{"inputs": ["2\n3\n7 9 11\n2\n13 15"], "outputs": ["Ghayeeth\nSiroj"]}
| 450
| 36
|
coding
|
Solve the programming task below in a Python markdown code block.
There are n points marked on the plane. The points are situated in such a way that they form a regular polygon (marked points are its vertices, and they are numbered in counter-clockwise order). You can draw n - 1 segments, each connecting any two marked points, in such a way that all points have to be connected with each other (directly or indirectly).
But there are some restrictions. Firstly, some pairs of points cannot be connected directly and have to be connected undirectly. Secondly, the segments you draw must not intersect in any point apart from the marked points (that is, if any two segments intersect and their intersection is not a marked point, then the picture you have drawn is invalid).
How many ways are there to connect all vertices with n - 1 segments? Two ways are considered different iff there exist some pair of points such that a segment is drawn between them in the first way of connection, but it is not drawn between these points in the second one. Since the answer might be large, output it modulo 10^9 + 7.
-----Input-----
The first line contains one number n (3 ≤ n ≤ 500) — the number of marked points.
Then n lines follow, each containing n elements. a_{i}, j (j-th element of line i) is equal to 1 iff you can connect points i and j directly (otherwise a_{i}, j = 0). It is guaranteed that for any pair of points a_{i}, j = a_{j}, i, and for any point a_{i}, i = 0.
-----Output-----
Print the number of ways to connect points modulo 10^9 + 7.
-----Examples-----
Input
3
0 0 1
0 0 1
1 1 0
Output
1
Input
4
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
Output
12
Input
3
0 0 0
0 0 1
0 1 0
Output
0
|
{"inputs": ["3\n0 0 1\n0 0 1\n1 1 0\n", "3\n0 0 0\n0 0 1\n0 1 0\n", "3\n0 0 1\n0 0 1\n1 1 0\n", "3\n0 0 0\n0 0 1\n0 1 0\n", "4\n0 1 1 1\n1 0 1 1\n1 1 0 1\n1 1 1 0\n", "4\n0 0 0 1\n0 0 0 0\n0 0 0 1\n1 0 1 0\n", "4\n0 0 1 0\n0 0 0 1\n1 0 0 0\n0 1 0 0\n", "4\n0 0 1 0\n0 0 0 1\n1 0 0 0\n0 1 0 0\n"], "outputs": ["1\n", "0\n", "1\n", "0\n", "12\n", "0\n", "0\n", "0\n"]}
| 458
| 271
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given two integers, num and t. A number is achievable if it can become equal to num after applying the following operation:
Increase or decrease the number by 1, and simultaneously increase or decrease num by 1.
Return the maximum achievable number after applying the operation at most t times.
Please complete the following python code precisely:
```python
class Solution:
def theMaximumAchievableX(self, num: int, t: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(num = 4, t = 1) == 6\n assert candidate(num = 3, t = 2) == 7\n\n\ncheck(Solution().theMaximumAchievableX)"}
| 112
| 56
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Russian], [Mandarin Chinese], [Bengali], and [Vietnamese] as well.
During a fight with the Joker, Batman's eyes lose the capability to distinguish between some pairs of colors.
Each color has an integer ID from 1 to N. There are M lists where each color belongs to exactly one list. Batman can distinguish colors belonging to different lists, but he cannot distinguish colors belonging to the same list.
Given a strip of L colors, find the different number of segments Batman will see as a result of his disability. Two positions of the strip are said to belong to the same segment if they are adjacent on the strip and Batman cannot distinguish their colors. See the sample explanation for clarity.
------ Input Format ------
- The first line contains an integer T, the number of test cases. Then the test cases follow.
- The first line contain three integers N, M, and L - the number of colors, the number of lists, and the length of the strip, respectively.
- Each of the next M lines describes a list. It begins with an integer K_{i}, the length of the i-th list, followed by K_{i} integers A_{i1}, A_{i2}, \ldots, A_{iK_{i}} - the color IDs of the i-th list.
- The next line contains L integers S_{1}, S_{2}, \ldots, S_{L} - the color IDs of the strip.
------ Output Format ------
For each test case, output in a single line the answer to the problem.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ M ≤ N ≤ 10^{5}$
$1 ≤ L ≤ 10^{5}$
$1 ≤ K_{i}, A_{ij}, S_{i} ≤ N$
$\sum_{i=1}^{M} K_{i} = N$
- Each color belongs to exactly one list.
----- Sample Input 1 ------
3
2 2 2
1 2
1 1
2 1
2 2 4
1 1
1 2
1 2 2 1
3 2 3
2 1 3
1 2
1 3 1
----- Sample Output 1 ------
2
3
1
----- explanation 1 ------
Test Case 1: Since the strip is composed of colors from different lists, the answer is the length of the strip, which is $2$.
Test Case 2: The first and second index have colors from different lists, and the third and fourth index have colors from different lists. So the strip is seen to be composed of $3$ consecutive segments.
Test Case 3: Since the strip is composed of colors from the same list, the answer is $1$ segment.
|
{"inputs": ["3\n2 2 2\n1 2\n1 1\n2 1\n2 2 4\n1 1\n1 2\n1 2 2 1\n3 2 3\n2 1 3\n1 2\n1 3 1"], "outputs": ["2\n3\n1"]}
| 612
| 78
|
coding
|
Solve the programming task below in a Python markdown code block.
Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array a with n integers. You need to count the number of funny pairs (l, r) (l ≤ r). To check if a pair (l, r) is a funny pair, take mid = (l + r - 1)/(2), then if r - l + 1 is an even number and a_l ⊕ a_{l+1} ⊕ … ⊕ a_{mid} = a_{mid + 1} ⊕ a_{mid + 2} ⊕ … ⊕ a_r, then the pair is funny. In other words, ⊕ of elements of the left half of the subarray from l to r should be equal to ⊕ of elements of the right half. Note that ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
It is time to continue solving the contest, so Sasha asked you to solve this task.
Input
The first line contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the size of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i < 2^{20}) — array itself.
Output
Print one integer — the number of funny pairs. You should consider only pairs where r - l + 1 is even number.
Examples
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
Note
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is (2, 5), as 2 ⊕ 3 = 4 ⊕ 5 = 1.
In the second example, funny pairs are (2, 3), (1, 4), and (3, 6).
In the third example, there are no funny pairs.
|
{"inputs": ["3\n3 4 2\n", "3\n3 4 3\n", "3\n2 4 3\n", "3\n2 4 6\n", "3\n2 2 6\n", "3\n2 2 7\n", "3\n2 4 7\n", "3\n0 4 8\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "1\n", "1\n", "0\n", "0\n"]}
| 516
| 118
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the root of a Binary Search Tree (BST), return the minimum difference between the values of any two different nodes in the tree.
Please complete the following python code precisely:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def minDiffInBST(self, root: Optional[TreeNode]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(root = tree_node([4,2,6,1,3])) == 1\n assert candidate(root = tree_node([1,0,48,None,None,12,49])) == 1\n\n\ncheck(Solution().minDiffInBST)"}
| 129
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array $a$ consisting of $n$ integers $a_1, a_2, \dots, a_n$.
Your problem is to find such pair of indices $i, j$ ($1 \le i < j \le n$) that $lcm(a_i, a_j)$ is minimum possible.
$lcm(x, y)$ is the least common multiple of $x$ and $y$ (minimum positive number such that both $x$ and $y$ are divisors of this number).
-----Input-----
The first line of the input contains one integer $n$ ($2 \le n \le 10^6$) — the number of elements in $a$.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^7$), where $a_i$ is the $i$-th element of $a$.
-----Output-----
Print two integers $i$ and $j$ ($1 \le i < j \le n$) such that the value of $lcm(a_i, a_j)$ is minimum among all valid pairs $i, j$. If there are multiple answers, you can print any.
-----Examples-----
Input
5
2 4 8 3 6
Output
1 2
Input
5
5 2 11 3 7
Output
2 4
Input
6
2 5 10 1 10 2
Output
1 4
|
{"inputs": ["2\n1 1\n", "2\n7 2\n", "2\n6 7\n", "2\n4 4\n", "2\n8 8\n", "2\n6 5\n", "2\n8 8\n", "2\n6 5\n"], "outputs": ["1 2\n", "1 2\n", "1 2\n", "1 2\n", "1 2\n", "1 2\n", "1 2\n", "1 2\n"]}
| 349
| 118
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the array favoriteCompanies where favoriteCompanies[i] is the list of favorites companies for the ith person (indexed from 0).
Return the indices of people whose list of favorite companies is not a subset of any other list of favorites companies. You must return the indices in increasing order.
Please complete the following python code precisely:
```python
class Solution:
def peopleIndexes(self, favoriteCompanies: List[List[str]]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(favoriteCompanies = [[\"leetcode\",\"google\",\"facebook\"],[\"google\",\"microsoft\"],[\"google\",\"facebook\"],[\"google\"],[\"amazon\"]]) == [0,1,4] \n assert candidate(favoriteCompanies = [[\"leetcode\",\"google\",\"facebook\"],[\"leetcode\",\"amazon\"],[\"facebook\",\"google\"]]) == [0,1] \n assert candidate(favoriteCompanies = [[\"leetcode\"],[\"google\"],[\"facebook\"],[\"amazon\"]]) == [0,1,2,3]\n\n\ncheck(Solution().peopleIndexes)"}
| 108
| 137
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the nth lake, the nth lake becomes full of water. If it rains over a lake that is full of water, there will be a flood. Your goal is to avoid floods in any lake.
Given an integer array rains where:
rains[i] > 0 means there will be rains over the rains[i] lake.
rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.
Return an array ans where:
ans.length == rains.length
ans[i] == -1 if rains[i] > 0.
ans[i] is the lake you choose to dry in the ith day if rains[i] == 0.
If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.
Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes.
Please complete the following python code precisely:
```python
class Solution:
def avoidFlood(self, rains: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(rains = [1,2,3,4]) == [-1,-1,-1,-1]\n assert candidate(rains = [1,2,0,0,2,1]) == [-1,-1,2,1,-1,-1]\n assert candidate(rains = [1,2,0,1,2]) == []\n\n\ncheck(Solution().avoidFlood)"}
| 263
| 101
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i].
Return the answer in an array.
Please complete the following python code precisely:
```python
class Solution:
def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [8,1,2,2,3]) == [4,0,1,1,3]\n assert candidate(nums = [6,5,4,8]) == [2,1,0,3]\n assert candidate(nums = [7,7,7,7]) == [0,0,0,0]\n\n\ncheck(Solution().smallerNumbersThanCurrent)"}
| 114
| 101
|
coding
|
Solve the programming task below in a Python markdown code block.
E-training
Nene is writing a program to look up $ N $ integers $ V_1, V_2, V_3, \ cdots, V_N $ for programming training.
As told by his instructor, Umiko, Nene wrote a program to look up multiples of 2, 3, and 6.
Multiples of 2 were $ A $, multiples of 3 were $ B $, and multiples of 6 were $ C $.
Umiko told me to look up the number of "numbers that are neither multiples of 2 nor multiples of 3".
However, Nene was tired, so she decided to cheat only for the answer.
Based only on the values of $ N, A, B, and C $, you can find the number of "numbers that are neither multiples of 2 nor multiples of 3". Create a program that asks for this.
input
$ N, A, B, C $ are given separated by blanks.
output
Output the number of "numbers that are neither multiples of 2 nor multiples of 3" in the data. However, insert a line break at the end.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 $
* $ A, B, C $ are integers greater than or equal to $ 0 $ and less than or equal to $ N $
* No inconsistent data is given, such as $ A $ being greater than $ N $
Input example 1
6 3 2 1
Output example 1
2
For example, if your data is $ 2, 3, 4, 5, 6, 7 $, then $ 5 $ and $ 7 $ are "numbers that are neither multiples of 2 nor multiples of 3".
Input example 2
10 9 9 9
Output example 2
1
Example
Input
6 3 2 1
Output
2
|
{"inputs": ["6 5 2 1", "9 5 2 1", "0 5 2 1", "6 3 2 1", "12 5 2 1", "-1 5 2 1", "-1 0 2 0", "-1 0 1 0"], "outputs": ["0\n", "3\n", "-6\n", "2", "6\n", "-7\n", "-3\n", "-2\n"]}
| 438
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Your job is to return the volume of a cup when given the diameter of the top, the diameter of the bottom and the height.
You know that there is a steady gradient from the top to the bottom.
You want to return the volume rounded to 2 decimal places.
Exmples:
```python
cup_volume(1, 1, 1)==0.79
cup_volume(10, 8, 10)==638.79
cup_volume(1000, 1000, 1000)==785398163.4
cup_volume(13.123, 123.12, 1)==4436.57
cup_volume(5, 12, 31)==1858.51
```
You will only be passed positive numbers.
Also feel free to reuse/extend the following starter code:
```python
def cup_volume(d1, d2, height):
```
|
{"functional": "_inputs = [[1, 1, 1], [10, 8, 10], [1000, 1000, 1000], [13.123, 123.12, 1], [5, 12, 31]]\n_outputs = [[0.79], [638.79], [785398163.4], [4436.57], [1858.51]]\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(cup_volume(*i), o[0])"}
| 230
| 262
|
coding
|
Solve the programming task below in a Python markdown code block.
In this task Anna and Maria play the following game. Initially they have a checkered piece of paper with a painted n × m rectangle (only the border, no filling). Anna and Maria move in turns and Anna starts. During each move one should paint inside the last-painted rectangle a new lesser rectangle (along the grid lines). The new rectangle should have no common points with the previous one. Note that when we paint a rectangle, we always paint only the border, the rectangles aren't filled.
Nobody wins the game — Anna and Maria simply play until they have done k moves in total. Count the number of different ways to play this game.
Input
The first and only line contains three integers: n, m, k (1 ≤ n, m, k ≤ 1000).
Output
Print the single number — the number of the ways to play the game. As this number can be very big, print the value modulo 1000000007 (109 + 7).
Examples
Input
3 3 1
Output
1
Input
4 4 1
Output
9
Input
6 7 2
Output
75
Note
Two ways to play the game are considered different if the final pictures are different. In other words, if one way contains a rectangle that is not contained in the other way.
In the first sample Anna, who performs her first and only move, has only one possible action plan — insert a 1 × 1 square inside the given 3 × 3 square.
In the second sample Anna has as much as 9 variants: 4 ways to paint a 1 × 1 square, 2 ways to insert a 1 × 2 rectangle vertically, 2 more ways to insert it horizontally and one more way is to insert a 2 × 2 square.
|
{"inputs": ["5 5 3\n", "5 7 2\n", "2 2 1\n", "3 5 1\n", "3 6 1\n", "1 5 3\n", "5 4 2\n", "2 2 2\n"], "outputs": ["0\n", "15\n", "0\n", "6\n", "10\n", "0\n", "0\n", "0\n"]}
| 401
| 104
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
A child is running up a staircase with n steps and can hop either 1 step, 2 steps, or 3 steps at a time. Implement a method to count how many possible ways the child can run up the stairs. The result may be large, so return it modulo 1000000007.
Please complete the following python code precisely:
```python
class Solution:
def waysToStep(self, n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 3) == 4\n assert candidate(n = 5) == 13\n\n\ncheck(Solution().waysToStep)"}
| 117
| 45
|
coding
|
Solve the programming task below in a Python markdown code block.
Today Sonya learned about long integers and invited all her friends to share the fun. Sonya has an initially empty multiset with integers. Friends give her t queries, each of one of the following type:
1. + ai — add non-negative integer ai to the multiset. Note, that she has a multiset, thus there may be many occurrences of the same integer.
2. - ai — delete a single occurrence of non-negative integer ai from the multiset. It's guaranteed, that there is at least one ai in the multiset.
3. ? s — count the number of integers in the multiset (with repetitions) that match some pattern s consisting of 0 and 1. In the pattern, 0 stands for the even digits, while 1 stands for the odd. Integer x matches the pattern s, if the parity of the i-th from the right digit in decimal notation matches the i-th from the right digit of the pattern. If the pattern is shorter than this integer, it's supplemented with 0-s from the left. Similarly, if the integer is shorter than the pattern its decimal notation is supplemented with the 0-s from the left.
For example, if the pattern is s = 010, than integers 92, 2212, 50 and 414 match the pattern, while integers 3, 110, 25 and 1030 do not.
Input
The first line of the input contains an integer t (1 ≤ t ≤ 100 000) — the number of operation Sonya has to perform.
Next t lines provide the descriptions of the queries in order they appear in the input file. The i-th row starts with a character ci — the type of the corresponding operation. If ci is equal to '+' or '-' then it's followed by a space and an integer ai (0 ≤ ai < 1018) given without leading zeroes (unless it's 0). If ci equals '?' then it's followed by a space and a sequence of zeroes and onse, giving the pattern of length no more than 18.
It's guaranteed that there will be at least one query of type '?'.
It's guaranteed that any time some integer is removed from the multiset, there will be at least one occurrence of this integer in it.
Output
For each query of the third type print the number of integers matching the given pattern. Each integer is counted as many times, as it appears in the multiset at this moment of time.
Examples
Input
12
+ 1
+ 241
? 1
+ 361
- 241
? 0101
+ 101
? 101
- 101
? 101
+ 4000
? 0
Output
2
1
2
1
1
Input
4
+ 200
+ 200
- 200
? 0
Output
1
Note
Consider the integers matching the patterns from the queries of the third type. Queries are numbered in the order they appear in the input.
1. 1 and 241.
2. 361.
3. 101 and 361.
4. 361.
5. 4000.
|
{"inputs": ["4\n+ 200\n+ 15\n- 200\n? 0\n", "4\n+ 200\n+ 200\n- 200\n? 0\n", "10\n+ 2\n- 2\n+ 778\n+ 3\n+ 4\n- 4\n+ 1\n+ 617\n? 011\n? 011\n", "10\n+ 2\n- 2\n+ 778\n+ 2\n+ 4\n- 4\n+ 1\n+ 617\n? 011\n? 011\n", "10\n+ 2\n- 2\n+ 778\n+ 0\n+ 4\n- 4\n+ 0\n+ 617\n? 001\n? 011\n", "10\n+ 2\n- 2\n+ 778\n+ 1\n+ 4\n- 4\n+ 1\n+ 617\n? 011\n? 011\n", "10\n+ 2\n- 2\n+ 778\n+ 3\n+ 4\n- 4\n+ 0\n+ 617\n? 011\n? 011\n", "10\n+ 2\n- 2\n+ 778\n+ 0\n+ 4\n- 4\n+ 0\n+ 617\n? 011\n? 011\n"], "outputs": ["0\n", "1\n", "1\n1\n", "1\n1\n", "0\n1\n", "1\n1\n", "1\n1\n", "1\n1\n"]}
| 756
| 419
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a sequence of positive integers a_1, a_2, ..., a_{n}.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
-----Input-----
The first line contains a single integer n (2 ≤ n ≤ 2·10^5) — the number of elements in the sequence.
The second line contains the sequence of integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9).
-----Output-----
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
-----Examples-----
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
-----Note-----
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
|
{"inputs": ["2\n1 1\n", "2\n1 1\n", "3\n2 1 1\n", "3\n2 1 1\n", "4\n3 2 1 1\n", "4\n3 2 1 1\n", "6\n5 2 1 1 2 2\n", "6\n5 3 1 1 2 2\n"], "outputs": ["1\n2 ", "1\n2\n", "1\n3 ", "1\n3\n", "1\n4 ", "1\n4\n", "2\n5 4 ", "3\n5 4 2\n"]}
| 683
| 148
|
coding
|
Solve the programming task below in a Python markdown code block.
Vladik had started reading a complicated book about algorithms containing n pages. To improve understanding of what is written, his friends advised him to read pages in some order given by permutation P = [p_1, p_2, ..., p_{n}], where p_{i} denotes the number of page that should be read i-th in turn.
Sometimes Vladik’s mom sorted some subsegment of permutation P from position l to position r inclusive, because she loves the order. For every of such sorting Vladik knows number x — what index of page in permutation he should read. He is wondered if the page, which he will read after sorting, has changed. In other words, has p_{x} changed? After every sorting Vladik return permutation to initial state, so you can assume that each sorting is independent from each other.
-----Input-----
First line contains two space-separated integers n, m (1 ≤ n, m ≤ 10^4) — length of permutation and number of times Vladik's mom sorted some subsegment of the book.
Second line contains n space-separated integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) — permutation P. Note that elements in permutation are distinct.
Each of the next m lines contains three space-separated integers l_{i}, r_{i}, x_{i} (1 ≤ l_{i} ≤ x_{i} ≤ r_{i} ≤ n) — left and right borders of sorted subsegment in i-th sorting and position that is interesting to Vladik.
-----Output-----
For each mom’s sorting on it’s own line print "Yes", if page which is interesting to Vladik hasn't changed, or "No" otherwise.
-----Examples-----
Input
5 5
5 4 3 2 1
1 5 3
1 3 1
2 4 3
4 4 4
2 5 3
Output
Yes
No
Yes
Yes
No
Input
6 5
1 4 3 2 5 6
2 4 3
1 6 2
4 5 4
1 3 3
2 6 3
Output
Yes
No
Yes
No
Yes
-----Note-----
Explanation of first test case: [1, 2, 3, 4, 5] — permutation after sorting, 3-rd element hasn’t changed, so answer is "Yes". [3, 4, 5, 2, 1] — permutation after sorting, 1-st element has changed, so answer is "No". [5, 2, 3, 4, 1] — permutation after sorting, 3-rd element hasn’t changed, so answer is "Yes". [5, 4, 3, 2, 1] — permutation after sorting, 4-th element hasn’t changed, so answer is "Yes". [5, 1, 2, 3, 4] — permutation after sorting, 3-rd element has changed, so answer is "No".
|
{"inputs": ["5 5\n5 4 3 2 1\n1 5 3\n1 3 1\n2 4 3\n4 4 4\n2 5 3\n", "5 5\n5 4 3 2 1\n1 5 3\n1 5 1\n2 4 3\n4 4 4\n2 5 3\n", "5 5\n5 4 3 2 1\n1 5 4\n1 3 1\n2 4 3\n4 4 4\n2 5 3\n", "5 5\n5 4 3 2 1\n1 5 3\n1 3 1\n2 4 3\n3 4 4\n2 5 3\n", "5 5\n5 4 6 2 1\n1 5 4\n1 3 1\n2 4 3\n4 4 4\n2 5 3\n", "5 5\n8 4 3 2 1\n1 5 3\n1 3 1\n2 4 3\n3 4 4\n2 5 3\n", "5 5\n5 4 3 2 1\n1 5 3\n1 5 1\n2 4 3\n2 4 4\n2 5 3\n", "5 5\n5 4 3 2 1\n1 5 4\n1 3 1\n2 4 3\n4 4 4\n3 5 3\n"], "outputs": ["Yes\nNo\nYes\nYes\nNo\n", "Yes\nNo\nYes\nYes\nNo\n", "No\nNo\nYes\nYes\nNo\n", "Yes\nNo\nYes\nNo\nNo\n", "No\nNo\nNo\nYes\nNo\n", "Yes\nNo\nYes\nNo\nNo\n", "Yes\nNo\nYes\nNo\nNo\n", "No\nNo\nYes\nYes\nNo\n"]}
| 686
| 470
|
coding
|
Solve the programming task below in a Python markdown code block.
Complete the method so that it formats the words into a single comma separated value. The last word should be separated by the word 'and' instead of a comma. The method takes in an array of strings and returns a single formatted string. Empty string values should be ignored. Empty arrays or null/nil values being passed into the method should result in an empty string being returned.
```Python
format_words(['ninja', 'samurai', 'ronin']) # should return "ninja, samurai and ronin"
format_words(['ninja', '', 'ronin']) # should return "ninja and ronin"
format_words([]) # should return ""
```
```Haskell
formatWords ["ninja", "samurai", "ronin"] -- should return "ninja, samurai and ronin"
formatWords ["ninja", "", "ronin"] -- should return "ninja and ronin"
formatWords [] -- should return ""
```
Also feel free to reuse/extend the following starter code:
```python
def format_words(words):
```
|
{"functional": "_inputs = [[['one', 'two', 'three', 'four']], [['one']], [['one', '', 'three']], [['', '', 'three']], [['one', 'two', '']], [[]], [None], [['']]]\n_outputs = [['one, two, three and four'], ['one'], ['one and three'], ['three'], ['one and two'], [''], [''], ['']]\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(format_words(*i), o[0])"}
| 237
| 224
|
coding
|
Solve the programming task below in a Python markdown code block.
Let's call beauty of an array $b_1, b_2, \ldots, b_n$ ($n > 1$) — $\min\limits_{1 \leq i < j \leq n} |b_i - b_j|$.
You're given an array $a_1, a_2, \ldots a_n$ and a number $k$. Calculate the sum of beauty over all subsequences of the array of length exactly $k$. As this number can be very large, output it modulo $998244353$.
A sequence $a$ is a subsequence of an array $b$ if $a$ can be obtained from $b$ by deletion of several (possibly, zero or all) elements.
-----Input-----
The first line contains integers $n, k$ ($2 \le k \le n \le 1000$).
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^5$).
-----Output-----
Output one integer — the sum of beauty over all subsequences of the array of length exactly $k$. As this number can be very large, output it modulo $998244353$.
-----Examples-----
Input
4 3
1 7 3 5
Output
8
Input
5 5
1 10 100 1000 10000
Output
9
-----Note-----
In the first example, there are $4$ subsequences of length $3$ — $[1, 7, 3]$, $[1, 3, 5]$, $[7, 3, 5]$, $[1, 7, 5]$, each of which has beauty $2$, so answer is $8$.
In the second example, there is only one subsequence of length $5$ — the whole array, which has the beauty equal to $|10-1| = 9$.
|
{"inputs": ["3 2\n4 4 4\n", "3 2\n4 4 4\n", "3 3\n1 4 0\n", "3 2\n8 4 4\n", "3 3\n4 4 4\n", "3 3\n4 4 7\n", "3 3\n4 4 0\n", "3 5\n1 4 0\n"], "outputs": ["0", "0\n", "1\n", "8\n", "0\n", "0\n", "0\n", "0\n"]}
| 465
| 133
|
coding
|
Solve the programming task below in a Python markdown code block.
Joisino is working as a receptionist at a theater.
The theater has 100000 seats, numbered from 1 to 100000.
According to her memo, N groups of audiences have come so far, and the i-th group occupies the consecutive seats from Seat l_i to Seat r_i (inclusive).
How many people are sitting at the theater now?
-----Constraints-----
- 1≤N≤1000
- 1≤l_i≤r_i≤100000
- No seat is occupied by more than one person.
- All input values are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
l_1 r_1
:
l_N r_N
-----Output-----
Print the number of people sitting at the theater.
-----Sample Input-----
1
24 30
-----Sample Output-----
7
There are 7 people, sitting at Seat 24,25,26,27,28,29 and 30.
|
{"inputs": ["1\n2 0", "1\n1 0", "1\n1 1", "1\n4 0", "1\n8 0", "1\n7 0", "1\n7 1", "1\n0 30"], "outputs": ["-1\n", "0\n", "1\n", "-3\n", "-7\n", "-6\n", "-5\n", "31\n"]}
| 236
| 97
|
coding
|
Solve the programming task below in a Python markdown code block.
# Introduction and Warm-up (Highly recommended)
# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
___
# Task
**_Given_** an **_array of integers_** , **_Find the minimum sum_** which is obtained *from summing each Two integers product* .
___
# Notes
* **_Array/list_** *will contain* **_positives only_** .
* **_Array/list_** *will always has* **_even size_**
___
# Input >> Output Examples
```
minSum({5,4,2,3}) ==> return (22)
```
## **_Explanation_**:
* **_The minimum sum_** *obtained from summing each two integers product* , ` 5*2 + 3*4 = 22`
___
```
minSum({12,6,10,26,3,24}) ==> return (342)
```
## **_Explanation_**:
* **_The minimum sum_** *obtained from summing each two integers product* , ` 26*3 + 24*6 + 12*10 = 342`
___
```
minSum({9,2,8,7,5,4,0,6}) ==> return (74)
```
## **_Explanation_**:
* **_The minimum sum_** *obtained from summing each two integers product* , ` 9*0 + 8*2 +7*4 +6*5 = 74`
___
___
___
___
# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)
# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___
## ALL translations are welcomed
## Enjoy Learning !!
# Zizou
Also feel free to reuse/extend the following starter code:
```python
def min_sum(arr):
```
|
{"functional": "_inputs = [[[5, 4, 2, 3]], [[12, 6, 10, 26, 3, 24]], [[9, 2, 8, 7, 5, 4, 0, 6]]]\n_outputs = [[22], [342], [74]]\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(min_sum(*i), o[0])"}
| 492
| 219
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a string s and a robot that currently holds an empty string t. Apply one of the following operations until s and t are both empty:
Remove the first character of a string s and give it to the robot. The robot will append this character to the string t.
Remove the last character of a string t and give it to the robot. The robot will write this character on paper.
Return the lexicographically smallest string that can be written on the paper.
Please complete the following python code precisely:
```python
class Solution:
def robotWithString(self, s: str) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"zza\") == \"azz\"\n assert candidate(s = \"bac\") == \"abc\"\n assert candidate(s = \"bdda\") == \"addb\"\n\n\ncheck(Solution().robotWithString)"}
| 143
| 60
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array $a$ of length $n$, and an integer $x$. You can perform the following operation as many times as you would like (possibly zero): replace two adjacent elements of the array by their sum. For example, if the initial array was $[3, 6, 9]$, in a single operation one can replace the last two elements by their sum, yielding an array $[3, 15]$, or replace the first two elements to get an array $[9, 9]$. Note that the size of the array decreases after each operation.
The beauty of an array $b=[b_1, \ldots, b_k]$ is defined as $\sum_{i=1}^k \left\lceil \frac{b_i}{x} \right\rceil$, which means that we divide each element by $x$, round it up to the nearest integer, and sum up the resulting values. For example, if $x = 3$, and the array is $[4, 11, 6]$, the beauty of the array is equal to $\left\lceil \frac{4}{3} \right\rceil + \left\lceil \frac{11}{3} \right\rceil + \left\lceil \frac{6}{3} \right\rceil = 2 + 4 + 2 = 8$.
Please determine the minimum and the maximum beauty you can get by performing some operations on the original array.
-----Input-----
The first input line contains a single integer $t$ — the number of test cases ($1 \le t \le 1000$).
The first line of each test case contains two integers $n$ and $x$ ($1 \leq n \leq 10^5$, $1 \leq x \leq 10^9$).
The next line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$), the elements of the array $a$.
It is guaranteed that the sum of values of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case output two integers — the minimal and the maximal possible beauty.
-----Examples-----
Input
2
3 3
3 6 9
3 3
6 4 11
Output
6 6
7 8
-----Note-----
In the first test case the beauty of the array does not change if we perform any operations.
In the second example we can leave the array unchanged to attain the maximum beauty, and to get the minimum beauty one can replace two elements $4$ and $11$ with their sum, yielding an array $[6, 15]$, which has its beauty equal to $7$.
|
{"inputs": ["1\n1 1\n1\n", "1\n1 1\n1\n", "1\n1 1\n0\n", "1\n1 171\n1\n", "1\n1 1234\n1\n", "1\n1 1234\n1\n", "2\n3 3\n3 6 9\n3 3\n6 4 11\n", "1\n4 2\n2 2655 6548 2082\n"], "outputs": ["1 1\n", "1 1\n", "0 0\n", "1 1\n", "1 1\n", "1 1\n", "6 6\n7 8\n", "5644 5644\n"]}
| 627
| 182
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer array arr, return the mean of the remaining integers after removing the smallest 5% and the largest 5% of the elements.
Answers within 10-5 of the actual answer will be considered accepted.
Please complete the following python code precisely:
```python
class Solution:
def trimMean(self, arr: List[int]) -> float:
```
|
{"functional": "def check(candidate):\n assert candidate(arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3]) == 2.00000\n assert candidate(arr = [6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0]) == 4.00000\n assert candidate(arr = [6,0,7,0,7,5,7,8,3,4,0,7,8,1,6,8,1,1,2,4,8,1,9,5,4,3,8,5,10,8,6,6,1,0,6,10,8,2,3,4]) == 4.77778\n assert candidate(arr = [9,7,8,7,7,8,4,4,6,8,8,7,6,8,8,9,2,6,0,0,1,10,8,6,3,3,5,1,10,9,0,7,10,0,10,4,1,10,6,9,3,6,0,0,2,7,0,6,7,2,9,7,7,3,0,1,6,1,10,3]) == 5.27778\n assert candidate(arr = [4,8,4,10,0,7,1,3,7,8,8,3,4,1,6,2,1,1,8,0,9,8,0,3,9,10,3,10,1,10,7,3,2,1,4,9,10,7,6,4,0,8,5,1,2,1,6,2,5,0,7,10,9,10,3,7,10,5,8,5,7,6,7,6,10,9,5,10,5,5,7,2,10,7,7,8,2,0,1,1]) == 5.29167\n\n\ncheck(Solution().trimMean)"}
| 94
| 559
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the array restaurants where restaurants[i] = [idi, ratingi, veganFriendlyi, pricei, distancei]. You have to filter the restaurants using three filters.
The veganFriendly filter will be either true (meaning you should only include restaurants with veganFriendlyi set to true) or false (meaning you can include any restaurant). In addition, you have the filters maxPrice and maxDistance which are the maximum value for price and distance of restaurants you should consider respectively.
Return the array of restaurant IDs after filtering, ordered by rating from highest to lowest. For restaurants with the same rating, order them by id from highest to lowest. For simplicity veganFriendlyi and veganFriendly take value 1 when it is true, and 0 when it is false.
Please complete the following python code precisely:
```python
class Solution:
def filterRestaurants(self, restaurants: List[List[int]], veganFriendly: int, maxPrice: int, maxDistance: int) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 1, maxPrice = 50, maxDistance = 10) == [3,1,5] \n assert candidate(restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 50, maxDistance = 10) == [4,3,2,1,5]\n assert candidate(restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]], veganFriendly = 0, maxPrice = 30, maxDistance = 3) == [4,5]\n\n\ncheck(Solution().filterRestaurants)"}
| 227
| 301
|
coding
|
Solve the programming task below in a Python markdown code block.
Squirrel Liss loves nuts. There are n trees (numbered 1 to n from west to east) along a street and there is a delicious nut on the top of each tree. The height of the tree i is h_{i}. Liss wants to eat all nuts.
Now Liss is on the root of the tree with the number 1. In one second Liss can perform one of the following actions: Walk up or down one unit on a tree. Eat a nut on the top of the current tree. Jump to the next tree. In this action the height of Liss doesn't change. More formally, when Liss is at height h of the tree i (1 ≤ i ≤ n - 1), she jumps to height h of the tree i + 1. This action can't be performed if h > h_{i} + 1.
Compute the minimal time (in seconds) required to eat all nuts.
-----Input-----
The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of trees.
Next n lines contains the height of trees: i-th line contains an integer h_{i} (1 ≤ h_{i} ≤ 10^4) — the height of the tree with the number i.
-----Output-----
Print a single integer — the minimal time required to eat all nuts in seconds.
-----Examples-----
Input
2
1
2
Output
5
Input
5
2
1
2
1
1
Output
14
|
{"inputs": ["1\n1\n", "1\n1\n", "1\n2\n", "1\n3\n", "1\n4\n", "1\n6\n", "1\n5\n", "1\n8\n"], "outputs": ["2\n", "2\n", "3\n", "4\n", "5\n", "7\n", "6\n", "9\n"]}
| 336
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
Ichigo is on his way to save Rukia. Unfortunately, when Ichigo was busy fighting Renji, Kenpachi Zaraki had gone to the Dangai(the same place where Ichigo got his final Getsuga Tenshou) to train. Now, he has a Bankai called Tensa Quantum Computer and he used it against Ichigo!
Tensa Quantum Computer consists of 2N rooms arranged in a circle. Kenpachi imprisoned Rukia in one of these rooms. The rooms have the numbers 1, 2, ..., N-1, N, -N, -(N-1), ..., -1 written on them in that order clockwise. Each room has a one-way door to another unique room. Kenpachi knows that if a room has number X, then it leads to another room which is at distance abs(X) from this room. More precisely, if X is positive, it means that this room leads to the X-th room in the clockwise direction from the current room. And if X is negative, then that means that this room leads to the (-X)-th room in the anticlockwise direction from the current room.
Kenpachi knows that Ichigo starts at the room with the number A. Being a determined guy, Ichigo doesn't sit still until he finds Rukia. Instead he keeps running to the next room for as long as he can. But Kenpachi's funny and crafty lieutenant Yachiru Kusajishi suggested that if Kenpachi keeps Rukia in one of the rooms that Ichigo will never visit, then Ichigo will keep running forever and die from exhaustion.
Now, Kenpachi wants to know the number of rooms that he can keep Rukia in, so that poor Ichigo never finds her and hence, keeps running.
Note: abs(X) is the absolute value of X.
Input Format
Line 1: T
T - Number of test cases.
Lines 2 to T+1: N A
N - Half the total number of rooms.
A - The number of the room where Ichigo starts his pursuit of Rukia.
Output Format
For each test case, print a single integer in a new line that is the number of rooms where Kenpachi can imprison Rukia so that Ichigo never finds her.
Constraints
1 <= T <= 1000
1 <= N <= 10^{9}
1 <= abs(A) <= N
Sample Input
4
1 1
4 1
4 -3
1729 -786
Sample Output
0
2
6
3170
Explanation
In the first test case, the rooms that Ichigo visits have numbers 1, -1, 1, -1, ... in that order. So, there are no unvisited rooms.
In the second test case, the rooms that Ichigo visits have numbers 1, 2, 4, -1, -2, -4, 1, 2, ... in that order. So, there are two unvisited rooms namely the ones numbered 3 and -3.
In the third test case, the rooms that Ichigo visits have numbers -3, 3, -3, 3, ... in that order. So, there are six unvisited rooms namely the ones numbered 1, 2, 4, -4, -2, -1.
|
{"inputs": ["4\n1 1\n4 1\n4 -3\n1729 -786\n"], "outputs": ["0\n2\n6\n3170\n"]}
| 732
| 44
|
coding
|
Solve the programming task below in a Python markdown code block.
The country of Byalechinsk is running elections involving n candidates. The country consists of m cities. We know how many people in each city voted for each candidate.
The electoral system in the country is pretty unusual. At the first stage of elections the votes are counted for each city: it is assumed that in each city won the candidate who got the highest number of votes in this city, and if several candidates got the maximum number of votes, then the winner is the one with a smaller index.
At the second stage of elections the winner is determined by the same principle over the cities: the winner of the elections is the candidate who won in the maximum number of cities, and among those who got the maximum number of cities the winner is the one with a smaller index.
Determine who will win the elections.
-----Input-----
The first line of the input contains two integers n, m (1 ≤ n, m ≤ 100) — the number of candidates and of cities, respectively.
Each of the next m lines contains n non-negative integers, the j-th number in the i-th line a_{ij} (1 ≤ j ≤ n, 1 ≤ i ≤ m, 0 ≤ a_{ij} ≤ 10^9) denotes the number of votes for candidate j in city i.
It is guaranteed that the total number of people in all the cities does not exceed 10^9.
-----Output-----
Print a single number — the index of the candidate who won the elections. The candidates are indexed starting from one.
-----Examples-----
Input
3 3
1 2 3
2 3 1
1 2 1
Output
2
Input
3 4
10 10 3
5 1 6
2 2 2
1 5 7
Output
1
-----Note-----
Note to the first sample test. At the first stage city 1 chosen candidate 3, city 2 chosen candidate 2, city 3 chosen candidate 2. The winner is candidate 2, he gained 2 votes.
Note to the second sample test. At the first stage in city 1 candidates 1 and 2 got the same maximum number of votes, but candidate 1 has a smaller index, so the city chose candidate 1. City 2 chosen candidate 3. City 3 chosen candidate 1, due to the fact that everyone has the same number of votes, and 1 has the smallest index. City 4 chosen the candidate 3. On the second stage the same number of cities chose candidates 1 and 3. The winner is candidate 1, the one with the smaller index.
|
{"inputs": ["1 1\n0\n", "1 1\n0\n", "2 1\n0 0\n", "2 1\n0 0\n", "1 3\n5\n3\n2\n", "3 1\n1 2 3\n", "3 1\n0 0 0\n", "3 1\n1 2 3\n"], "outputs": ["1", "1\n", "1", "1\n", "1", "3", "1", "3\n"]}
| 569
| 117
|
coding
|
Solve the programming task below in a Python markdown code block.
Naman owns a very famous Ice Cream parlour in Pune. He has a wide range of flavours with different pricing.
Every flavour costs ₹ X per gram and quantity of each flavour in the parlour is indefinite. Now, Naman has
received an order for a party wherein he is asked to prepare each Ice Cream with N number of flavours.
He needs to prepare each Ice Cream of W grams and at the same time has to keep the cost minimum.
Can you help him out?
Note: If it is not possible to prepare such an Ice Cream, print “Not Possible”.
-----Input:-----
First line contains an integer T denoting the number of test cases.
First line of every test case contains an integer N denoting the number of flavours.
The second line of every test case by N space separated integers denoting the cost per gram of each flavour.
Second line of every test case contains two space separated integers W and Y denoting the weight
of Ice Cream in grams and the number of flavours to be used respectively.
-----Output:-----
For each test case, print the total cost of the Ice Cream in a single line.
-----Constraints:-----
1 ≤ T ≤ 100
1 ≤ N,W,Y ≤ 40000
-----Example:-----Input:
2
5
4 6 8 1 10
10 3
2
1 2
1 2Output:
18
Not Possible
-----Explanation:-----
In the first test case to achieve the minimum cost, the Ice Cream will consist of 8 grams
of flavour costing ₹1, 1 gram of flavour costing ₹4 and 1 gram of flavour costing ₹6.
In the second test case it is not possible to make an ice-cream weighing 1 gram using 2 flavours.
|
{"inputs": ["2\n5\n4 6 8 1 10\n10 3\n2\n1 2\n1 2"], "outputs": ["18\nNot Possible"]}
| 390
| 44
|
coding
|
Solve the programming task below in a Python markdown code block.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
|
{"inputs": ["3 1\nerase 0\nerase 0\nerase -2147483648\n", "3 1\nerase -1\nerase 0\nerase -2147483648\n", "3 1\nerase -1\nerase 0\nerase -2666718247\n", "6 10\nalloc 6\nalloc 3\nerase 1\nalloc 6\ndefragment\nalloc 6\n", "6 4\nalloc 5\nalloc 3\nerase 2\nalloc 18\ndefragment\nalloc 6\n", "6 6\nalloc 5\nalloc 3\nerase 1\nalloc 10\ndefragment\nalloc 6\n", "6 10\nalloc 6\nalloc 3\nerase 2\nalloc 6\ndefragment\nalloc 6\n", "6 4\nalloc 5\nalloc 3\nerase 2\nalloc 28\ndefragment\nalloc 6\n"], "outputs": ["ILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\n", "ILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\n", "ILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\nILLEGAL_ERASE_ARGUMENT\n", "1\n2\n3\nNULL\n", "NULL\n1\nILLEGAL_ERASE_ARGUMENT\nNULL\nNULL\n", "1\nNULL\nNULL\n2\n", "1\n2\nNULL\nNULL\n", "NULL\n1\nILLEGAL_ERASE_ARGUMENT\nNULL\nNULL\n"]}
| 704
| 373
|
coding
|
Solve the programming task below in a Python markdown code block.
There are $n$ children, numbered $1,2,\ldots,n$, sitting around a circle in a clockwise manner. The ${i}$th child has a piece of paper with the number $a_i$ written on it. They play the following game:
In the ${1}$st round, the child numbered ${i}$ increases his number by the sum of the numbers of his neighbors.
In the $2$nd round, the child next in clockwise order increases his number by the sum of the numbers of his neighbors.
In the $3$rd round, the child next in clockwise order increases his number by the sum of the numbers of his neighbors.
And so on.
The game ends after $m$ rounds have been played.
For every ${i}$, find the numbers that the children end up with if the game starts with child ${i}$ playing the first round. Since the numbers can be large, output them modulo $10^9+7$.
Input Format
The first line contains ${t}$, the number of test cases. ${t}$ cases follow.
The first line of each test case contains two space-separated integers $n$ and $m$. The next line contains $n$ integers, the ${i}$th of which is $a_i$.
Constraints
$1\leq t\leq15$
$3\leq n\leq50$
$1\leq m\leq10^9$
$1\leq a_i\leq10^9$
Output Format
For each test case, print $n$ lines, each having $n$ integers. The $j$th integer on the ${i}$th line contains the number that the $j$th child ends up with if the game starts with child ${i}$ playing the first round.
Print a blank line after each test case except the last one.
Since the numbers can be large, output them modulo $10^9+7$.
Sample Input 0
2
5 1
10 20 30 40 50
3 4
1 2 1
Sample Output 0
80 20 30 40 50
10 60 30 40 50
10 20 90 40 50
10 20 30 120 50
10 20 30 40 100
23 7 12
11 21 6
7 13 24
|
{"inputs": ["2\n5 1\n10 20 30 40 50\n3 4\n1 2 1\n"], "outputs": ["80 20 30 40 50\n10 60 30 40 50\n10 20 90 40 50\n10 20 30 120 50\n10 20 30 40 100\n\n23 7 12\n11 21 6\n7 13 24\n"]}
| 575
| 143
|
coding
|
Solve the programming task below in a Python markdown code block.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
- 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
- T_i = A (T_i is the i-th character of T from the beginning.)
- T_j = B
- T_k = C
For example, when T = ABCBC, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is A, B, C or ?.
Let Q be the number of occurrences of ? in S. We can make 3^Q strings by replacing each occurrence of ? in S with A, B or C. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
-----Constraints-----
- 3 ≤ |S| ≤ 10^5
- Each character of S is A, B, C or ?.
-----Input-----
Input is given from Standard Input in the following format:
S
-----Output-----
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
-----Sample Input-----
A??C
-----Sample Output-----
8
In this case, Q = 2, and we can make 3^Q = 9 strings by by replacing each occurrence of ? with A, B or C. The ABC number of each of these strings is as follows:
- AAAC: 0
- AABC: 2
- AACC: 0
- ABAC: 1
- ABBC: 2
- ABCC: 2
- ACAC: 0
- ACBC: 1
- ACCC: 0
The sum of these is 0 + 2 + 0 + 1 + 2 + 2 + 0 + 1 + 0 = 8, so we print 8 modulo 10^9 + 7, that is, 8.
|
{"inputs": ["ABC\n", "AAA\n", "ACB\n", "???\n", "?C?\n", "?BC\n", "??AC", "A??C"], "outputs": ["1\n", "0\n", "0\n", "1\n", "0\n", "1\n", "1\n", "8"]}
| 505
| 73
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese and Russian.
Yesterday Chef had a great party and doesn't remember the way he celebreated it. But he found a strange paper in his kitchen containing n digits (lets give them indices from 1 to n and name them a_{1}, a_{2} ... a_{N}).
Chef remembers that he played such game:
On each step he choose an index x from 1 to n.
For all indices y (y < x) he calculated the difference b_{y} = a_{x} - a_{y}.
Then he calculated B1 - sum of all b_{y} which are greater than 0 and B2 - sum of all b_{y} which are less than 0.
The answer for this step is B1 - B2.
Chef remembers the game, but forgot the answer. Please, help him!
------ Input ------
The first line contains two integers n, m denoting the number of digits and number of steps. The second line contains n digits (without spaces) a_{1}, a_{2}, ..., a_{n}.
Each of next m lines contains single integer x denoting the index for current step.
------ Output ------
For each of m steps print single number in a line - answer of the step.
------ Constraints ------
$1 ≤ n, m ≤ 10^{5}$
$0 ≤ a_{i} ≤ 9$
$1 ≤ x ≤ n$
----- Sample Input 1 ------
10 3
0324152397
1
4
7
----- Sample Output 1 ------
0
7
9
----- explanation 1 ------
For index 1 there are no indexes which are less, so B1 = B2 = 0 and the answer is 0.
For index 4 we have
b1 = 4-0=4,
b2 = 4-3=1,
b3 = 4-2=2,
so B1 = 4+1+2 = 7, B2 = 0
and the answer is 7.
For index 7 we have
b1 = 2-0=2,
b2 = 2-3=-1,
b3 = 2-2=0,
b4 = 2-4=-2,
b5 = 2-1=1,
b6 = 2-5=-3,
so B1 = 2 + 1 = 3,
B2 = -1 -2 -3 = -6
and the answer is 9.
|
{"inputs": ["10 3\n0324152397\n1\n4\n7", "10 3\n0324152397\n1\n6\n7", "10 1\n0324152397\n1\n6\n7", "10 2\n0324152397\n1\n6\n7", "10 3\n0324152397\n2\n4\n7", "10 2\n0324152397\n1\n7\n7", "10 3\n0324152397\n1\n3\n7", "10 3\n0324152397\n3\n1\n7"], "outputs": ["0\n7\n9", "0\n15\n9\n", "0\n", "0\n15\n", "3\n7\n9\n", "0\n9\n", "0\n3\n9\n", "3\n0\n9\n"]}
| 572
| 247
|
coding
|
Solve the programming task below in a Python markdown code block.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
|
{"inputs": ["4\n2 4\n1 3\n3 1\n4 2", "4\n2 4\n1 3\n3 2\n4 1", "4\n1 4\n2 3\n3 2\n4 1", "4\n1 4\n2 2\n3 1\n4 3", "4\n2 4\n1 2\n3 1\n4 3", "4\n2 4\n1 3\n3 1\n4 2", "4\n2 4\n1 3\n3 2\n4 1", "4\n1 4\n3 3\n2 1\n4 2"], "outputs": ["2\n2\n2\n2\n", "2\n2\n1\n1\n", "1\n1\n1\n1\n", "1\n3\n3\n3\n", "4\n4\n4\n4\n", "2\n2\n2\n2\n", "2\n2\n1\n1\n", "1\n3\n3\n3\n"]}
| 401
| 238
|
coding
|
Solve the programming task below in a Python markdown code block.
Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or null/nil value then it should return an empty array.
For example:
```python
solution([1,2,3,10,5]) # should return [1,2,3,5,10]
solution(None) # should return []
```
```Hakell
sortNumbers [1, 2, 10, 50, 5] = Just [1, 2, 5, 10, 50]
sortNumbers [] = Nothing
```
Also feel free to reuse/extend the following starter code:
```python
def solution(nums):
```
|
{"functional": "_inputs = [[[1, 2, 3, 10, 5]], [None], [[]], [[20, 2, 10]], [[2, 20, 10]]]\n_outputs = [[[1, 2, 3, 5, 10]], [[]], [[]], [[2, 10, 20]], [[2, 10, 20]]]\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])"}
| 162
| 232
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has an array A of size N and an integer M, such that 1 ≤ A_{i} ≤ M for every 1 ≤ i ≤ N.
The *distance* of an array B from array A is defined as:
d(A, B) = \sum_{i=1}^N |A_{i} - B_{i}|
Chef wants an array B of size N, such that 1 ≤ B_{i} ≤ M and the value d(A, B) is as large as possible, i.e, the distance of B from A is maximum.
Find the maximum distance for any valid array B.
Note: |X| denotes the absolute value of an integer X. For example, |-4| = 4 and |7| = 7.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- Each test case consists of two lines of input.
- The first line of each test case contains two space-separated integers N and M — the length of array A and the limit on the elements of A and B.
- The second line contains N space-separated integers A_{1}, A_{2}, \ldots, A_{N}.
------ Output Format ------
For each test case, output on a new line the maximum distance of an array from A.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 2\cdot 10^{5}$
$1 ≤ M ≤ 10^{9}$
$1 ≤ A_{i} ≤ M$
- The sum of $N$ over all test cases won't exceed $3\cdot 10^{5}$.
----- Sample Input 1 ------
4
2 6
3 5
4 1
1 1 1 1
5 7
2 3 4 5 6
7 24
23 7 6 16 12 4 24
----- Sample Output 1 ------
7
0
21
127
----- explanation 1 ------
Test case $1$: The array having maximum distance from $A$ is $B = [6, 1]$. Thus the distance is $|3-6| + |5-1| = 3+4=7$.
Test case $2$: The only array possible is $B = [1,1,1,1]$. The distance of this array from $A$ is $0$.
Test case $3$: One of the possible arrays having maximum distance from $A$ is $B = [7,7,1,1,1]$. Thus the distance is $|2-7| + |3-7| + |4-1| + |5-1| + |6-1| = 5+4+3+4+5=21$.
|
{"inputs": ["4\n2 6\n3 5\n4 1\n1 1 1 1\n5 7\n2 3 4 5 6\n7 24\n23 7 6 16 12 4 24\n"], "outputs": ["7\n0\n21\n127\n"]}
| 632
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has an array consisting of N + K - 1 integers. The array contains only the first N positive odd numbers. Each number appears exactly once, except for one number which appears exactly K times. The sum of integers in Chef's array is equal to S.
For example, for N = 3, K = 2, the possible arrays could be [1, 1, 3, 5], [3, 1, 3, 5], [5, 3, 5, 1]. For N = 1, K = 3, there is only one possible array: [1, 1, 1].
Chef gives you three integers N, K and S and asks you to find the only element which appears K times in his array.
It is guaranteed that for the given input, there exists a valid array consisting of N + K -1 elements with a sum exactly equal to S.
------ Input Format ------
- 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 N, K, S.
------ Output Format ------
For each test case, print a single line containing the integer which appeared K times in Chef's array.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 10^{4}$
$1 ≤ S ≤ 10^{9}$
$2 ≤ K ≤ 10^{4}$
----- Sample Input 1 ------
3
3 2 14
5 4 28
2 3 10
----- Sample Output 1 ------
5
1
3
----- explanation 1 ------
Test case $1$: Chef's array could be $[5, 3, 5, 1]$.
Test case $3$: Chef's array could be $[3, 1, 3, 3]$.
|
{"inputs": ["3\n3 2 14\n5 4 28\n2 3 10\n"], "outputs": ["5\n1\n3\n"]}
| 434
| 39
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an array nums sorted in non-decreasing order, return the maximum between the number of positive integers and the number of negative integers.
In other words, if the number of positive integers in nums is pos and the number of negative integers is neg, then return the maximum of pos and neg.
Note that 0 is neither positive nor negative.
Please complete the following python code precisely:
```python
class Solution:
def maximumCount(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [-2,-1,-1,1,2,3]) == 3\n assert candidate(nums = [-3,-2,-1,0,0,1,2]) == 3\n assert candidate(nums = [5,20,66,1314]) == 4\n\n\ncheck(Solution().maximumCount)"}
| 117
| 88
|
coding
|
Solve the programming task below in a Python markdown code block.
Ivan is a student at Berland State University (BSU). There are n days in Berland week, and each of these days Ivan might have some classes at the university.
There are m working hours during each Berland day, and each lesson at the university lasts exactly one hour. If at some day Ivan's first lesson is during i-th hour, and last lesson is during j-th hour, then he spends j - i + 1 hours in the university during this day. If there are no lessons during some day, then Ivan stays at home and therefore spends 0 hours in the university.
Ivan doesn't like to spend a lot of time in the university, so he has decided to skip some lessons. He cannot skip more than k lessons during the week. After deciding which lessons he should skip and which he should attend, every day Ivan will enter the university right before the start of the first lesson he does not skip, and leave it after the end of the last lesson he decides to attend. If Ivan skips all lessons during some day, he doesn't go to the university that day at all.
Given n, m, k and Ivan's timetable, can you determine the minimum number of hours he has to spend in the university during one week, if he cannot skip more than k lessons?
-----Input-----
The first line contains three integers n, m and k (1 ≤ n, m ≤ 500, 0 ≤ k ≤ 500) — the number of days in the Berland week, the number of working hours during each day, and the number of lessons Ivan can skip, respectively.
Then n lines follow, i-th line containing a binary string of m characters. If j-th character in i-th line is 1, then Ivan has a lesson on i-th day during j-th hour (if it is 0, there is no such lesson).
-----Output-----
Print the minimum number of hours Ivan has to spend in the university during the week if he skips not more than k lessons.
-----Examples-----
Input
2 5 1
01001
10110
Output
5
Input
2 5 0
01001
10110
Output
8
-----Note-----
In the first example Ivan can skip any of two lessons during the first day, so he spends 1 hour during the first day and 4 hours during the second day.
In the second example Ivan can't skip any lessons, so he spends 4 hours every day.
|
{"inputs": ["1 1 5\n1\n", "1 1 1\n0\n", "1 1 1\n1\n", "1 1 2\n1\n", "1 1 0\n1\n", "1 1 2\n0\n", "1 1 5\n1\n", "1 1 1\n1\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "1\n", "0\n", "0", "0"]}
| 537
| 116
|
coding
|
Solve the programming task below in a Python markdown code block.
Bear Limak has n colored balls, arranged in one long row. Balls are numbered 1 through n, from left to right. There are n possible colors, also numbered 1 through n. The i-th ball has color t_{i}.
For a fixed interval (set of consecutive elements) of balls we can define a dominant color. It's a color occurring the biggest number of times in the interval. In case of a tie between some colors, the one with the smallest number (index) is chosen as dominant.
There are $\frac{n \cdot(n + 1)}{2}$ non-empty intervals in total. For each color, your task is to count the number of intervals in which this color is dominant.
-----Input-----
The first line of the input contains a single integer n (1 ≤ n ≤ 5000) — the number of balls.
The second line contains n integers t_1, t_2, ..., t_{n} (1 ≤ t_{i} ≤ n) where t_{i} is the color of the i-th ball.
-----Output-----
Print n integers. The i-th of them should be equal to the number of intervals where i is a dominant color.
-----Examples-----
Input
4
1 2 1 2
Output
7 3 0 0
Input
3
1 1 1
Output
6 0 0
-----Note-----
In the first sample, color 2 is dominant in three intervals: An interval [2, 2] contains one ball. This ball's color is 2 so it's clearly a dominant color. An interval [4, 4] contains one ball, with color 2 again. An interval [2, 4] contains two balls of color 2 and one ball of color 1.
There are 7 more intervals and color 1 is dominant in all of them.
|
{"inputs": ["1\n1\n", "1\n1\n", "2\n2 1\n", "2\n2 1\n", "2\n2 2\n", "3\n1 1 1\n", "3\n2 1 1\n", "3\n1 1 1\n"], "outputs": ["1 \n", "1 ", "2 1 \n", "2 1 ", "0 3\n", "6 0 0 \n", "5 1 0\n", "6 0 0 "]}
| 412
| 123
|
coding
|
Solve the programming task below in a Python markdown code block.
Tom is very fond of adding values , so what he does whenever he gets a value he adds all its digits and forms a new value and checks it whether it has become a single digit or not and if it does not even becomes a single digit he apply the operation again and adds all its digits once again and he continues to do this process repeat and repeat until he gets a single digit.
Input
First line of input contains the number of test cases(T). Next each of T lines contains a integer value.
Output
You have to print the single digit answer for each test case.
Constraints
1<T ≤ 100
1<value ≤ 10^5
SAMPLE INPUT
3
167
569
102
SAMPLE OUTPUT
5
2
3
Explanation
167 = 1+6+7 = 14 = 1+4 = 5
569 = 5+6+9 = 20 = 2+0 = 2
102 = 1+0+2 = 3
|
{"inputs": ["72\n147\n1009\n994\n5564\n9999\n1547\n18894\n1475\n5554\n8457\n32254\n14562\n18995\n5624\n65412\n1235\n2356\n1113\n1555\n4631\n8641\n2945\n8466\n3214\n4412\n6594\n3120\n55\n964\n1584\n6645\n3472\n12\n6642\n34454\n4851\n6524\n6314\n7516\n9547\n8714\n8214\n6425\n7132\n5621\n1203\n2350\n563\n1223\n4584\n6424\n2154\n9945\n3574\n21548\n33154\n22004\n6522\n564\n22213\n5478\n6221\n3547\n6644\n5986\n8614\n3364\n2475\n8282\n6446\n5964\n4475"], "outputs": ["3\n1\n4\n2\n9\n8\n3\n8\n1\n6\n7\n9\n5\n8\n9\n2\n7\n6\n7\n5\n1\n2\n6\n1\n2\n6\n6\n1\n1\n9\n3\n7\n3\n9\n2\n9\n8\n5\n1\n7\n2\n6\n8\n4\n5\n6\n1\n5\n8\n3\n7\n3\n9\n1\n2\n7\n8\n6\n6\n1\n6\n2\n1\n2\n1\n1\n7\n9\n2\n2\n6\n2"]}
| 242
| 516
|
coding
|
Solve the programming task below in a Python markdown code block.
Iahub got lost in a very big desert. The desert can be represented as a n × n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 ≤ i, j ≤ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1).
Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter.
Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n).
-----Input-----
The first line contains two integers n (1 ≤ n ≤ 10^9) and m (1 ≤ m ≤ 10^5). Each of the next m lines contains a pair of integers, x and y (1 ≤ x, y ≤ n), representing the coordinates of the volcanoes.
Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
-----Output-----
Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1.
-----Examples-----
Input
4 2
1 3
1 4
Output
6
Input
7 8
1 6
2 6
3 5
3 6
4 3
5 1
5 2
5 3
Output
12
Input
2 2
1 2
2 1
Output
-1
-----Note-----
Consider the first sample. A possible road is: (1, 1) → (1, 2) → (2, 2) → (2, 3) → (3, 3) → (3, 4) → (4, 4).
|
{"inputs": ["2 1\n1 2\n", "2 1\n2 2\n", "2 1\n2 2\n", "2 1\n2 2\n", "2 1\n1 2\n", "12 1\n7 4\n", "12 1\n7 4\n", "12 1\n12 4\n"], "outputs": ["2\n", "-1\n", "-1\n", "-1\n", "2\n", "22\n", "22\n", "22\n"]}
| 507
| 125
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a string s consisting of lowercase English letters, and you are allowed to perform operations on it. In one operation, you can replace a character in s with another lowercase English letter.
Your task is to make s a palindrome with the minimum number of operations possible. If there are multiple palindromes that can be made using the minimum number of operations, make the lexicographically smallest one.
A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b.
Return the resulting palindrome string.
Please complete the following python code precisely:
```python
class Solution:
def makeSmallestPalindrome(self, s: str) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"egcfe\") == \"efcfe\"\n assert candidate(s = \"abcd\") == \"abba\"\n assert candidate(s = \"seven\") == \"neven\"\n\n\ncheck(Solution().makeSmallestPalindrome)"}
| 184
| 66
|
coding
|
Solve the programming task below in a Python markdown code block.
Given $N *M$ matrix containing elements either $1$ or $0$ and string S of length $N+M-1$ containing characters $0$ or $1$. Your task is to make all the paths from top left corner to the bottom right corner of the matrix same as the given string .You can perform two types of operations any time .Path means you can only allow it to take right or down.
Operations :
- Changing the matrix elements from $1$ to $0$ or vice versa will cost P rupees per element.
- Changing the character of string from $1$ to $0$ or vice versa will cost Q rupees per character.
You have to minimize the cost, (possibly 0) .
-----Input:-----
- First line of input contains the total no. of test cases $T$.
- For every test case, first line of input contains two spaced positive integers, $N$ and $M$.
- Next $N$ lines contains $M$-spaced integers which can be only $0$ or $1$.
- Next line of input contains a string $S$ of length $N+M-1$.
- Last line of input contains two spaced integers, $P$ and $Q$.
-----Output:-----
- $You$ $have$ $to$ $print$ $the$ $minimum$ $cost .$
-----Constraints-----
- $1 \leq T \leq 20$
- $1 \leq N, M \leq 1000$
- $|S| = N+M-1$
- $0 \leq P, Q \leq 1000$The input/output is quite large, please use fast reading and writing methods.
-----Sample Input-----
2
3 3
1 0 1
0 1 1
1 1 0
10111
10 5
3 3
0 0 1
0 1 1
0 1 1
00011
2 9
-----Sample Output-----
5
4
-----Explanation-----
- You can change the last element of the matrix and also can change the last element of string but the minimum cost will produce by changing string element , therefore it will cost 5 rupees.
|
{"inputs": ["2\n3 3\n1 0 1\n0 1 1\n1 1 0\n10111\n10 5\n3 3\n0 0 1\n0 1 1\n0 1 1\n00011\n2 9"], "outputs": ["5\n4"]}
| 511
| 79
|
coding
|
Solve the programming task below in a Python markdown code block.
Given a set of N integer points on the Cartesian plane. Your task is to find an integer point satisfying its sum of distances to N given points (S) is minimum.
------ Input ------
There are several test cases (fifteen at most), each formed as follows:
The first line contains a positive integer N (N ≤ 2,000).
N lines follow, each containing a pair of integers (each having an absolute value of 10^{9} at most) describing coordinates of a given point.
The input is ended with N = 0.
------ Output ------
For each test case, output on a line a real number (with exactly 6 decimal places) which is the respective minimum sum S found.
----- Sample Input 1 ------
3
1 1
2 2
3 3
5
1 4
2 3
5 2
3 5
4 1
0
----- Sample Output 1 ------
2.828427
9.640986
|
{"inputs": ["3\n1 1\n2 2\n3 3\n5\n1 4\n2 3\n5 2\n3 5\n4 1\n0\n"], "outputs": ["2.828427\n9.640986"]}
| 232
| 65
|
coding
|
Solve the programming task below in a Python markdown code block.
You will be given two ASCII strings, `a` and `b`. Your task is write a function to determine which one of these strings is "worth" more, and return it.
A string's worth is determined by the sum of its ASCII codepoint indexes. So, for example, the string `HELLO` has a value of 372: H is codepoint 72, E 69, L 76, and O is 79. The sum of these values is 372.
In the event of a tie, you should return the first string, i.e. `a`.
Also feel free to reuse/extend the following starter code:
```python
def highest_value(a, b):
```
|
{"functional": "_inputs = [['AaBbCcXxYyZz0189', 'KkLlMmNnOoPp4567'], ['ABcd', '0123'], ['!\"?$%^&*()', \"{}[]@~'#:;\"], ['ABCD', 'DCBA']]\n_outputs = [['KkLlMmNnOoPp4567'], ['ABcd'], [\"{}[]@~'#:;\"], ['ABCD']]\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(highest_value(*i), o[0])"}
| 166
| 257
|
coding
|
Solve the programming task below in a Python markdown code block.
During a daily walk Alina noticed a long number written on the ground. Now Alina wants to find some positive number of same length without leading zeroes, such that the sum of these two numbers is a palindrome.
Recall that a number is called a palindrome, if it reads the same right to left and left to right. For example, numbers $121, 66, 98989$ are palindromes, and $103, 239, 1241$ are not palindromes.
Alina understands that a valid number always exist. Help her find one!
-----Input-----
The first line of input data contains an integer $t$ ($1 \leq t \leq 100$) — the number of test cases. Next, descriptions of $t$ test cases follow.
The first line of each test case contains a single integer $n$ ($2 \leq n \leq 100000$) — the length of the number that is written on the ground.
The second line of contains the positive $n$-digit integer without leading zeroes — the number itself.
It is guaranteed that the sum of the values $n$ over all test cases does not exceed $100000$.
-----Output-----
For each of $t$ test cases print an answer — a positive $n$-digit integer without leading zeros, such that the sum of the input integer and this number is a palindrome.
We can show that at least one number satisfying the constraints exists. If there are multiple solutions, you can output any of them.
-----Examples-----
Input
3
2
99
4
1023
3
385
Output
32
8646
604
-----Note-----
In the first test case $99 + 32 = 131$ is a palindrome. Note that another answer is $12$, because $99 + 12 = 111$ is also a palindrome.
In the second test case $1023 + 8646 = 9669$.
In the third test case $385 + 604 = 989$.
|
{"inputs": ["1\n3\n100\n", "1\n3\n109\n", "3\n2\n99\n4\n1023\n3\n385\n"], "outputs": ["899\n", "890\n", "12\n8976\n614\n"]}
| 490
| 74
|
coding
|
Solve the programming task below in a Python markdown code block.
Pupils Alice and Ibragim are best friends. It's Ibragim's birthday soon, so Alice decided to gift him a new puzzle. The puzzle can be represented as a matrix with $2$ rows and $n$ columns, every element of which is either $0$ or $1$. In one move you can swap two values in neighboring cells.
More formally, let's number rows $1$ to $2$ from top to bottom, and columns $1$ to $n$ from left to right. Also, let's denote a cell in row $x$ and column $y$ as $(x, y)$. We consider cells $(x_1, y_1)$ and $(x_2, y_2)$ neighboring if $|x_1 - x_2| + |y_1 - y_2| = 1$.
Alice doesn't like the way in which the cells are currently arranged, so she came up with her own arrangement, with which she wants to gift the puzzle to Ibragim. Since you are her smartest friend, she asked you to help her find the minimal possible number of operations in which she can get the desired arrangement. Find this number, or determine that it's not possible to get the new arrangement.
-----Input-----
The first line contains an integer $n$ ($1 \leq n \leq 200000$) — the number of columns in the puzzle.
Following two lines describe the current arrangement on the puzzle. Each line contains $n$ integers, every one of which is either $0$ or $1$.
The last two lines describe Alice's desired arrangement in the same format.
-----Output-----
If it is possible to get the desired arrangement, print the minimal possible number of steps, otherwise print $-1$.
-----Examples-----
Input
5
0 1 0 1 0
1 1 0 0 1
1 0 1 0 1
0 0 1 1 0
Output
5
Input
3
1 0 0
0 0 0
0 0 0
0 0 0
Output
-1
-----Note-----
In the first example the following sequence of swaps will suffice:
$(2, 1), (1, 1)$,
$(1, 2), (1, 3)$,
$(2, 2), (2, 3)$,
$(1, 4), (1, 5)$,
$(2, 5), (2, 4)$.
It can be shown that $5$ is the minimal possible answer in this case.
In the second example no matter what swaps you do, you won't get the desired arrangement, so the answer is $-1$.
|
{"inputs": ["1\n0\n1\n1\n0\n", "3\n1 0 0\n0 0 0\n0 0 0\n0 0 0\n", "5\n0 1 0 1 0\n1 1 0 0 1\n1 0 1 0 1\n0 0 1 1 0\n", "7\n1 0 0 1 1 0 1\n1 0 0 0 1 1 1\n1 1 1 0 0 1 0\n0 1 1 1 0 0 0\n", "7\n0 0 1 0 1 0 1\n0 0 0 0 0 0 1\n0 1 0 1 0 1 0\n1 0 0 0 0 0 0\n", "7\n0 0 0 0 0 0 0\n1 0 0 0 0 0 0\n0 0 0 0 0 1 0\n0 0 0 0 0 0 0\n", "7\n0 0 0 0 0 0 0\n1 0 0 0 0 0 0\n0 1 0 0 0 0 0\n0 0 0 0 0 0 0\n", "7\n0 0 1 0 0 0 0\n1 1 0 0 1 0 1\n1 0 0 1 1 1 0\n0 0 0 0 0 1 0\n"], "outputs": ["1\n", "-1\n", "5\n", "-1\n", "9\n", "6\n", "2\n", "9\n"]}
| 602
| 422
|
coding
|
Solve the programming task below in a Python markdown code block.
Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI — to 12.
Pay attention to the difference to the traditional roman system — in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 ≤ n ≤ 10^9) — the number of roman digits to use.
Output
Output a single integer — the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented — I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL).
|
{"inputs": ["6\n", "8\n", "4\n", "9\n", "3\n", "5\n", "7\n", "1\n"], "outputs": ["83\n", "155\n", "35\n", "198\n", "20\n", "56\n", "116\n", "4\n"]}
| 390
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef had an array A of length N such that 1 ≤ A_{i} ≤ N for all 1 ≤ i ≤ N. Chef constructed another binary array B of length N in the following manner:
B_{i} = 1 if the frequency of element i in A is *odd*.
B_{i} = 0 if the frequency of element i in A is *even*.
Such an array B is called the *parity encoding* array of A.
For example, if A = [1, 1, 2, 3], then B = [0, 1, 1, 0].
Unfortunately, Chef completely forgot the array A and vaguely remembers the *parity encoding* array B. He is now wondering whether there exists any valid array A for which the *parity encoding* array is B. Can you help Chef?
------ Input Format ------
- The first line contains a single integer T — the number of test cases. Then the test cases follow.
- The first line of each test case contains an integer N — the size of the arrays A and B.
- The second line of each test case contains N space-separated integers B_{1}, B_{2}, \dots, B_{N} denoting the *parity encoding* array B.
------ Output Format ------
For each test case, output YES if there exists any valid array A for which the *parity encoding* array is B. Otherwise, output NO.
You may print each character of YES and NO in uppercase or lowercase (for example, yes, yEs, Yes will be considered identical).
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$B_{i} \in \{0, 1\}$
- Sum of $N$ over all test cases does not exceed $2 \cdot 10^{5}$.
----- Sample Input 1 ------
3
4
0 1 0 1
5
1 1 1 1 0
6
1 1 1 1 1 1
----- Sample Output 1 ------
YES
NO
YES
----- explanation 1 ------
Test case $1$: $A = [2, 4, 3, 3]$ is a valid array for the given array $B$.
Test case $2$: It can be proven that there does not exist any array $A$ for the given parity encoding array $B$.
Test case $3$: $A = [1, 2, 3, 4, 5, 6]$ is a valid array for the given array $B$.
|
{"inputs": ["3\n4\n0 1 0 1\n5\n1 1 1 1 0\n6\n1 1 1 1 1 1\n"], "outputs": ["YES\nNO\nYES\n"]}
| 569
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
The activity of a panipuri seller is "making a panipuri and putting it on the palte of his customer".
$N$ customers are eating panipuri, Given an array $A$ of length $N$, $i^{th}$ customer takes $A_i$ seconds to eat a panipuri.
The Speed of Panipuri seller refers to the number of customers served per second. Determine the minimum speed of panipuri seller so that no customer has to wait for panipuri after getting his/her first panipuri.
Assume that the plate can hold infinite panipuris, and customer starts eating next panipuri just after finishing the current one. You would be provided with the time taken by each customer to eat a panipuri.
Panpuri seller serves panipuri in round robin manner (first to last and then again first).
-----Input:-----
- First line will contain $T$, number of testcases. Then the test cases follow.
- For each test case, the first line contains $N$ number of customers.
- Then the second line will contain $N$ space separated integers, $A_1$ to $A_N$, eating time taken by each customer(in seconds).
-----Output:-----
- For each test case, print a single line containing the minimum integral speed of panipuri seller so that no customer has to wait.
-----Constraints-----
- $0 < T \leq 100$
- $0 < N \leq 10^6$
- $0 < A_i \leq 10^9$
- Sum of $N$ over all test cases does not exceed $10^6$
-----Sample Input:-----
2
4
2 4 6 3
5
2 3 4 6 5
-----Sample Output:-----
2
3
-----EXPLANATION:-----
$Test case$ $1$:
Let's assume speed of panipuri seller be 1.
So starting from $0^{th}$ second, in $0$ to $1$ second seller make a panipuri and put it into the plate of first customer, and first customer completely eat it in $1$ to $3$ second as he takes $2$ second to eat a panipuri. But in $3$ to $4$ second panipuri seller is serving to $4^{th}$ customer, and hence first customer have to wait, so 1 cannot be our answer.
Next possible speed can be $2$ .
Starting from $0^{th}$ second, at half second seller make a panipuri and put it into the plate of first customer, first customer completely eat it on $2.5$ second as he takes $2$ second to eat a panipuri. In $0.5$ to $1$ second, seller serve the second customer. similarly in $1$ to $2$ second $3^{rd}$ and $4^{th}$ customer will be serve, in $2$ to $2.5$ second, seller will again serve the first customer so at $2.5$ sec $1^{st}$ customer will have a panipuri to eat.
Similarly proceeding further we will find that no customer have to wait when speed is $2$.
|
{"inputs": ["2\n4\n2 4 6 3\n5\n2 3 4 6 5"], "outputs": ["2\n3"]}
| 702
| 36
|
coding
|
Solve the programming task below in a Python markdown code block.
There are S sheep and W wolves.
If the number of wolves is greater than or equal to that of sheep, the wolves will attack the sheep.
If the wolves will attack the sheep, print unsafe; otherwise, print safe.
-----Constraints-----
- 1 \leq S \leq 100
- 1 \leq W \leq 100
-----Input-----
Input is given from Standard Input in the following format:
S W
-----Output-----
If the wolves will attack the sheep, print unsafe; otherwise, print safe.
-----Sample Input-----
4 5
-----Sample Output-----
unsafe
There are four sheep and five wolves. The number of wolves is not less than that of sheep, so they will attack them.
|
{"inputs": ["1 5", "1 6", "0 6", "0 7", "0 8", "0 1", "0 0", "1 0"], "outputs": ["unsafe\n", "unsafe\n", "unsafe\n", "unsafe\n", "unsafe\n", "unsafe\n", "unsafe\n", "safe\n"]}
| 168
| 78
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a string s, a string chars of distinct characters and an integer array vals of the same length as chars.
The cost of the substring is the sum of the values of each character in the substring. The cost of an empty string is considered 0.
The value of the character is defined in the following way:
If the character is not in the string chars, then its value is its corresponding position (1-indexed) in the alphabet.
For example, the value of 'a' is 1, the value of 'b' is 2, and so on. The value of 'z' is 26.
Otherwise, assuming i is the index where the character occurs in the string chars, then its value is vals[i].
Return the maximum cost among all substrings of the string s.
Please complete the following python code precisely:
```python
class Solution:
def maximumCostSubstring(self, s: str, chars: str, vals: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"adaa\", chars = \"d\", vals = [-1000]) == 2\n assert candidate(s = \"abc\", chars = \"abc\", vals = [-1,-1,-1]) == 0\n\n\ncheck(Solution().maximumCostSubstring)"}
| 224
| 72
|
coding
|
Solve the programming task below in a Python markdown code block.
Given are two strings S and T consisting of lowercase English letters. Concatenate T and S in this order, without space in between, and print the resulting string.
-----Constraints-----
- S and T are strings consisting of lowercase English letters.
- The lengths of S and T are between 1 and 100 (inclusive).
-----Input-----
Input is given from Standard Input in the following format:
S T
-----Output-----
Print the resulting string.
-----Sample Input-----
oder atc
-----Sample Output-----
atcoder
When S = oder and T = atc, concatenating T and S in this order results in atcoder.
|
{"inputs": ["c a\n", "oder atb", "redo atb", "redp atb", "redp bta", "redo bta", "redo bat", "redo b`t"], "outputs": ["ac\n", "atboder\n", "atbredo\n", "atbredp\n", "btaredp\n", "btaredo\n", "batredo\n", "b`tredo\n"]}
| 145
| 92
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.
Please complete the following python code precisely:
```python
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums1 = [1,2,2,1], nums2 = [2,2]) == [2]\n assert candidate(nums1 = [4,9,5], nums2 = [9,4,9,8,4]) == [9,4]\n\n\ncheck(Solution().intersection)"}
| 90
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
In ChefLand, there is a mountain range consisting of $N$ hills (numbered $1$ through $N$) in a straight line. Let's denote the height of the $i$-th hill from the left by $h_i$.
Ada is working on the water supply system of ChefLand. On some of the hills, she wants to place water reservoirs; then, for each reservoir, she will decide in which direction the water should flow from it — either to the left or to the right (water may not flow in both directions from the same reservoir). From a reservoir on a hill with height $h$, water flows in the chosen direction until it reaches the first hill that is strictly higher than $h$; all hills before this hill (including the hill containing the reservoir) are therefore supplied with water.
For example, suppose we have hills with heights $[7, 2, 3, 5, 8]$. If we place a reservoir on the hill with height $5$, and pump water from it to the left, then the hills with heights $2$, $3$ and $5$ are supplied with water.
Help Ada find the minimum numer of reservoirs needed to provide water to all the hills if she chooses the directions optimally.
-----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 $h_1, h_2, \dots, h_N$.
-----Output-----
For each test case, print a single line containing one integer — the minimum required number of reservoirs.
-----Constraints-----
- $2 \le N \le 10^5$
- $1 \le h_i \le 10^9$ for each valid $i$
- $h_i \neq h_j $ for any valid $i \neq j$
- the sum of $N$ over all test cases does not exceed $5 \cdot 10^5$
-----Example Input-----
1
6
4 16 32 6 8 2
-----Example Output-----
2
-----Explanation-----
Example case 1: We can place reservoirs on the second and third hill, pumping water to the left and right respectively.
|
{"inputs": ["1\n6\n4 16 32 6 8 2\n"], "outputs": ["2 "]}
| 517
| 31
|
coding
|
Solve the programming task below in a Python markdown code block.
# Do you ever wish you could talk like Siegfried of KAOS ?
## YES, of course you do!
https://en.wikipedia.org/wiki/Get_Smart
# Task
Write the function ```siegfried``` to replace the letters of a given sentence.
Apply the rules using the course notes below. Each week you will learn some more rules.
Und by ze fifz vek yu vil be speakink viz un aksent lik Siegfried viz no trubl at al!
# Lessons
## Week 1
* ```ci``` -> ```si```
* ```ce``` -> ```se```
* ```c``` -> ```k``` (except ```ch``` leave alone)
## Week 2
* ```ph``` -> ```f```
## Week 3
* remove trailing ```e``` (except for all 2 and 3 letter words)
* replace double letters with single letters (e.g. ```tt``` -> ```t```)
## Week 4
* ```th``` -> ```z```
* ```wr``` -> ```r```
* ```wh``` -> ```v```
* ```w``` -> ```v```
## Week 5
* ```ou``` -> ```u```
* ```an``` -> ```un```
* ```ing``` -> ```ink``` (but only when ending words)
* ```sm``` -> ```schm``` (but only when beginning words)
# Notes
* You must retain the case of the original sentence
* Apply rules strictly in the order given above
* Rules are cummulative. So for week 3 first apply week 1 rules, then week 2 rules, then week 3 rules
Also feel free to reuse/extend the following starter code:
```python
def siegfried(week, txt):
```
|
{"functional": "_inputs = [[1, 'City civilians'], [1, 'Centre receiver'], [1, 'Chatanooga choo choo crashed'], [1, 'Capital city cats chew cheese'], [2, 'Photo of 5 pheasants with graphs'], [3, 'Meet me at the same place at noon'], [3, 'The time is now'], [3, 'Be quite quiet'], [3, 'Aardvarks are nice most of the time'], [5, 'And another thing Mr Smart, I want no more trouble!'], [5, 'You ought to behave yourself Smart!'], [5, 'Smart and 99 were husband and wife'], [5, '.. Mr Maxwell be The Smart ..'], [5, '.. Mr Maxwell be We Smart ..'], [5, 'Be be The the We we Me me She she'], [5, 'be Be the The we We me Me she She'], [5, 'be the wee me'], [5, 'be we Maxwell be We bee wee'], [5, 'Be like Me'], [5, 'be the same'], [5, 'The same bee we see'], [5, 'It was an inglorious ending']]\n_outputs = [['Sity sivilians'], ['Sentre reseiver'], ['Chatanooga choo choo krashed'], ['Kapital sity kats chew cheese'], ['Foto of 5 feasants with grafs'], ['Met me at the sam plas at non'], ['The tim is now'], ['Be quit quiet'], ['Ardvarks are nis most of the tim'], ['Und unozer zink Mr Schmart, I vunt no mor trubl!'], ['Yu ught to behav yurself Schmart!'], ['Schmart und 99 ver husbund und vif'], ['.. Mr Maxvel be Ze Schmart ..'], ['.. Mr Maxvel be Ve Schmart ..'], ['Be be Ze ze Ve ve Me me She she'], ['be Be ze Ze ve Ve me Me she She'], ['be ze ve me'], ['be ve Maxvel be Ve be ve'], ['Be lik Me'], ['be ze sam'], ['Ze sam be ve se'], ['It vas un inglorius endink']]\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(siegfried(*i), o[0])"}
| 389
| 618
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given two strings,write a method to decide if one is a permutation of the other.
Please complete the following python code precisely:
```python
class Solution:
def CheckPermutation(self, s1: str, s2: str) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(s1 = \"abc\", s2 = \"bca\") == True\n assert candidate(s1 = \"abc\", s2 = \"bad\") == False\n\n\ncheck(Solution().CheckPermutation)"}
| 71
| 57
|
coding
|
Solve the programming task below in a Python markdown code block.
At the beginning of the new semester there is new schedule in the Berland State University. According to this schedule, n groups have lessons at the room 31. For each group the starting time of the lesson and the finishing time of the lesson are known. It has turned out that it is impossible to hold all lessons, because for some groups periods of their lessons intersect. If at some moment of time one groups finishes it's lesson, and the other group starts the lesson, their lessons don't intersect.
The dean wants to cancel the lesson in one group so that no two time periods of lessons of the remaining groups intersect. You are to find all ways to do that.
Input
The first line contains integer n (1 ≤ n ≤ 5000) — amount of groups, which have lessons in the room 31. Then n lines follow, each of them contains two integers li ri (1 ≤ li < ri ≤ 106) — starting and finishing times of lesson of the i-th group. It is possible that initially no two lessons intersect (see sample 1).
Output
Output integer k — amount of ways to cancel the lesson in exactly one group so that no two time periods of lessons of the remaining groups intersect. In the second line output k numbers — indexes of groups, where it is possible to cancel the lesson. Groups are numbered starting from 1 in the order that they were given in the input. Output the numbers in increasing order.
Examples
Input
3
3 10
20 30
1 3
Output
3
1 2 3
Input
4
3 10
20 30
1 3
1 39
Output
1
4
Input
3
1 5
2 6
3 7
Output
0
|
{"inputs": ["3\n1 5\n2 6\n4 7\n", "3\n1 5\n2 6\n3 7\n", "3\n1 5\n2 6\n3 12\n", "3\n3 9\n20 30\n1 3\n", "3\n3 9\n20 30\n0 3\n", "3\n3 9\n20 55\n0 3\n", "3\n3 13\n20 55\n0 3\n", "3\n3 10\n20 30\n0 3\n"], "outputs": ["0\n\n", "0\n", "0\n\n", "3\n1 2 3\n", "3\n1 2 3\n", "3\n1 2 3\n", "3\n1 2 3\n", "3\n1 2 3\n"]}
| 394
| 211
|
coding
|
Solve the programming task below in a Python markdown code block.
Berland, 2016. The exchange rate of currency you all know against the burle has increased so much that to simplify the calculations, its fractional part was neglected and the exchange rate is now assumed to be an integer.
Reliable sources have informed the financier Anton of some information about the exchange rate of currency you all know against the burle for tomorrow. Now Anton knows that tomorrow the exchange rate will be an even number, which can be obtained from the present rate by swapping exactly two distinct digits in it. Of all the possible values that meet these conditions, the exchange rate for tomorrow will be the maximum possible. It is guaranteed that today the exchange rate is an odd positive integer n. Help Anton to determine the exchange rate of currency you all know for tomorrow!
-----Input-----
The first line contains an odd positive integer n — the exchange rate of currency you all know for today. The length of number n's representation is within range from 2 to 10^5, inclusive. The representation of n doesn't contain any leading zeroes.
-----Output-----
If the information about tomorrow's exchange rate is inconsistent, that is, there is no integer that meets the condition, print - 1.
Otherwise, print the exchange rate of currency you all know against the burle for tomorrow. This should be the maximum possible number of those that are even and that are obtained from today's exchange rate by swapping exactly two digits. Exchange rate representation should not contain leading zeroes.
-----Examples-----
Input
527
Output
572
Input
4573
Output
3574
Input
1357997531
Output
-1
|
{"inputs": ["11\n", "85\n", "21\n", "99\n", "21\n", "99\n", "11\n", "85\n"], "outputs": ["-1\n", "58\n", "12\n", "-1\n", "12\n", "-1\n", "-1\n", "58\n"]}
| 360
| 83
|
coding
|
Solve the programming task below in a Python markdown code block.
AtCoDeer the deer found two positive integers, a and b.
Determine whether the product of a and b is even or odd.
-----Constraints-----
- 1 ≤ a,b ≤ 10000
- a and b are integers.
-----Input-----
Input is given from Standard Input in the following format:
a b
-----Output-----
If the product is odd, print Odd; if it is even, print Even.
-----Sample Input-----
3 4
-----Sample Output-----
Even
As 3 × 4 = 12 is even, print Even.
|
{"inputs": ["4 4", "2 4", "3 0", "0 0", "0 1", "0 2", "1 2", "1 1"], "outputs": ["Even\n", "Even\n", "Even\n", "Even\n", "Even\n", "Even\n", "Even\n", "Odd\n"]}
| 133
| 78
|
coding
|
Solve the programming task below in a Python markdown code block.
While Alice was drinking sugarcane juice, she started wondering about the following facts:
The juicer sells each glass of sugarcane juice for 50 coins.
He spends 20\% of his total income on buying sugarcane.
He spends 20\% of his total income on buying salt and mint leaves.
He spends 30\% of his total income on shop rent.
Alice wonders, what is the juicer's profit (in coins) when he sells N glasses of sugarcane juice?
------ Input Format ------
- The first line of input will contain an integer T — the number of test cases. The description of T test cases follows.
- The first and only line of each test case contains an integer N, as described in the problem statement.
------ Output Format ------
For each test case, output on a new line the juicer's profit when he sells N glasses of juice.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 10^{6}$
----- Sample Input 1 ------
4
2
4
5
10
----- Sample Output 1 ------
30
60
75
150
----- explanation 1 ------
Test case $1$: The total income is $50\times 2 = 100$ coins. The juicer spends $20$ coins on sugarcane, $20$ coins on salt and mint leaves and $30$ coins on rent. Thus, the profit is $100-(20+20+30) = 30$ coins.
Test case $2$: The total income is $50\times 4 = 200$ coins. The juicer spends $40$ coins on sugarcane, $40$ coins on salt and mint leaves and $60$ coins on rent. Thus, the profit is $200-(40+40+60) = 60$ coins.
Test case $3$: The total income is $50\times 5 = 250$ coins. The juicer spends $50$ coins on sugarcane, $50$ coins on salt and mint leaves and $75$ coins on rent. Thus, the profit is $250-(50+50+75) = 75$ coins.
Test case $4$: The total income is $50\times 10 = 500$ coins. The juicer spends $100$ coins on sugarcane, $100$ coins on salt and mint leaves and $150$ coins on rent. Thus, the profit is $500-(100+100+150) = 150$ coins.
|
{"inputs": ["4\n2\n4\n5\n10\n"], "outputs": ["30\n60\n75\n150\n"]}
| 624
| 34
|
coding
|
Solve the programming task below in a Python markdown code block.
It's a Pokemon battle! Your task is to calculate the damage that a particular move would do using the following formula (not the actual one from the game):
Where:
* attack = your attack power
* defense = the opponent's defense
* effectiveness = the effectiveness of the attack based on the matchup (see explanation below)
Effectiveness:
Attacks can be super effective, neutral, or not very effective depending on the matchup. For example, water would be super effective against fire, but not very effective against grass.
* Super effective: 2x damage
* Neutral: 1x damage
* Not very effective: 0.5x damage
To prevent this kata from being tedious, you'll only be dealing with four types: `fire`, `water`, `grass`, and `electric`. Here is the effectiveness of each matchup:
* `fire > grass`
* `fire < water`
* `fire = electric`
* `water < grass`
* `water < electric`
* `grass = electric`
For this kata, any type against itself is not very effective. Also, assume that the relationships between different types are symmetric (if `A` is super effective against `B`, then `B` is not very effective against `A`).
The function you must implement takes in:
1. your type
2. the opponent's type
3. your attack power
4. the opponent's defense
Also feel free to reuse/extend the following starter code:
```python
def calculate_damage(your_type, opponent_type, attack, defense):
```
|
{"functional": "_inputs = [['fire', 'water', 100, 100], ['grass', 'water', 100, 100], ['electric', 'fire', 100, 100], ['grass', 'electric', 57, 19], ['grass', 'water', 40, 40], ['grass', 'fire', 35, 5], ['fire', 'electric', 10, 2]]\n_outputs = [[25], [100], [50], [150], [100], [175], [250]]\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(calculate_damage(*i), o[0])"}
| 334
| 284
|
coding
|
Solve the programming task below in a Python markdown code block.
## Description
Given an array X of positive integers, its elements are to be transformed by running the following operation on them as many times as required:
```if X[i] > X[j] then X[i] = X[i] - X[j]```
When no more transformations are possible, return its sum ("smallest possible sum").
For instance, the successive transformation of the elements of input X = [6, 9, 21] is detailed below:
```
X_1 = [6, 9, 12] # -> X_1[2] = X[2] - X[1] = 21 - 9
X_2 = [6, 9, 6] # -> X_2[2] = X_1[2] - X_1[0] = 12 - 6
X_3 = [6, 3, 6] # -> X_3[1] = X_2[1] - X_2[0] = 9 - 6
X_4 = [6, 3, 3] # -> X_4[2] = X_3[2] - X_3[1] = 6 - 3
X_5 = [3, 3, 3] # -> X_5[1] = X_4[0] - X_4[1] = 6 - 3
```
The returning output is the sum of the final transformation (here 9).
## Example
## Solution steps:
## Additional notes:
There are performance tests consisted of very big numbers and arrays of size at least 30000. Please write an efficient algorithm to prevent timeout.
Also feel free to reuse/extend the following starter code:
```python
def solution(a):
```
|
{"functional": "_inputs = [[[6, 9, 21]], [[9]], [[30, 12]], [[11, 22]], [[1, 21, 55]], [[4, 16, 24]], [[3, 13, 23, 7, 83]], [[60, 12, 96, 48, 60, 24, 72, 36, 72, 72, 48]], [[71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71]]]\n_outputs = [[9], [9], [12], [22], [3], [12], [5], [132], [923]]\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])"}
| 403
| 346
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer n, return the decimal value of the binary string formed by concatenating the binary representations of 1 to n in order, modulo 109 + 7.
Please complete the following python code precisely:
```python
class Solution:
def concatenatedBinary(self, n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 1) == 1\n assert candidate(n = 3) == 27\n assert candidate(n = 12) == 505379714\n\n\ncheck(Solution().concatenatedBinary)"}
| 84
| 67
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a rooted tree of $2^n - 1$ vertices. Every vertex of this tree has either $0$ children, or $2$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.
The vertices of the tree are numbered in the following order:
the root has index $1$;
if a vertex has index $x$, then its left child has index $2x$, and its right child has index $2x+1$.
Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $x$ as $s_x$.
Let the preorder string of some vertex $x$ be defined in the following way:
if the vertex $x$ is a leaf, then the preorder string of $x$ be consisting of only one character $s_x$;
otherwise, the preorder string of $x$ is $s_x + f(l_x) + f(r_x)$, where $+$ operator defines concatenation of strings, $f(l_x)$ is the preorder string of the left child of $x$, and $f(r_x)$ is the preorder string of the right child of $x$.
The preorder string of the tree is the preorder string of its root.
Now, for the problem itself...
You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree:
choose any non-leaf vertex $x$, and swap its children (so, the left child becomes the right one, and vice versa).
-----Input-----
The first line contains one integer $n$ ($2 \le n \le 18$).
The second line contains a sequence of $2^n-1$ characters $s_1, s_2, \dots, s_{2^n-1}$. Each character is either A or B. The characters are not separated by spaces or anything else.
-----Output-----
Print one integer — the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $998244353$.
-----Examples-----
Input
4
BAAAAAAAABBABAB
Output
16
Input
2
BAA
Output
1
Input
2
ABA
Output
2
Input
2
AAB
Output
2
Input
2
AAA
Output
1
-----Note-----
None
|
{"inputs": ["2\nBAA\n", "2\nABA\n", "2\nAAB\n", "2\nAAA\n", "2\nBBB\n", "2\nBBB\n", "2\nAAB\n", "2\nBBB\n"], "outputs": ["1\n", "2\n", "2\n", "1\n", "1\n", "1\n", "2\n", "1\n"]}
| 593
| 92
|
coding
|
Solve the programming task below in a Python markdown code block.
You get an array of numbers, return the sum of all of the positives ones.
Example `[1,-4,7,12]` => `1 + 7 + 12 = 20`
Note: if there is nothing to sum, the sum is default to `0`.
Also feel free to reuse/extend the following starter code:
```python
def positive_sum(arr):
```
|
{"functional": "_inputs = [[[1, 2, 3, 4, 5]], [[1, -2, 3, 4, 5]], [[-1, 2, 3, 4, -5]], [[]], [[-1, -2, -3, -4, -5]]]\n_outputs = [[15], [13], [9], [0], [0]]\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(positive_sum(*i), o[0])"}
| 95
| 230
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.