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.
Similar to the [previous kata](https://www.codewars.com/kata/string-subpattern-recognition-ii/), but this time you need to operate with shuffled strings to identify if they are composed repeating a subpattern
Since there is no deterministic way to tell which pattern was really the original one among all the possible permutations of a fitting subpattern, return a subpattern with sorted characters, otherwise return the base string with sorted characters (you might consider this case as an edge case, with the subpattern being repeated only once and thus equalling the original input string).
For example:
```python
has_subpattern("a") == "a"; #no repeated pattern, just one character
has_subpattern("aaaa") == "a" #just one character repeated
has_subpattern("abcd") == "abcd" #base pattern equals the string itself, no repetitions
has_subpattern("babababababababa") == "ab" #remember to return the base string sorted"
has_subpattern("bbabbaaabbaaaabb") == "ab" #same as above, just shuffled
```
If you liked it, go for either the [previous kata](https://www.codewars.com/kata/string-subpattern-recognition-ii/) or the [next kata](https://www.codewars.com/kata/string-subpattern-recognition-iv/) of the series!
Also feel free to reuse/extend the following starter code:
```python
def has_subpattern(string):
```
|
{"functional": "_inputs = [['a'], ['aaaa'], ['abcd'], ['babababababababa'], ['bbabbaaabbaaaabb'], ['123a123a123a'], ['123A123a123a'], ['12aa13a21233'], ['12aa13a21233A'], ['abcdabcaccd']]\n_outputs = [['a'], ['a'], ['abcd'], ['ab'], ['ab'], ['123a'], ['111222333Aaa'], ['123a'], ['111222333Aaaa'], ['aaabbccccdd']]\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(has_subpattern(*i), o[0])"}
| 321
| 296
|
coding
|
Solve the programming task below in a Python markdown code block.
Mash 2 arrays together so that the returning array has alternating elements of the 2 arrays . Both arrays will always be the same length.
eg. [1,2,3] + ['a','b','c'] = [1, 'a', 2, 'b', 3, 'c']
Also feel free to reuse/extend the following starter code:
```python
def array_mash(a, b):
```
|
{"functional": "_inputs = [[[1, 2, 3], ['a', 'b', 'c']], [[1, 2, 3, 4, 5], ['a', 'b', 'c', 'd', 'e']], [[1, 1, 1, 1], [2, 2, 2, 2]], [[1, 8, 'hello', 'dog'], ['fish', '2', 9, 10]], [[None, 4], [None, 'hello']], [[1], [2]], [['h', 'l', 'o', 'o', 'l'], ['e', 'l', 'w', 'r', 'd']]]\n_outputs = [[[1, 'a', 2, 'b', 3, 'c']], [[1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e']], [[1, 2, 1, 2, 1, 2, 1, 2]], [[1, 'fish', 8, '2', 'hello', 9, 'dog', 10]], [[None, None, 4, 'hello']], [[1, 2]], [['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']]]\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(array_mash(*i), o[0])"}
| 103
| 440
|
coding
|
Solve the programming task below in a Python markdown code block.
Some time ago, Chef bought X stocks at the cost of Rs. Y each. Today, Chef is going to sell all these X stocks at Rs. Z each. What is Chef's total profit after he sells them?
Chef's profit equals the total amount he received by selling the stocks, minus the total amount he spent buying them.
------ Input Format ------
- The first line of input contains an 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 X, Y and Z — the number of stocks, the price they were bought at, and the price they can be sold at, respectively.
------ Output Format ------
For each test case print on a new line a single integer — Chef's profit after selling all the stocks he has.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ X, Y ≤ 10^{4}$
$Y ≤ Z ≤ 10^{4}$
----- Sample Input 1 ------
3
2 5 20
3 1 2
4 5 6
----- Sample Output 1 ------
30
3
4
----- explanation 1 ------
Test Case 1: Chef bought $X = 2$ stocks for $Y = 5$ each, making the total amount spent by Chef $ = 2 \cdot 5 = 10$.
Chef can sell this stock today for $Z = 20$, making the total amount received by Chef $ = 2 \cdot 20 = 40$.
The total profit is then the amount received minus the amount spent, which equals $40 - 10 = 30$.
Test Case 2: Chef bought $X = 3$ stocks for $Y = 1$ each, making the total amount spent by Chef $ = 3 \cdot 1 = 3$.
Chef can sell this stock today for $Z = 2$, making the total amount received by Chef $ = 3 \cdot 2 = 6$.
The total profit is then the amount received minus the amount spent, which equals $6 - 3 = 3$.
Test Case 3: Chef bought $X = 4$ stocks for $Y = 5$ each, making the total amount spent by Chef $ = 4 \cdot 5 = 20$.
Chef can sell this stock today for $Z = 6$, making the total amount received by Chef $ = 4 \cdot 6 = 24$.
The total profit is then the amount received minus the amount spent, which equals $24 - 20 = 4$
|
{"inputs": ["3\n2 5 20\n3 1 2\n4 5 6"], "outputs": ["30\n3\n4\n"]}
| 590
| 37
|
coding
|
Solve the programming task below in a Python markdown code block.
My washing machine uses ```water``` amount of water to wash ```clothes``` amount of clothes. You are given a ```load``` amount of clothes to wash. For each single item of load above the standard amount of clothes, the washing machine will use 10% more water (multiplicative) to clean.
For example, if the amount of clothes is ```10```, the amount of water it requires is ```5``` and the load is ```14```, then you need ```5 * 1.1 ^ (14 - 10)``` amount of water.
Write a function ```howMuchWater``` (JS)/```how_much_water``` (Python) to work out how much water is needed if you have a ```clothes``` amount of clothes. The function will accept 3 parameters - ```howMuchWater(water, load, clothes)``` / ```how_much_water(water, load, clothes)```
My washing machine is an old model that can only handle double the amount of ```load```. If the amount of ```clothes``` is more than 2 times the standard amount of ```load```, return ```'Too much clothes'```. The washing machine also cannot handle any amount of clothes less than ```load```. If that is the case, return ```'Not enough clothes'```.
The answer should be rounded to the nearest 2 decimal places.
Also feel free to reuse/extend the following starter code:
```python
def how_much_water(water, load, clothes):
```
|
{"functional": "_inputs = [[10, 10, 21], [10, 10, 2], [10, 11, 20], [50, 15, 29], [50, 15, 15]]\n_outputs = [['Too much clothes'], ['Not enough clothes'], [23.58], [189.87], [50]]\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_much_water(*i), o[0])"}
| 337
| 239
|
coding
|
Solve the programming task below in a Python markdown code block.
You are playing a game called Guru Guru Gururin. In this game, you can move with the vehicle called Gururin. There are two commands you can give to Gururin: 'R' and 'L'. When 'R' is sent, Gururin rotates clockwise by 90 degrees. Otherwise, when 'L' is sent, Gururin rotates counterclockwise by 90 degrees.
During the game, you noticed that Gururin obtains magical power by performing special commands. In short, Gururin obtains magical power every time when it performs one round in the clockwise direction from north to north. In more detail, the conditions under which magical power can be obtained is as follows.
* At the beginning of the special commands, Gururin faces north.
* At the end of special commands, Gururin faces north.
* Except for the beginning and the end of special commands, Gururin does not face north.
* During the special commands, Gururin faces north, east, south, and west one or more times, respectively, after the command of 'R'.
At the beginning of the game, Gururin faces north. For example, if the sequence of commands Gururin received in order is 'RRRR' or 'RRLRRLRR', Gururin can obtain magical power. Otherwise, if the sequence of commands is 'LLLL' or 'RLLR', Gururin cannot obtain magical power.
Your task is to calculate how many times Gururin obtained magical power throughout the game. In other words, given the sequence of the commands Gururin received, calculate how many special commands exists in it.
Input
The input consists of a single test case in the format below.
$S$
The first line consists of a string $S$, which represents the sequence of commands Gururin received. $S$ consists of 'L' and 'R'. The length of $S$ is between $1$ and $10^3$ inclusive.
Output
Print the number of times Gururin obtained magical power throughout the game in one line.
Examples
Input
RRRRLLLLRRRR
Output
2
Input
RLLRLLLLRRRLLLRRR
Output
0
Input
LR
Output
0
Input
RRLRRLRRRRLRRLRRRRLRRLRRRRLRRLRR
Output
4
|
{"inputs": ["RL", "QL", "LQ", "KR", "KQ", "QK", "RK", "SK"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 513
| 65
|
coding
|
Solve the programming task below in a Python markdown code block.
Let's define $S(x)$ to be the sum of digits of number $x$ written in decimal system. For example, $S(5) = 5$, $S(10) = 1$, $S(322) = 7$.
We will call an integer $x$ interesting if $S(x + 1) < S(x)$. In each test you will be given one integer $n$. Your task is to calculate the number of integers $x$ such that $1 \le x \le n$ and $x$ is interesting.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) — number of test cases.
Then $t$ lines follow, the $i$-th line contains one integer $n$ ($1 \le n \le 10^9$) for the $i$-th test case.
-----Output-----
Print $t$ integers, the $i$-th should be the answer for the $i$-th test case.
-----Examples-----
Input
5
1
9
10
34
880055535
Output
0
1
1
3
88005553
-----Note-----
The first interesting number is equal to $9$.
|
{"inputs": ["5\n1\n4\n4\n3\n75116\n", "5\n1\n4\n4\n3\n52440\n", "5\n1\n4\n4\n0\n80298\n", "5\n1\n4\n3\n1\n86587\n", "5\n1\n5\n3\n0\n34153\n", "5\n1\n5\n3\n0\n13341\n", "5\n2\n4\n5\n1\n55511991\n", "5\n2\n4\n5\n0\n56517944\n"], "outputs": ["0\n0\n0\n0\n7511\n", "0\n0\n0\n0\n5244\n", "0\n0\n0\n0\n8029\n", "0\n0\n0\n0\n8658\n", "0\n0\n0\n0\n3415\n", "0\n0\n0\n0\n1334\n", "0\n0\n0\n0\n5551199\n", "0\n0\n0\n0\n5651794\n"]}
| 299
| 282
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given a matrix and a target, return the number of non-empty submatrices that sum to target.
A submatrix x1, y1, x2, y2 is the set of all cells matrix[x][y] with x1 <= x <= x2 and y1 <= y <= y2.
Two submatrices (x1, y1, x2, y2) and (x1', y1', x2', y2') are different if they have some coordinate that is different: for example, if x1 != x1'.
Please complete the following python code precisely:
```python
class Solution:
def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0) == 4\n assert candidate(matrix = [[1,-1],[-1,1]], target = 0) == 5\n assert candidate(matrix = [[904]], target = 0) == 0\n\n\ncheck(Solution().numSubmatrixSumTarget)"}
| 173
| 97
|
coding
|
Solve the programming task below in a Python markdown code block.
You have a long stick, consisting of $m$ segments enumerated from $1$ to $m$. Each segment is $1$ centimeter long. Sadly, some segments are broken and need to be repaired.
You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length $t$ placed at some position $s$ will cover segments $s, s+1, \ldots, s+t-1$.
You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.
Time is money, so you want to cut at most $k$ continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?
-----Input-----
The first line contains three integers $n$, $m$ and $k$ ($1 \le n \le 10^5$, $n \le m \le 10^9$, $1 \le k \le n$) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.
The second line contains $n$ integers $b_1, b_2, \ldots, b_n$ ($1 \le b_i \le m$) — the positions of the broken segments. These integers are given in increasing order, that is, $b_1 < b_2 < \ldots < b_n$.
-----Output-----
Print the minimum total length of the pieces.
-----Examples-----
Input
4 100 2
20 30 75 80
Output
17
Input
5 100 3
1 2 4 60 87
Output
6
-----Note-----
In the first example, you can use a piece of length $11$ to cover the broken segments $20$ and $30$, and another piece of length $6$ to cover $75$ and $80$, for a total length of $17$.
In the second example, you can use a piece of length $4$ to cover broken segments $1$, $2$ and $4$, and two pieces of length $1$ to cover broken segments $60$ and $87$.
|
{"inputs": ["1 1 1\n1\n", "1 1 1\n1\n", "3 8 1\n2 6 7\n", "3 8 2\n4 6 8\n", "3 8 3\n1 2 6\n", "3 8 3\n1 2 6\n", "3 8 2\n4 6 8\n", "3 8 1\n2 6 7\n"], "outputs": ["1\n", "1", "6\n", "4\n", "3\n", "3", "4", "6"]}
| 512
| 138
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer array nums and an integer target.
You want to build an expression out of nums by adding one of the symbols '+' and '-' before each integer in nums and then concatenate all the integers.
For example, if nums = [2, 1], you can add a '+' before 2 and a '-' before 1 and concatenate them to build the expression "+2-1".
Return the number of different expressions that you can build, which evaluates to target.
Please complete the following python code precisely:
```python
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,1,1,1,1], target = 3) == 5\n assert candidate(nums = [1], target = 1) == 1\n\n\ncheck(Solution().findTargetSumWays)"}
| 151
| 64
|
coding
|
Solve the programming task below in a Python markdown code block.
There are N balls in the xy-plane. The coordinates of the i-th of them is (x_i, i).
Thus, we have one ball on each of the N lines y = 1, y = 2, ..., y = N.
In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B.
Then, he placed the i-th type-A robot at coordinates (0, i), and the i-th type-B robot at coordinates (K, i).
Thus, now we have one type-A robot and one type-B robot on each of the N lines y = 1, y = 2, ..., y = N.
When activated, each type of robot will operate as follows.
- When a type-A robot is activated at coordinates (0, a), it will move to the position of the ball on the line y = a, collect the ball, move back to its original position (0, a) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
- When a type-B robot is activated at coordinates (K, b), it will move to the position of the ball on the line y = b, collect the ball, move back to its original position (K, b) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
Snuke will activate some of the 2N robots to collect all of the balls. Find the minimum possible total distance covered by robots.
-----Constraints-----
- 1 \leq N \leq 100
- 1 \leq K \leq 100
- 0 < x_i < K
- All input values are integers.
-----Inputs-----
Input is given from Standard Input in the following format:
N
K
x_1 x_2 ... x_N
-----Outputs-----
Print the minimum possible total distance covered by robots.
-----Sample Input-----
1
10
2
-----Sample Output-----
4
There are just one ball, one type-A robot and one type-B robot.
If the type-A robot is used to collect the ball, the distance from the robot to the ball is 2, and the distance from the ball to the original position of the robot is also 2, for a total distance of 4.
Similarly, if the type-B robot is used, the total distance covered will be 16.
Thus, the total distance covered will be minimized when the type-A robot is used. The output should be 4.
|
{"inputs": ["1\n18\n2", "1\n23\n1", "1\n23\n0", "1\n10\n3", "1\n15\n8", "1\n17\n9", "1\n0\n-8", "1\n0\n-7"], "outputs": ["4\n", "2\n", "0\n", "6\n", "14\n", "16\n", "-16\n", "-14\n"]}
| 546
| 106
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a function that takes a single array as an argument (containing multiple strings and/or positive numbers and/or arrays), and returns one of four possible string values, depending on the ordering of the lengths of the elements in the input array:
Your function should return...
- “Increasing” - if the lengths of the elements increase from left to right (although it is possible that some neighbouring elements may also be equal in length)
- “Decreasing” - if the lengths of the elements decrease from left to right (although it is possible that some neighbouring elements may also be equal in length)
- “Unsorted” - if the lengths of the elements fluctuate from left to right
- “Constant” - if all element's lengths are the same.
Numbers and Strings should be evaluated based on the number of characters or digits used to write them.
Arrays should be evaluated based on the number of elements counted directly in the parent array (but not the number of elements contained in any sub-arrays).
Happy coding! :)
Also feel free to reuse/extend the following starter code:
```python
def order_type(arr):
```
|
{"functional": "_inputs = [[[1, 'b', ['p'], 2]], [[123, 1234, 12345, 123456]], [['a', 'abc', 'abcde', 'ab']], [[[1, 2, 3, 4], [5, 6, 7], [8, 9]]], [[1, 2, 3, 4, 56]], [[['ab', 'cdef', 'g'], ['hi', 'jk', 'lmnopq'], ['rst', 'uv', 'wx'], ['yz']]], [[[1, 23, 456, 78910], ['abcdef', 'ghijklmno', 'pqrstuvwxy'], [[1, 23, 456, 78910, ['abcdef', 'ghijklmno', 'pqrstuvwxy']], 1234]]], [[]], [['pippi', 'pippi', 'batuffulo', 'pippi']], [['pippi']]]\n_outputs = [['Constant'], ['Increasing'], ['Unsorted'], ['Decreasing'], ['Increasing'], ['Decreasing'], ['Decreasing'], ['Constant'], ['Unsorted'], ['Constant']]\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(order_type(*i), o[0])"}
| 238
| 412
|
coding
|
Solve the programming task below in a Python markdown code block.
There is a street with $n$ houses in a line, numbered from $1$ to $n$. The house $i$ is initially painted in color $c_i$. The street is considered beautiful if all houses are painted in the same color. Tom, the painter, is in charge of making the street beautiful. Tom's painting capacity is defined by an integer, let's call it $k$.
On one day, Tom can do the following repainting process that consists of two steps:
He chooses two integers $l$ and $r$ such that $ 1 \le l \le r \le n $ and $ r - l + 1 = k $.
For each house $i$ such that $l \le i \le r$, he can either repaint it with any color he wants, or ignore it and let it keep its current color.
Note that in the same day Tom can use different colors to repaint different houses.
Tom wants to know the minimum number of days needed to repaint the street so that it becomes beautiful.
-----Input-----
The first line of input contains a single integer $t$ ($ 1 \le t \le 10^4$), the number of test cases. Description of test cases follows.
In the first line of a test case description there are two integers $n$ and $k$ ($1 \le k \le n \le 10^5$).
The second line contains $n$ space-separated integers. The $i$-th of these integers represents $c_i$ ($1 \le c_i \le 100$), the color which house $i$ is initially painted in.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
Print $t$ lines, each with one integer: the minimum number of days Tom needs to make the street beautiful for each test case.
-----Examples-----
Input
3
10 2
1 1 2 2 1 1 2 2 2 1
7 1
1 2 3 4 5 6 7
10 3
1 3 3 3 3 1 2 1 3 3
Output
3
6
2
-----Note-----
In the first test case Tom should paint houses 1 and 2 in the first day in color 2, houses 5 and 6 in the second day in color 2, and the last house in color 2 on the third day.
In the second test case Tom can, for example, spend 6 days to paint houses 1, 2, 4, 5, 6, 7 in color 3.
In the third test case Tom can paint the first house in the first day and houses 6, 7, and 8 in the second day in color 3.
|
{"inputs": ["3\n10 2\n1 1 2 2 1 1 2 2 2 1\n7 1\n1 2 3 4 5 6 7\n10 3\n1 3 3 3 3 1 2 1 3 3\n", "6\n6 4\n2 1 1 1 1 2\n10 5\n1 1 1 2 2 1 2 2 1 1\n9 6\n1 2 3 1 2 3 1 2 3\n1 1\n100\n10 10\n1 100 2 99 3 98 4 97 5 96\n8 1\n50 50 50 50 50 50 50 50\n"], "outputs": ["3\n6\n2\n", "1\n1\n2\n0\n1\n0\n"]}
| 624
| 235
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
There is a secret sequence $A_{1}, A_{2}, \ldots, A_{N}$. We do not know the elements of this sequence, but we know another sequence $B_{1}, B_{2}, \ldots, B_{N-1}$ such that $B_{i} = A_{i} + A_{i+1}$ for each valid $i$.
You should process $Q$ queries. In each query, you are given two indices $p$ and $q$; your task is to compute $A_{p} + A_{q}$ or determine that there is not enough information to uniquely determine this sum.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains two space-separated integers $N$ and $Q$.
The second line contains $N-1$ space-separated integers $B_{1}, B_{2}, \ldots, B_{N-1}$.
Each of the following $Q$ lines contains two space-separated integers $p$ and $q$ describing a query.
------ Output ------
For each query, if it is impossible to determine the required sum, print a single line containing the string "UNKNOWN". Otherwise, print a single line containing one integer — the required sum.
------ Constraints ------
$1 ≤ T ≤ 100$
$2 ≤ N ≤ 10^{5}$
$1 ≤ Q ≤ 10^{5}$
$1 ≤ p, q ≤ N$
$1 ≤ B_{i} ≤ 10^{9}$ for each valid $i$
the sum of $N$ over all test cases does not exceed $5 \cdot 10^{5}$
the sum of $Q$ over all test cases does not exceed $5 \cdot 10^{5}$
------ Subtasks ------
Subtask #1 (50 points):
$2 ≤ N ≤ 1,000$
$1 ≤ Q ≤ 1,000$
the sum of $N$ over all test cases does not exceed $5,000$
the sum of $Q$ over all test cases does not exceed $5,000$
Subtask #2 (50 points): original constraints
----- Sample Input 1 ------
1
5 3
4 5 6 7
1 2
1 3
4 1
----- Sample Output 1 ------
4
UNKNOWN
5
|
{"inputs": ["1\n5 3\n4 5 6 7\n1 2\n1 3\n4 1"], "outputs": ["4\nUNKNOWN\n5"]}
| 587
| 40
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There is a new alien language that uses the English alphabet. However, the order of the letters is unknown to you.
You are given a list of strings words from the alien language's dictionary. Now it is claimed that the strings in words are sorted lexicographically by the rules of this new language.
If this claim is incorrect, and the given arrangement of string in words cannot correspond to any order of letters, return "".
Otherwise, return a string of the unique letters in the new alien language sorted in lexicographically increasing order by the new language's rules. If there are multiple solutions, return any of them.
Please complete the following python code precisely:
```python
class Solution:
def alienOrder(self, words: List[str]) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(words = [\"wrt\",\"wrf\",\"er\",\"ett\",\"rftt\"]) == \"wertf\"\n assert candidate(words = [\"z\",\"x\"]) == \"zx\"\n assert candidate(words = [\"z\",\"x\",\"z\"]) == \"\"\n\n\ncheck(Solution().alienOrder)"}
| 177
| 82
|
coding
|
Solve the programming task below in a Python markdown code block.
An army of n droids is lined up in one row. Each droid is described by m integers a_1, a_2, ..., a_{m}, where a_{i} is the number of details of the i-th type in this droid's mechanism. R2-D2 wants to destroy the sequence of consecutive droids of maximum length. He has m weapons, the i-th weapon can affect all the droids in the army by destroying one detail of the i-th type (if the droid doesn't have details of this type, nothing happens to it).
A droid is considered to be destroyed when all of its details are destroyed. R2-D2 can make at most k shots. How many shots from the weapon of what type should R2-D2 make to destroy the sequence of consecutive droids of maximum length?
-----Input-----
The first line contains three integers n, m, k (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 5, 0 ≤ k ≤ 10^9) — the number of droids, the number of detail types and the number of available shots, respectively.
Next n lines follow describing the droids. Each line contains m integers a_1, a_2, ..., a_{m} (0 ≤ a_{i} ≤ 10^8), where a_{i} is the number of details of the i-th type for the respective robot.
-----Output-----
Print m space-separated integers, where the i-th number is the number of shots from the weapon of the i-th type that the robot should make to destroy the subsequence of consecutive droids of the maximum length.
If there are multiple optimal solutions, print any of them.
It is not necessary to make exactly k shots, the number of shots can be less.
-----Examples-----
Input
5 2 4
4 0
1 2
2 1
0 2
1 3
Output
2 2
Input
3 2 4
1 2
1 3
2 2
Output
1 3
-----Note-----
In the first test the second, third and fourth droids will be destroyed.
In the second test the first and second droids will be destroyed.
|
{"inputs": ["1 1 0\n0\n", "1 1 0\n1\n", "1 1 1\n0\n", "1 1 0\n0\n", "1 1 1\n0\n", "1 1 0\n1\n", "1 1 1\n1\n", "1 1 0\n2\n"], "outputs": ["0\n", "0\n", "0\n", "0 \n", "0 \n", "0 \n", "1 ", "0 "]}
| 486
| 120
|
coding
|
Solve the programming task below in a Python markdown code block.
Hooray! Polycarp turned $n$ years old! The Technocup Team sincerely congratulates Polycarp!
Polycarp celebrated all of his $n$ birthdays: from the $1$-th to the $n$-th. At the moment, he is wondering: how many times he turned beautiful number of years?
According to Polycarp, a positive integer is beautiful if it consists of only one digit repeated one or more times. For example, the following numbers are beautiful: $1$, $77$, $777$, $44$ and $999999$. The following numbers are not beautiful: $12$, $11110$, $6969$ and $987654321$.
Of course, Polycarpus uses the decimal numeral system (i.e. radix is 10).
Help Polycarpus to find the number of numbers from $1$ to $n$ (inclusive) that are beautiful.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input. Then $t$ test cases follow.
Each test case consists of one line, which contains a positive integer $n$ ($1 \le n \le 10^9$) — how many years Polycarp has turned.
-----Output-----
Print $t$ integers — the answers to the given test cases in the order they are written in the test. Each answer is an integer: the number of beautiful years between $1$ and $n$, inclusive.
-----Example-----
Input
6
18
1
9
100500
33
1000000000
Output
10
1
9
45
12
81
-----Note-----
In the first test case of the example beautiful years are $1$, $2$, $3$, $4$, $5$, $6$, $7$, $8$, $9$ and $11$.
|
{"inputs": ["6\n18\n1\n9\n100500\n33\n1000000000\n"], "outputs": ["10\n1\n9\n45\n12\n81\n"]}
| 456
| 56
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a 0-indexed circular string array words and a string target. A circular array means that the array's end connects to the array's beginning.
Formally, the next element of words[i] is words[(i + 1) % n] and the previous element of words[i] is words[(i - 1 + n) % n], where n is the length of words.
Starting from startIndex, you can move to either the next word or the previous word with 1 step at a time.
Return the shortest distance needed to reach the string target. If the string target does not exist in words, return -1.
Please complete the following python code precisely:
```python
class Solution:
def closetTarget(self, words: List[str], target: str, startIndex: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(words = [\"hello\",\"i\",\"am\",\"leetcode\",\"hello\"], target = \"hello\", startIndex = 1) == 1\n assert candidate(words = [\"a\",\"b\",\"leetcode\"], target = \"leetcode\", startIndex = 0) == 1\n assert candidate(words = [\"i\",\"eat\",\"leetcode\"], target = \"ate\", startIndex = 0) == -1\n\n\ncheck(Solution().closetTarget)"}
| 188
| 108
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given two strings s and t, find the number of ways you can choose a non-empty substring of s and replace a single character by a different character such that the resulting substring is a substring of t. In other words, find the number of substrings in s that differ from some substring in t by exactly one character.
For example, the underlined substrings in "computer" and "computation" only differ by the 'e'/'a', so this is a valid way.
Return the number of substrings that satisfy the condition above.
A substring is a contiguous sequence of characters within a string.
Please complete the following python code precisely:
```python
class Solution:
def countSubstrings(self, s: str, t: str) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"aba\", t = \"baba\") == 6\n assert candidate(s = \"ab\", t = \"bb\") == 3\n assert candidate(s = \"a\", t = \"a\") == 0\n assert candidate(s = \"abe\", t = \"bbc\") == 10\n\n\ncheck(Solution().countSubstrings)"}
| 175
| 90
|
coding
|
Solve the programming task below in a Python markdown code block.
Giant chess is quite common in Geraldion. We will not delve into the rules of the game, we'll just say that the game takes place on an h × w field, and it is painted in two colors, but not like in chess. Almost all cells of the field are white and only some of them are black. Currently Gerald is finishing a game of giant chess against his friend Pollard. Gerald has almost won, and the only thing he needs to win is to bring the pawn from the upper left corner of the board, where it is now standing, to the lower right corner. Gerald is so confident of victory that he became interested, in how many ways can he win?
The pawn, which Gerald has got left can go in two ways: one cell down or one cell to the right. In addition, it can not go to the black cells, otherwise the Gerald still loses. There are no other pawns or pieces left on the field, so that, according to the rules of giant chess Gerald moves his pawn until the game is over, and Pollard is just watching this process.
-----Input-----
The first line of the input contains three integers: h, w, n — the sides of the board and the number of black cells (1 ≤ h, w ≤ 10^5, 1 ≤ n ≤ 2000).
Next n lines contain the description of black cells. The i-th of these lines contains numbers r_{i}, c_{i} (1 ≤ r_{i} ≤ h, 1 ≤ c_{i} ≤ w) — the number of the row and column of the i-th cell.
It is guaranteed that the upper left and lower right cell are white and all cells in the description are distinct.
-----Output-----
Print a single line — the remainder of the number of ways to move Gerald's pawn from the upper left to the lower right corner modulo 10^9 + 7.
-----Examples-----
Input
3 4 2
2 2
2 3
Output
2
Input
100 100 3
15 16
16 15
99 88
Output
545732279
|
{"inputs": ["3 4 2\n2 2\n2 3\n", "2 2 2\n2 1\n1 2\n", "2 2 2\n2 1\n1 2\n", "3 4 2\n2 2\n1 3\n", "3 4 2\n2 2\n2 3\n", "100000 100000 2\n1 2\n2 1\n", "100000 100000 2\n1 2\n2 1\n", "100000 100000 2\n2 2\n2 1\n"], "outputs": ["2\n", "0\n", "0\n", "1\n", "2\n", "0\n", "0\n", "307833736\n"]}
| 477
| 204
|
coding
|
Solve the programming task below in a Python markdown code block.
The famous store "Second Food" sells groceries only two days a month. And the prices in each of days differ. You wanted to buy $n$ kilos of potatoes for a month. You know that on the first day of the month $1$ kilo of potatoes costs $a$ coins, and on the second day $b$ coins. In "Second Food" you can buy any integer kilograms of potatoes.
Fortunately, "Second Food" has announced a promotion for potatoes, which is valid only on the first day of the month — for each $m$ kilos of potatoes you buy, you get $1$ kilo as a gift! In other words, you can get $m + 1$ kilograms by paying for $m$ kilograms.
Find the minimum number of coins that you have to spend to buy at least $n$ kilos of potatoes.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10000$). Description of the test cases follows.
The first line of each test case contains two integers $a$ and $b$ $(1 \leq a, b \leq 10^9)$ — the prices of $1$ kilo of potatoes on the first and second days, respectively.
The second line contains two integers $n$ and $m$ $(1 \leq n, m \leq 10^9)$ — the required amount of potatoes to buy and the amount of potatoes to use the promotion.
-----Output-----
For each test case print one integer — the minimum number of coins that you have to pay to buy at least $n$ kilos of potatoes.
-----Examples-----
Input
5
5 4
3 1
5 4
3 2
3 4
3 5
20 15
10 2
1000000000 900000000
1000000000 8
Output
9
10
9
135
888888888900000000
-----Note-----
In the first test case, on the first day you buy $1$ kilo and get $1$ more for a promotion. On the second day, you can buy $1$ kilo of potatoes. Thus, you will spend $5+4=9$ coins in total.
In the second test case, on the first day you buy $2$ kilo and get another $1$ more for a promotion. This way you will spend $2 \cdot 5 = 10$ coins.
|
{"inputs": ["5\n5 4\n3 1\n5 4\n3 2\n3 4\n3 5\n20 15\n10 2\n1000000000 900000000\n1000000000 8\n"], "outputs": ["9\n10\n9\n135\n888888888900000000\n"]}
| 587
| 111
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an array nums of integers and integer k, return the maximum sum such that there exists i < j with nums[i] + nums[j] = sum and sum < k. If no i, j exist satisfying this equation, return -1.
Please complete the following python code precisely:
```python
class Solution:
def twoSumLessThanK(self, nums: List[int], k: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [34,23,1,24,75,33,54,8], k = 60) == 58\n assert candidate(nums = [10,20,30], k = 15) == -1\n\n\ncheck(Solution().twoSumLessThanK)"}
| 106
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef wants to become fit for which he decided to walk to the office and return home by walking. It is known that Chef's office is X km away from his home.
If his office is open on 5 days in a week, find the number of kilometers Chef travels through office trips in a week.
------ Input Format ------
- First line will contain T, number of test cases. Then the test cases follow.
- Each test case contains of a single line consisting of single integer X.
------ Output Format ------
For each test case, output the number of kilometers Chef travels through office trips in a week.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ X ≤ 10$
----- Sample Input 1 ------
4
1
3
7
10
----- Sample Output 1 ------
10
30
70
100
----- explanation 1 ------
Test case $1$: The office is $1$ km away. Thus, to go to the office and come back home, Chef has to walk $2$ kms in a day. In a week with $5$ working days, Chef has to travel $2\cdot 5 = 10$ kms in total.
Test case $2$: The office is $3$ kms away. Thus, to go to the office and come back home, Chef has to walk $6$ kms in a day. In a week with $5$ working days, Chef has to travel $6\cdot 5 = 30$ kms in total.
Test case $3$: The office is $7$ kms away. Thus, to go to the office and come back home, Chef has to walk $14$ kms in a day. In a week with $5$ working days, Chef has to travel $14\cdot 5 = 70$ kms in total.
Test case $4$: The office is $10$ kms away. Thus, to go to the office and come back home, Chef has to walk $20$ kms in a day. In a week with $5$ working days, Chef has to travel $20\cdot 5 = 100$ kms in total.
|
{"inputs": ["4\n1\n3\n7\n10\n"], "outputs": ["10\n30\n70\n100\n"]}
| 478
| 34
|
coding
|
Solve the programming task below in a Python markdown code block.
Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
One day Petya dreamt of a lexicographically k-th permutation of integers from 1 to n. Determine how many lucky numbers in the permutation are located on the positions whose indexes are also lucky numbers.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 109) — the number of elements in the permutation and the lexicographical number of the permutation.
Output
If the k-th permutation of numbers from 1 to n does not exist, print the single number "-1" (without the quotes). Otherwise, print the answer to the problem: the number of such indexes i, that i and ai are both lucky numbers.
Examples
Input
7 4
Output
1
Input
4 7
Output
1
Note
A permutation is an ordered set of n elements, where each integer from 1 to n occurs exactly once. The element of permutation in position with index i is denoted as ai (1 ≤ i ≤ n). Permutation a is lexicographically smaller that permutation b if there is such a i (1 ≤ i ≤ n), that ai < bi, and for any j (1 ≤ j < i) aj = bj. Let's make a list of all possible permutations of n elements and sort it in the order of lexicographical increasing. Then the lexicographically k-th permutation is the k-th element of this list of permutations.
In the first sample the permutation looks like that:
1 2 3 4 6 7 5
The only suitable position is 4.
In the second sample the permutation looks like that:
2 1 3 4
The only suitable position is 4.
|
{"inputs": ["3 7\n", "2 3\n", "1 2\n", "1 1\n", "7 1\n", "2 4\n", "2 1\n", "2 2\n"], "outputs": ["-1\n", "-1\n", "-1\n", "0\n", "2\n", "-1\n", "0\n", "0\n"]}
| 425
| 87
|
coding
|
Solve the programming task below in a Python markdown code block.
Sherlock considers a string to be valid if all characters of the string appear the same number of times. It is also valid if he can remove just $1$ character at $1$ index in the string, and the remaining characters will occur the same number of times. Given a string $s$, determine if it is valid. If so, return YES, otherwise return NO.
Example
$s=abc$
This is a valid string because frequencies are $\{a:1,b:1,c:1\}$.
$s=abcc$
This is a valid string because we can remove one $c$ and have $1$ of each character in the remaining string.
$s=abccc$
This string is not valid as we can only remove $1$ occurrence of $c$. That leaves character frequencies of $\{a:1,b:1,c:2\}$.
Function Description
Complete the isValid function in the editor below.
isValid has the following parameter(s):
string s: a string
Returns
string: either YES or NO
Input Format
A single string $s$.
Constraints
$1\leq|s|\leq10^5$
Each character $s[i]\in ascii[a-z]$
Sample Input 0
aabbcd
Sample Output 0
NO
Explanation 0
Given $s="aabbcd"$, we would need to remove two characters, both c and d $\rightarrow$ aabb or a and b $\rightarrow$ abcd, to make it valid. We are limited to removing only one character, so $s$ is invalid.
Sample Input 1
aabbccddeefghi
Sample Output 1
NO
Explanation 1
Frequency counts for the letters are as follows:
{'a': 2, 'b': 2, 'c': 2, 'd': 2, 'e': 2, 'f': 1, 'g': 1, 'h': 1, 'i': 1}
There are two ways to make the valid string:
Remove $4$ characters with a frequency of $1$: $\{\mbox{fghi}\}$.
Remove $5$ characters of frequency $2$: $\{\textsf{abcde}\}$.
Neither of these is an option.
Sample Input 2
abcdefghhgfedecba
Sample Output 2
YES
Explanation 2
All characters occur twice except for $e$ which occurs $3$ times. We can delete one instance of $e$ to have a valid string.
|
{"inputs": ["aabbcd\n", "aabbccddeefghi\n", "abcdefghhgfedecba\n"], "outputs": ["NO\n", "NO\n", "YES\n"]}
| 556
| 42
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a program which reads a list of student test scores and evaluates the performance for each student.
The test scores for a student include scores of the midterm examination m (out of 50), the final examination f (out of 50) and the makeup examination r (out of 100). If the student does not take the examination, the score is indicated by -1.
The final performance of a student is evaluated by the following procedure:
* If the student does not take the midterm or final examination, the student's grade shall be F.
* If the total score of the midterm and final examination is greater than or equal to 80, the student's grade shall be A.
* If the total score of the midterm and final examination is greater than or equal to 65 and less than 80, the student's grade shall be B.
* If the total score of the midterm and final examination is greater than or equal to 50 and less than 65, the student's grade shall be C.
* If the total score of the midterm and final examination is greater than or equal to 30 and less than 50, the student's grade shall be D. However, if the score of the makeup examination is greater than or equal to 50, the grade shall be C.
* If the total score of the midterm and final examination is less than 30, the student's grade shall be F.
Input
The input consists of multiple datasets. For each dataset, three integers m, f and r are given in a line.
The input ends with three -1 for m, f and r respectively. Your program should not process for the terminal symbols.
The number of datasets (the number of students) does not exceed 50.
Output
For each dataset, print the grade (A, B, C, D or F) in a line.
Example
Input
40 42 -1
20 30 -1
0 2 -1
-1 -1 -1
Output
A
C
F
|
{"inputs": ["34 10 1\n30 42 0\n1 1 1\n-1 -1 -1", "40 53 -1\n0 7 -1\n0 1 -1\n-1 -1 -1", "73 6 -1\n16 30 0\n1 2 -1\n-1 -1 -1", "92 64 0\n16 30 -1\n0 2 0\n-1 -1 -1", "40 53 -1\n0 7 -1\n0 1 -2\n-1 -1 -1", "92 64 0\n16 30 -1\n1 2 0\n-1 -1 -1", "40 53 -1\n0 58 -1\n0 1 0\n-1 -1 -1", "40 53 -2\n0 7 -1\n0 1 -1\n-1 -1 -1"], "outputs": ["D\nB\nF\n", "A\nF\nF\n", "B\nD\nF\n", "A\nD\nF\n", "A\nF\nF\n", "A\nD\nF\n", "A\nC\nF\n", "A\nF\nF\n"]}
| 444
| 302
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
Chef has a string $S$. He also has another string $P$, called *pattern*. He wants to find the pattern in $S$, but that might be impossible. Therefore, he is willing to reorder the characters of $S$ in such a way that $P$ occurs in the resulting string (an anagram of $S$) as a substring.
Since this problem was too hard for Chef, he decided to ask you, his genius friend, for help. Can you find the lexicographically smallest anagram of $S$ that contains $P$ as substring?
Note: A string $B$ is a substring of a string $A$ if $B$ can be obtained from $A$ by deleting several (possibly none or all) characters from the beginning and several (possibly none or all) characters from the end.
------ 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 string $S$.
The second line contains a single string $P$.
------ Output ------
For each test case, print a single line containing one string ― the smallest anagram of $S$ that contains $P$.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ |P| ≤ |S| ≤ 10^{5}$
$S$ and $P$ contain only lowercase English letters
there is at least one anagram of $S$ that contains $P$
------ Subtasks ------
Subtask #1 (20 points): $|S| ≤ 1,000$
Subtask #2 (80 points): $|S| ≤ 10^{5}$
----- Sample Input 1 ------
3
akramkeeanany
aka
supahotboy
bohoty
daehabshatorawy
badawy
----- Sample Output 1 ------
aaakaeekmnnry
abohotypsu
aabadawyehhorst
|
{"inputs": ["3\nakramkeeanany\naka\nsupahotboy\nbohoty\ndaehabshatorawy\nbadawy"], "outputs": ["aaakaeekmnnry\nabohotypsu\naabadawyehhorst"]}
| 479
| 57
|
coding
|
Solve the programming task below in a Python markdown code block.
Alice and Bob invented the following silly game:
The game starts with an integer, $n$, that's used to build a $\boldsymbol{set}$ of $n$ distinct integers in the inclusive range from $1$ to $n$ (i.e., $set=\{1,2,3,\ldots,n-1,n\}$).
Alice always plays first, and the two players move in alternating turns.
During each move, the current player chooses a prime number, $\boldsymbol{p}$, from $\boldsymbol{set}$. The player then removes $\boldsymbol{p}$ and all of its multiples from $\boldsymbol{set}$.
The first player to be unable to make a move loses the game.
Alice and Bob play $\mathrm{~g~}$ games. Given the value of $n$ for each game, print the name of the game's winner on a new line. If Alice wins, print Alice; otherwise, print Bob.
Note: Each player always plays optimally, meaning they will not make a move that causes them to lose the game if some better, winning move exists.
Input Format
The first line contains an integer, $\mathrm{~g~}$, denoting the number of games Alice and Bob play.
Each line $\boldsymbol{i}$ of the $\mathrm{~g~}$ subsequent lines contains a single integer, $n$, describing a game.
Constraints
$1\leq g\leq1000$
$1\leq n\leq10^5$
Subtasks
$1\leq n\leq1000$ for $50\%$ of the maximum score
Output Format
For each game, print the name of the winner on a new line. If Alice wins, print Alice; otherwise, print Bob.
Sample Input 0
3
1
2
5
Sample Output 0
Bob
Alice
Alice
Explanation 0
Alice and Bob play the following $g=3$ games:
We are given $n=1$, so $set=\{1\}$. Because Alice has no valid moves (there are no prime numbers in the set), she loses the game. Thus, we print Bob on a new line.
We are given $n=2$, so $set=\{1,2\}$. Alice chooses the prime number $p=2$ and deletes it from the set, which becomes $set=\{1\}$. Because Bob has no valid moves (there are no prime numbers in the set), he loses the game. Thus, we print Alice on a new line.
We are given $n=5$, so $set=\{1,2,3,4,5\}$. Alice chooses the prime number $p=2$ and deletes the numbers $2$ and $4$ from the set, which becomes $set=\{1,3,5\}$. Now there are two primes left, $3$ and $5$. Bob can remove either prime from the set, and then Alice can remove the remaining prime. Because Bob is left without a final move, Alice will always win. Thus, we print Alice on a new line.
|
{"inputs": ["3\n1\n2\n5\n"], "outputs": ["Bob\nAlice\nAlice\n"]}
| 679
| 24
|
coding
|
Solve the programming task below in a Python markdown code block.
Vasily the bear has got a sequence of positive integers a_1, a_2, ..., a_{n}. Vasily the Bear wants to write out several numbers on a piece of paper so that the beauty of the numbers he wrote out was maximum.
The beauty of the written out numbers b_1, b_2, ..., b_{k} is such maximum non-negative integer v, that number b_1 and b_2 and ... and b_{k} is divisible by number 2^{v} without a remainder. If such number v doesn't exist (that is, for any non-negative integer v, number b_1 and b_2 and ... and b_{k} is divisible by 2^{v} without a remainder), the beauty of the written out numbers equals -1.
Tell the bear which numbers he should write out so that the beauty of the written out numbers is maximum. If there are multiple ways to write out the numbers, you need to choose the one where the bear writes out as many numbers as possible.
Here expression x and y means applying the bitwise AND operation to numbers x and y. In programming languages C++ and Java this operation is represented by "&", in Pascal — by "and".
-----Input-----
The first line contains integer n (1 ≤ n ≤ 10^5). The second line contains n space-separated integers a_1, a_2, ..., a_{n} (1 ≤ a_1 < a_2 < ... < a_{n} ≤ 10^9).
-----Output-----
In the first line print a single integer k (k > 0), showing how many numbers to write out. In the second line print k integers b_1, b_2, ..., b_{k} — the numbers to write out. You are allowed to print numbers b_1, b_2, ..., b_{k} in any order, but all of them must be distinct. If there are multiple ways to write out the numbers, choose the one with the maximum number of numbers to write out. If there still are multiple ways, you are allowed to print any of them.
-----Examples-----
Input
5
1 2 3 4 5
Output
2
4 5
Input
3
1 2 4
Output
1
4
|
{"inputs": ["1\n1\n", "1\n1\n", "1\n315\n", "1\n284\n", "1\n535\n", "1\n785\n", "1\n805\n", "1\n6360\n"], "outputs": ["1\n1\n", "1\n1 ", "1\n315\n", "1\n284\n", "1\n535\n", "1\n785\n", "1\n805\n", "1\n6360\n"]}
| 497
| 127
|
coding
|
Solve the programming task below in a Python markdown code block.
In Japan, people make offerings called hina arare, colorful crackers, on March 3.
We have a bag that contains N hina arare. (From here, we call them arare.)
It is known that the bag either contains arare in three colors: pink, white and green, or contains arare in four colors: pink, white, green and yellow.
We have taken out the arare in the bag one by one, and the color of the i-th arare was S_i, where colors are represented as follows - pink: P, white: W, green: G, yellow: Y.
If the number of colors of the arare in the bag was three, print Three; if the number of colors was four, print Four.
-----Constraints-----
- 1 \leq N \leq 100
- S_i is P, W, G or Y.
- There always exist i, j and k such that S_i=P, S_j=W and S_k=G.
-----Input-----
Input is given from Standard Input in the following format:
N
S_1 S_2 ... S_N
-----Output-----
If the number of colors of the arare in the bag was three, print Three; if the number of colors was four, print Four.
-----Sample Input-----
6
G W Y P Y W
-----Sample Output-----
Four
The bag contained arare in four colors, so you should print Four.
|
{"inputs": ["6\nG W Y Q Y W", "6\nG X X O X X", "6\nF W Y P Y W", "6\nF W Y O Y W", "6\nG W Y O Y W", "6\nE W Y O Y W", "6\nF W Y Q Y W", "6\nE W Y P Y W"], "outputs": ["Four\n", "Three\n", "Four\n", "Four\n", "Four\n", "Four\n", "Four\n", "Four\n"]}
| 315
| 118
|
coding
|
Solve the programming task below in a Python markdown code block.
You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.
Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .
Constraints
* $2 \leq n \leq 200,000$
* $1 \leq R_t \leq 10^9$
Input
The first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.
Output
Print the maximum value in a line.
Examples
Input
6
5
3
1
3
4
3
Output
3
Input
3
4
3
2
Output
-1
|
{"inputs": ["3\n4\n1\n2", "3\n4\n1\n3", "3\n5\n0\n6", "3\n3\n0\n9", "3\n2\n0\n0", "3\n4\n2\n3", "3\n5\n2\n3", "3\n5\n0\n3"], "outputs": ["1\n", "2\n", "6\n", "9\n", "0\n", "1\n", "1\n", "3\n"]}
| 277
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
n children are standing in a circle and playing the counting-out game. Children are numbered clockwise from 1 to n. In the beginning, the first child is considered the leader. The game is played in k steps. In the i-th step the leader counts out a_{i} people in clockwise order, starting from the next person. The last one to be pointed at by the leader is eliminated, and the next player after him becomes the new leader.
For example, if there are children with numbers [8, 10, 13, 14, 16] currently in the circle, the leader is child 13 and a_{i} = 12, then counting-out rhyme ends on child 16, who is eliminated. Child 8 becomes the leader.
You have to write a program which prints the number of the child to be eliminated on every step.
-----Input-----
The first line contains two integer numbers n and k (2 ≤ n ≤ 100, 1 ≤ k ≤ n - 1).
The next line contains k integer numbers a_1, a_2, ..., a_{k} (1 ≤ a_{i} ≤ 10^9).
-----Output-----
Print k numbers, the i-th one corresponds to the number of child to be eliminated at the i-th step.
-----Examples-----
Input
7 5
10 4 11 4 1
Output
4 2 5 6 1
Input
3 2
2 5
Output
3 2
-----Note-----
Let's consider first example: In the first step child 4 is eliminated, child 5 becomes the leader. In the second step child 2 is eliminated, child 3 becomes the leader. In the third step child 5 is eliminated, child 6 becomes the leader. In the fourth step child 6 is eliminated, child 7 becomes the leader. In the final step child 1 is eliminated, child 3 becomes the leader.
|
{"inputs": ["2 1\n1\n", "2 1\n2\n", "2 1\n3\n", "2 1\n1\n", "2 1\n3\n", "2 1\n2\n", "3 1\n2\n", "3 1\n1\n"], "outputs": ["2 \n", "1 \n", "2 \n", "2\n", "2\n", "1\n", "3\n", "2\n"]}
| 438
| 105
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef is deriving weird ways to sort his array. Currently he is trying to sort his arrays in increasing order by reversing some of his subarrays.
To make it more challenging for himself, Chef decides that he can reverse only those subarrays that have sum of its elements at most X. Soon he notices that it might not be always possible to sort the array with this condition.
Can you help the Chef by telling him if the given array can be sorted by reversing subarrays with sum at most X.
More formally, for a given array A and an integer X, check whether the array can be sorted in increasing order by reversing some (possibly none) of the subarrays such that the sum of all elements of the subarray is at most X.
------ Input Format ------
- First line will contain T, number of test cases. Then the test cases follow.
- The first line of each test case contains of two space-separated integers N and X denoting the length of the array and the maximum sum of subarrays that you can reverse.
- The second line contains N space-separated integers A_{1}, A_{2},..., A_{N} representing the initial array.
------ Output Format ------
For each test case, output \texttt{YES} if Chef can sort the array using a finite number of operations, else output \texttt{NO}.
You may print each character of the string in uppercase or lowercase (for example, the strings \texttt{YeS}, \texttt{yEs}, \texttt{yes} and \texttt{YES} will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 5\cdot 10^{4}$
$1 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 2\cdot 10^{9}$
$1 ≤ X ≤ 2\cdot 10^{9}$
- Sum of $N$ over all test cases does not exceeds $3\cdot 10^{5}$.
----- Sample Input 1 ------
3
4 1
1 2 3 4
4 1
2 1 3 4
5 7
3 2 2 3 3
----- Sample Output 1 ------
YES
NO
YES
----- explanation 1 ------
Test case $1$: The array is already sorted so we need not make any operations.
Test case $2$: There is no subarray with sum less than or equal to $1$ so we cannot sort the array.
Test case $3$: We can reverse the subarray $A[1, 3]$ which has a sum of $3+2+2=7$. Thus, the reversed subarray is $[2, 2, 3]$. The resulting array is $[2, 2, 3, 3, 3]$. The array is sorted in $1$ operation.
|
{"inputs": ["3\n4 1\n1 2 3 4\n4 1\n2 1 3 4\n5 7\n3 2 2 3 3\n"], "outputs": ["YES\nNO\nYES\n"]}
| 624
| 56
|
coding
|
Solve the programming task below in a Python markdown code block.
There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string s. The i-th (1-based) character of s represents the color of the i-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively.
Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times.
Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction c, if Liss is standing on a stone whose colors is c, Liss will move one stone forward, else she will not move.
You are given a string t. The number of instructions is equal to the length of t, and the i-th character of t represents the i-th instruction.
Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence.
-----Input-----
The input contains two lines. The first line contains the string s (1 ≤ |s| ≤ 50). The second line contains the string t (1 ≤ |t| ≤ 50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence.
-----Output-----
Print the final 1-based position of Liss in a single line.
-----Examples-----
Input
RGB
RRR
Output
2
Input
RRRBGBRBBB
BBBRR
Output
3
Input
BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB
BBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB
Output
15
|
{"inputs": ["R\nB\n", "R\nB\n", "S\nB\n", "S\nC\n", "S\nD\n", "T\nD\n", "U\nD\n", "R\nD\n"], "outputs": ["1\n", "1", "1\n", "1\n", "1\n", "1\n", "1\n", "1\n"]}
| 437
| 85
|
coding
|
Solve the programming task below in a Python markdown code block.
Little Petya very much likes computers. Recently he has received a new "Ternatron IV" as a gift from his mother. Unlike other modern computers, "Ternatron IV" operates with ternary and not binary logic. Petya immediately wondered how the xor operation is performed on this computer (and whether there is anything like it).
It turned out that the operation does exist (however, it is called tor) and it works like this. Suppose that we need to calculate the value of the expression a tor b. Both numbers a and b are written in the ternary notation one under the other one (b under a). If they have a different number of digits, then leading zeroes are added to the shorter number until the lengths are the same. Then the numbers are summed together digit by digit. The result of summing each two digits is calculated modulo 3. Note that there is no carry between digits (i. e. during this operation the digits aren't transferred). For example: 1410 tor 5010 = 01123 tor 12123 = 10213 = 3410.
Petya wrote numbers a and c on a piece of paper. Help him find such number b, that a tor b = c. If there are several such numbers, print the smallest one.
Input
The first line contains two integers a and c (0 ≤ a, c ≤ 109). Both numbers are written in decimal notation.
Output
Print the single integer b, such that a tor b = c. If there are several possible numbers b, print the smallest one. You should print the number in decimal notation.
Examples
Input
14 34
Output
50
Input
50 34
Output
14
Input
387420489 225159023
Output
1000000001
Input
5 5
Output
0
|
{"inputs": ["1 0\n", "0 0\n", "0 1\n", "5 5\n", "14 34\n", "50 34\n", "524 8790\n", "5849 7211\n"], "outputs": ["2\n", "0\n", "1\n", "0\n", "50\n", "14\n", "8998\n", "10146\n"]}
| 437
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has a pepperoni pizza in the shape of a $N \times N$ grid; both its rows and columns are numbered $1$ through $N$. Some cells of this grid have pepperoni on them, while some do not. Chef wants to cut the pizza vertically in half and give the two halves to two of his friends. Formally, one friend should get everything in the columns $1$ through $N/2$ and the other friend should get everything in the columns $N/2+1$ through $N$.
Before doing that, if Chef wants to, he may choose one row of the grid and reverse it, i.e. swap the contents of the cells in the $i$-th and $N+1-i$-th column in this row for each $i$ ($1 \le i \le N/2$).
After the pizza is cut, let's denote the number of cells containing pepperonis in one half by $p_1$ and their number in the other half by $p_2$. Chef wants to minimise their absolute difference. What is the minimum value of $|p_1-p_2|$?
-----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$.
- $N$ lines follow. For each $i$ ($1 \le i \le N$), the $i$-th of these lines contains a string with length $N$ describing the $i$-th row of the grid; this string contains only characters '1' (denoting a cell with pepperonis) and '0' (denoting a cell without pepperonis).
-----Output-----
For each test case, print a single line containing one integer — the minimum absolute difference between the number of cells with pepperonis in the half-pizzas given to Chef's friends.
-----Constraints-----
- $1 \le T \le 1,000$
- $2 \le N \le 1,000$
- $N$ is even
- the sum of $N \cdot N$ over all test cases does not exceed $2 \cdot 10^6$
-----Example Input-----
2
6
100000
100000
100000
100000
010010
001100
4
0011
1100
1110
0001
-----Example Output-----
2
0
-----Explanation-----
Example case 1: Initially, $|p_1-p_2| = 4$, but if Chef reverses any one of the first four rows from "100000" to "000001", $|p_1-p_2|$ becomes $2$.
Example case 2: Initially, $|p_1-p_2| = 0$. We cannot make that smaller by reversing any row.
|
{"inputs": ["2\n6\n100000\n100000\n100000\n100000\n010010\n001100\n4\n0011\n1100\n1110\n0001"], "outputs": ["2\n0"]}
| 668
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has N friends. Chef promised that he would gift a pair of shoes (consisting of one left shoe and one right shoe) to each of his N friends. Chef was about to go to the marketplace to buy shoes, but he suddenly remembers that he already had M left shoes.
What is the minimum number of extra shoes that Chef will have to buy to ensure that he is able to gift a pair of shoes to each of his N friends?
For example, if N = 2, M = 4, then Chef already has 4 left shoes, so he must buy 2 extra right shoes to form 2 pairs of shoes.
Therefore Chef must buy at least 2 extra shoes to ensure that he is able to get N = 2 pairs of shoes.
------ 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 two integers N and M - the number of Chef's friends and the number of left shoes Chef has.
------ Output Format ------
For each test case, output the minimum number of extra shoes that Chef will have to buy to ensure that he is able to get N pairs of shoes.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ N ≤ 100$
$0 ≤ M ≤ 100$
----- Sample Input 1 ------
3
2 4
6 0
4 3
----- Sample Output 1 ------
2
12
5
----- explanation 1 ------
Test Case 1: Discussed in the problem statement
Test Case 2: Chef initially has no left shoes. He must buy $6$ more left shoes and $6$ more right shoes to form $6$ pairs of shoes.
Test Case 3: Chef initially has $3$ left shoes. He must buy $1$ more left shoe and $4$ more right shoes to form $4$ pairs of shoes.
|
{"inputs": ["3\n2 4\n6 0\n4 3\n"], "outputs": ["2\n12\n5\n"]}
| 426
| 31
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word derivative. For example, when the root "help" is followed by the word "ful", we can form a derivative "helpful".
Given a dictionary consisting of many roots and a sentence consisting of words separated by spaces, replace all the derivatives in the sentence with the root forming it. If a derivative can be replaced by more than one root, replace it with the root that has the shortest length.
Return the sentence after the replacement.
Please complete the following python code precisely:
```python
class Solution:
def replaceWords(self, dictionary: List[str], sentence: str) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(dictionary = [\"cat\",\"bat\",\"rat\"], sentence = \"the cattle was rattled by the battery\") == \"the cat was rat by the bat\"\n assert candidate(dictionary = [\"a\",\"b\",\"c\"], sentence = \"aadsfasf absbs bbab cadsfafs\") == \"a a b c\"\n\n\ncheck(Solution().replaceWords)"}
| 169
| 94
|
coding
|
Solve the programming task below in a Python markdown code block.
Consider an infinite sequence a_1, a_2, … Initially, the values of all the terms are 0, and from this state we will sequentially perform Q operations. The i-th operation (1 ≤ i ≤ Q) is as follows:
* For every positive integer j, add x_i to the value of a_{j × m_i}.
Find the value of the largest term after these Q operations.
Constraints
* 1 ≤ Q ≤ 299
* 2 ≤ m_i ≤ 300
* -10^6 ≤ x_i ≤ 10^6
* All m_i are distinct.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
Q
m_1 x_1
:
m_Q x_Q
Output
Print the value of the largest term after the Q operations.
Examples
Input
3
2 10
3 -20
6 15
Output
10
Input
3
10 -3
50 4
100 -5
Output
1
Input
5
56 114834
72 -149861
100 190757
192 -132693
240 133108
Output
438699
|
{"inputs": ["3\n4 9\n3 -20\n2 18", "3\n7 9\n62 0\n111 1", "3\n2 10\n3 -4\n6 15", "3\n2 1\n4 -20\n6 15", "3\n2 18\n3 -20\n6 15", "3\n7 -3\n15 0\n110 0", "3\n2 18\n4 -20\n6 15", "3\n36 -3\n6 4\n111 2"], "outputs": ["27\n", "10\n", "21\n", "16\n", "18\n", "0\n", "33\n", "6\n"]}
| 310
| 185
|
coding
|
Solve the programming task below in a Python markdown code block.
How many licks does it take to get to the tootsie roll center of a tootsie pop?
A group of engineering students from Purdue University reported that its licking machine, modeled after a human tongue, took an average of 364 licks to get to the center of a Tootsie Pop. Twenty of the group's volunteers assumed the licking challenge-unassisted by machinery-and averaged 252 licks each to the center.
Your task, if you choose to accept it, is to write a function that will return the number of licks it took to get to the tootsie roll center of a tootsie pop, given some environmental variables.
Everyone knows it's harder to lick a tootsie pop in cold weather but it's easier if the sun is out. You will be given an object of environmental conditions for each trial paired with a value that will increase or decrease the number of licks. The environmental conditions all apply to the same trial.
Assuming that it would normally take 252 licks to get to the tootsie roll center of a tootsie pop, return the new total of licks along with the condition that proved to be most challenging (causing the most added licks) in that trial.
Example:
```
totalLicks({ "freezing temps": 10, "clear skies": -2 });
```
Should return:
```
"It took 260 licks to get to the tootsie roll center of a tootsie pop. The toughest challenge was freezing temps."
```
Other cases:
If there are no challenges, the toughest challenge sentence should be omitted. If there are multiple challenges with the highest toughest amount, the first one presented will be the toughest.
If an environment variable is present, it will be either a positive or negative integer. No need to validate.
Check out my other 80's Kids Katas:
80's Kids #1: How Many Licks Does It Take
80's Kids #2: Help Alf Find His Spaceship
80's Kids #3: Punky Brewster's Socks
80's Kids #4: Legends of the Hidden Temple
80's Kids #5: You Can't Do That on Television
80's Kids #6: Rock 'Em, Sock 'Em Robots
80's Kids #7: She's a Small Wonder
80's Kids #8: The Secret World of Alex Mack
80's Kids #9: Down in Fraggle Rock
80's Kids #10: Captain Planet
Also feel free to reuse/extend the following starter code:
```python
def total_licks(env):
```
|
{"functional": "_inputs = [[{'freezing temps': 10, 'clear skies': -2}], [{'happiness': -5, 'clear skies': -2}], [{}], [{'dragons': 100, 'evil wizards': 110, 'trolls': 50}], [{'white magic': -250}]]\n_outputs = [['It took 260 licks to get to the tootsie roll center of a tootsie pop. The toughest challenge was freezing temps.'], ['It took 245 licks to get to the tootsie roll center of a tootsie pop.'], ['It took 252 licks to get to the tootsie roll center of a tootsie pop.'], ['It took 512 licks to get to the tootsie roll center of a tootsie pop. The toughest challenge was evil wizards.'], ['It took 2 licks to get to the tootsie roll center of a tootsie pop.']]\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(total_licks(*i), o[0])"}
| 571
| 361
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in [Mandarin Chinese], [Russian], [Vietnamese] and [Bengali] as well.
Chef is playing a game where he has an array $A$ of $N$ integers, and an integer $K$. He looks at every subarray of length $K$, and writes its sum on a piece of paper. If a number appears as the sum of multiple subarrays of length $K$, then he only writes down that number once.
Chef is lazy and doesn't like to write numbers. You, being a friend of Chef, want to modify the array such that Chef will only write one number on his paper. In one modification you can choose any index $i$ and replace $A_{i}$ with any integer.
You need to find the minimum number of modifications required.
------ Input ------
The first line contains an integer $T$, the number of test cases. Then the test cases follow.
Each test case contains two lines of input.
The first line contains two space-separated integers $N$, $K$.
The second line contains $N$ space-separated integers $A_{1}, A_{2}, \ldots, A_{N}$.
------ Output ------
For each test case, output the answer in a single line.
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ N ≤ 10^{5}$
$1 ≤ K ≤ N$
$1 ≤ A_{i} ≤ 10^{5}$
The sum of $N$ over all test cases does not exceed $5\cdot 10^{5}$.
----- Sample Input 1 ------
2
3 3
1 2 3
2 1
4 6
----- Sample Output 1 ------
0
1
----- explanation 1 ------
Test Case 1: $K=3$ and there is only one subarray of length $3$, so no changes are required.
Test Case 2: $K=1$ and the subarrays of length $1$ are $[4]$ and $[6]$. So, at least one modification is required. One possible solution with only one modification is to change $A_{2}$ to $4$.
|
{"inputs": ["2\n3 3 \n1 2 3\n2 1\n4 6"], "outputs": ["0\n1"]}
| 477
| 33
|
coding
|
Solve the programming task below in a Python markdown code block.
Takahashi has N days of summer vacation.
His teacher gave him M summer assignments. It will take A_i days for him to do the i-th assignment.
He cannot do multiple assignments on the same day, or hang out on a day he does an assignment.
What is the maximum number of days Takahashi can hang out during the vacation if he finishes all the assignments during this vacation?
If Takahashi cannot finish all the assignments during the vacation, print -1 instead.
-----Constraints-----
- 1 \leq N \leq 10^6
- 1 \leq M \leq 10^4
- 1 \leq A_i \leq 10^4
-----Input-----
Input is given from Standard Input in the following format:
N M
A_1 ... A_M
-----Output-----
Print the maximum number of days Takahashi can hang out during the vacation, or -1.
-----Sample Input-----
41 2
5 6
-----Sample Output-----
30
For example, he can do the first assignment on the first 5 days, hang out on the next 30 days, and do the second assignment on the last 6 days of the vacation. In this way, he can safely spend 30 days hanging out.
|
{"inputs": ["1 2\n0 1", "4 6\n2 0", "3 2\n7 4", "3 2\n7 8", "1 2\n7 8", "2 2\n7 8", "2 2\n6 8", "0 2\n6 8"], "outputs": ["0\n", "2\n", "-1\n", "-1\n", "-1\n", "-1\n", "-1\n", "-1\n"]}
| 286
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Russian also.
Chef likes shopping, and especially he likes to buy oranges. But right now he is short of money. He has only k rubles. There are n oranges. The i-th one costs cost_{i} rubles and has weight equal to weight_{i}. Chef wants to buy a set of oranges with the maximal possible weight. Please help him, and tell him this weight.
------ Input ------
The first line of the input contains an integer T denoting the number of test cases. The first line of each test case contains two numbers n and k. The following n lines contain two numbers cost_{i} and weight_{i} respectively.
------ Output ------
For each test case, output a single line containing maximal weight among all the affordable sets of oranges.
------ Constraints ------
$1 ≤ T ≤ 250 $
$1 ≤ n ≤ 10 $
$1 ≤ k ≤ 100000000 $
$1 ≤ weight_{i} ≤ 100000000 $
$1 ≤ cost_{i} ≤ 100000000 $
------ Scoring ------
Subtask 1 (30 points): All the oranges' weights equals to 1.
Subtask 2 (30 points): N = 5
Subtask 2 (40 points): See the constraints
----- Sample Input 1 ------
2
1 3
2 2
3 4
2 1
2 2
3 5
----- Sample Output 1 ------
2
5
|
{"inputs": ["2\n1 3\n2 2\n3 4\n2 1\n2 2\n3 5", "2\n1 3\n2 2\n3 4\n2 2\n2 2\n3 5", "2\n1 3\n2 2\n1 4\n2 3\n2 2\n3 5", "2\n1 3\n2 3\n1 4\n2 3\n2 2\n3 5", "2\n1 3\n2 4\n1 4\n2 3\n2 2\n3 5", "2\n1 3\n2 2\n3 4\n0 1\n2 2\n3 5", "2\n2 3\n2 2\n3 4\n2 2\n2 2\n3 5", "2\n1 3\n2 2\n1 4\n2 1\n2 2\n3 5"], "outputs": ["2\n5", "2\n5\n", "2\n3\n", "3\n3\n", "4\n3\n", "2\n6\n", "4\n2\n", "2\n1\n"]}
| 357
| 269
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given two arrays of positive integers, boxes and warehouse, representing the heights of some boxes of unit width and the heights of n rooms in a warehouse respectively. The warehouse's rooms are labelled from 0 to n - 1 from left to right where warehouse[i] (0-indexed) is the height of the ith room.
Boxes are put into the warehouse by the following rules:
Boxes cannot be stacked.
You can rearrange the insertion order of the boxes.
Boxes can only be pushed into the warehouse from left to right only.
If the height of some room in the warehouse is less than the height of a box, then that box and all other boxes behind it will be stopped before that room.
Return the maximum number of boxes you can put into the warehouse.
Please complete the following python code precisely:
```python
class Solution:
def maxBoxesInWarehouse(self, boxes: List[int], warehouse: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(boxes = [4,3,4,1], warehouse = [5,3,3,4,1]) == 3\n assert candidate(boxes = [1,2,2,3,4], warehouse = [3,4,1,2]) == 3\n assert candidate(boxes = [1,2,3], warehouse = [1,2,3,4]) == 1\n\n\ncheck(Solution().maxBoxesInWarehouse)"}
| 211
| 113
|
coding
|
Solve the programming task below in a Python markdown code block.
Complete the function solveMeFirst to compute the sum of two integers.
Example
$a=7$
$b=3$
Return $10$.
Function Description
Complete the solveMeFirst function in the editor below.
solveMeFirst has the following parameters:
int a: the first value
int b: the second value
Returns
- int: the sum of $a$ and $b$
Constraints
$1\le a,b\le1000$
Sample Input
a = 2
b = 3
Sample Output
5
Explanation
$2+3=5$.
|
{"inputs": ["2\n3\n"], "outputs": ["5\n"]}
| 140
| 16
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a string number representing a positive integer and a character digit.
Return the resulting string after removing exactly one occurrence of digit from number such that the value of the resulting string in decimal form is maximized. The test cases are generated such that digit occurs at least once in number.
Please complete the following python code precisely:
```python
class Solution:
def removeDigit(self, number: str, digit: str) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(number = \"123\", digit = \"3\") == \"12\"\n assert candidate(number = \"1231\", digit = \"1\") == \"231\"\n assert candidate(number = \"551\", digit = \"5\") == \"51\"\n\n\ncheck(Solution().removeDigit)"}
| 109
| 84
|
coding
|
Solve the programming task below in a Python markdown code block.
You have an array $a$ of length $n$. For every positive integer $x$ you are going to perform the following operation during the $x$-th second:
Select some distinct indices $i_{1}, i_{2}, \ldots, i_{k}$ which are between $1$ and $n$ inclusive, and add $2^{x-1}$ to each corresponding position of $a$. Formally, $a_{i_{j}} := a_{i_{j}} + 2^{x-1}$ for $j = 1, 2, \ldots, k$. Note that you are allowed to not select any indices at all.
You have to make $a$ nondecreasing as fast as possible. Find the smallest number $T$ such that you can make the array nondecreasing after at most $T$ seconds.
Array $a$ is nondecreasing if and only if $a_{1} \le a_{2} \le \ldots \le a_{n}$.
You have to answer $t$ independent test cases.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^{4}$) — the number of test cases.
The first line of each test case contains single integer $n$ ($1 \le n \le 10^{5}$) — the length of array $a$. It is guaranteed that the sum of values of $n$ over all test cases in the input does not exceed $10^{5}$.
The second line of each test case contains $n$ integers $a_{1}, a_{2}, \ldots, a_{n}$ ($-10^{9} \le a_{i} \le 10^{9}$).
-----Output-----
For each test case, print the minimum number of seconds in which you can make $a$ nondecreasing.
-----Example-----
Input
3
4
1 7 6 5
5
1 2 3 4 5
2
0 -4
Output
2
0
3
-----Note-----
In the first test case, if you select indices $3, 4$ at the $1$-st second and $4$ at the $2$-nd second, then $a$ will become $[1, 7, 7, 8]$. There are some other possible ways to make $a$ nondecreasing in $2$ seconds, but you can't do it faster.
In the second test case, $a$ is already nondecreasing, so answer is $0$.
In the third test case, if you do nothing at first $2$ seconds and select index $2$ at the $3$-rd second, $a$ will become $[0, 0]$.
|
{"inputs": ["3\n4\n1 7 6 5\n5\n1 2 3 4 5\n2\n0 -4\n", "3\n4\n1 7 7 5\n5\n1 2 3 4 5\n2\n0 -4\n", "3\n4\n1 7 6 5\n5\n1 4 3 4 5\n2\n0 -4\n", "3\n4\n1 7 6 5\n5\n1 6 3 4 5\n2\n0 -4\n", "3\n4\n1 7 7 5\n5\n1 0 3 4 5\n2\n0 -1\n", "3\n4\n1 7 7 7\n5\n1 0 3 4 5\n2\n0 -8\n", "3\n4\n1 7 7 4\n5\n1 2 9 0 1\n2\n-1 0\n", "3\n4\n1 7 7 8\n5\n1 2 9 0 1\n2\n-1 0\n"], "outputs": ["2\n0\n3\n", "2\n0\n3\n", "2\n1\n3\n", "2\n2\n3\n", "2\n1\n1\n", "0\n1\n4\n", "2\n4\n0\n", "0\n4\n0\n"]}
| 615
| 328
|
coding
|
Solve the programming task below in a Python markdown code block.
Create a __moreZeros__ function which will __receive a string__ for input, and __return an array__ (or null terminated string in C) containing only the characters from that string whose __binary representation of its ASCII value__ consists of _more zeros than ones_.
You should __remove any duplicate characters__, keeping the __first occurence__ of any such duplicates, so they are in the __same order__ in the final array as they first appeared in the input string.
Examples
All input will be valid strings of length > 0. Leading zeros in binary should not be counted.
Also feel free to reuse/extend the following starter code:
```python
def more_zeros(s):
```
|
{"functional": "_inputs = [['abcde'], ['thequickbrownfoxjumpsoverthelazydog'], ['THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG'], ['abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_'], ['DIGEST'], ['abcdabcd'], ['Forgiveness is the fragrance that the violet sheds on the heal that has crushed it']]\n_outputs = [[['a', 'b', 'd']], [['h', 'b', 'p', 'a', 'd']], [['T', 'H', 'E', 'Q', 'I', 'C', 'B', 'R', 'F', 'X', 'J', 'P', 'L', 'A', 'D']], [['a', 'b', 'd', 'h', 'p', 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'I', 'J', 'L', 'P', 'Q', 'R', 'T', 'X', '0']], [['D', 'I', 'E', 'T']], [['a', 'b', 'd']], [['F', ' ', 'h', 'a', 'd']]]\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(more_zeros(*i), o[0])"}
| 157
| 393
|
coding
|
Solve the programming task below in a Python markdown code block.
CODE FESTIVAL 2016 is going to be held. For the occasion, Mr. Takahashi decided to make a signboard.
He intended to write `CODEFESTIVAL2016` on it, but he mistakenly wrote a different string S. Fortunately, the string he wrote was the correct length.
So Mr. Takahashi decided to perform an operation that replaces a certain character with another in the minimum number of iterations, changing the string to `CODEFESTIVAL2016`.
Find the minimum number of iterations for the rewrite operation.
Constraints
* S is 16 characters long.
* S consists of uppercase and lowercase alphabet letters and numerals.
Input
Inputs are provided from Standard Input in the following form.
S
Output
Output an integer representing the minimum number of iterations needed for the rewrite operation.
Examples
Input
C0DEFESTIVAL2O16
Output
2
Input
FESTIVAL2016CODE
Output
16
|
{"inputs": ["C0DEFESTIVAL2O61", "EDOC6102LAVITSEF", "C0DEFERTIVAL2O61", "C0DEGERTIVAL2O61", "CTDEGER0IVAL2O61", "CT/EGERDIVAL2O61", "CT0EGERDIVAK2O61", "1DO2LAVI6REGE0TC"], "outputs": ["4\n", "16\n", "5\n", "6\n", "7\n", "8\n", "9\n", "15\n"]}
| 220
| 134
|
coding
|
Solve the programming task below in a Python markdown code block.
Your classmates asked you to copy some paperwork for them. You know that there are 'n' classmates and the paperwork has 'm' pages.
Your task is to calculate how many blank pages do you need.
### Example:
```python
paperwork(5, 5) == 25
```
**Note:** if `n < 0` or `m < 0` return `0`!
Waiting for translations and Feedback! Thanks!
Also feel free to reuse/extend the following starter code:
```python
def paperwork(n, m):
```
|
{"functional": "_inputs = [[5, 5], [5, -5], [-5, -5], [-5, 5], [5, 0]]\n_outputs = [[25], [0], [0], [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(paperwork(*i), o[0])"}
| 128
| 195
|
coding
|
Solve the programming task below in a Python markdown code block.
Depth-first search (DFS) follows the strategy to search ”deeper” in the graph whenever possible. In DFS, edges are recursively explored out of the most recently discovered vertex $v$ that still has unexplored edges leaving it. When all of $v$'s edges have been explored, the search ”backtracks” to explore edges leaving the vertex from which $v$ was discovered.
This process continues until all the vertices that are reachable from the original source vertex have been discovered. If any undiscovered vertices remain, then one of them is selected as a new source and the search is repeated from that source.
DFS timestamps each vertex as follows:
* $d[v]$ records when $v$ is first discovered.
* $f[v]$ records when the search finishes examining $v$’s adjacency list.
Write a program which reads a directed graph $G = (V, E)$ and demonstrates DFS on the graph based on the following rules:
* $G$ is given in an adjacency-list. Vertices are identified by IDs $1, 2,... n$ respectively.
* IDs in the adjacency list are arranged in ascending order.
* The program should report the discover time and the finish time for each vertex.
* When there are several candidates to visit during DFS, the algorithm should select the vertex with the smallest ID.
* The timestamp starts with 1.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ denoting the number of vertices of $G$ is given. In the next $n$ lines, adjacency lists of $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is ID of the vertex and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
For each vertex, print $id$, $d$ and $f$ separated by a space character in a line. $id$ is ID of the vertex, $d$ and $f$ is the discover time and the finish time respectively. Print in order of vertex IDs.
Examples
Input
4
1 1 2
2 1 4
3 0
4 1 3
Output
1 1 8
2 2 7
3 4 5
4 3 6
Input
6
1 2 2 3
2 2 3 4
3 1 5
4 1 6
5 1 6
6 0
Output
1 1 12
2 2 11
3 3 8
4 9 10
5 4 7
6 5 6
|
{"inputs": ["4\n1 1 1\n2 1 4\n3 0\n4 1 3", "4\n1 1 1\n2 1 4\n3 0\n4 1 2", "4\n1 1 3\n2 1 4\n3 0\n4 1 3", "4\n1 1 3\n2 1 1\n3 0\n4 1 3", "4\n1 1 2\n2 1 4\n3 0\n4 1 2", "4\n1 1 2\n2 1 2\n3 0\n4 1 3", "4\n1 1 1\n2 1 1\n3 0\n4 1 2", "4\n1 1 1\n2 1 3\n3 0\n4 1 3"], "outputs": ["1 1 2\n2 3 8\n3 5 6\n4 4 7\n", "1 1 2\n2 3 6\n3 7 8\n4 4 5\n", "1 1 4\n2 5 8\n3 2 3\n4 6 7\n", "1 1 4\n2 5 6\n3 2 3\n4 7 8\n", "1 1 6\n2 2 5\n3 7 8\n4 3 4\n", "1 1 4\n2 2 3\n3 5 6\n4 7 8\n", "1 1 2\n2 3 4\n3 5 6\n4 7 8\n", "1 1 2\n2 3 6\n3 4 5\n4 7 8\n"]}
| 601
| 414
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
John is playing a RPG game. The initial attack value of the player is `x`. The player will face a crowd of monsters. Each monster has different defense value.
If the monster's defense value is less than or equal to the player's attack value, the player can easily defeat the monster, and the player's attack value will increase. The amount increased is equal to the monster's defense value.
If the monster's defense value is greater than the player's attack value, the player can still defeat monsters, but the player's attack value can only be increased little, equal to the `greatest common divisor` of the monster's defense value and the player's current attack value.
The defense values for all monsters are provided by `monsterList/monster_list`. The player will fight with the monsters from left to right.
Please help John calculate the player's final attack value.
# Example
For `x = 50, monsterList=[50,105,200]`, the output should be `110`.
The attack value increased: `50 --> 100 --> 105 --> 110`
For `x = 20, monsterList=[30,20,15,40,100]`, the output should be `205`.
The attack value increased:
`20 --> 30 --> 50 --> 65 --> 105 --> 205`
Also feel free to reuse/extend the following starter code:
```python
def final_attack_value(x,monster_list):
```
|
{"functional": "_inputs = [[50, [50, 105, 200]], [20, [30, 20, 15, 40, 100]]]\n_outputs = [[110], [205]]\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(final_attack_value(*i), o[0])"}
| 347
| 202
|
coding
|
Solve the programming task below in a Python markdown code block.
A film festival is coming up in the city N. The festival will last for exactly n days and each day will have a premiere of exactly one film. Each film has a genre — an integer from 1 to k.
On the i-th day the festival will show a movie of genre a_{i}. We know that a movie of each of k genres occurs in the festival programme at least once. In other words, each integer from 1 to k occurs in the sequence a_1, a_2, ..., a_{n} at least once.
Valentine is a movie critic. He wants to watch some movies of the festival and then describe his impressions on his site.
As any creative person, Valentine is very susceptive. After he watched the movie of a certain genre, Valentine forms the mood he preserves until he watches the next movie. If the genre of the next movie is the same, it does not change Valentine's mood. If the genres are different, Valentine's mood changes according to the new genre and Valentine has a stress.
Valentine can't watch all n movies, so he decided to exclude from his to-watch list movies of one of the genres. In other words, Valentine is going to choose exactly one of the k genres and will skip all the movies of this genre. He is sure to visit other movies.
Valentine wants to choose such genre x (1 ≤ x ≤ k), that the total number of after-movie stresses (after all movies of genre x are excluded) were minimum.
-----Input-----
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 10^5), where n is the number of movies and k is the number of genres.
The second line of the input contains a sequence of n positive integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ k), where a_{i} is the genre of the i-th movie. It is guaranteed that each number from 1 to k occurs at least once in this sequence.
-----Output-----
Print a single number — the number of the genre (from 1 to k) of the excluded films. If there are multiple answers, print the genre with the minimum number.
-----Examples-----
Input
10 3
1 1 2 3 2 3 3 1 1 3
Output
3
Input
7 3
3 1 3 2 3 1 2
Output
1
-----Note-----
In the first sample if we exclude the movies of the 1st genre, the genres 2, 3, 2, 3, 3, 3 remain, that is 3 stresses; if we exclude the movies of the 2nd genre, the genres 1, 1, 3, 3, 3, 1, 1, 3 remain, that is 3 stresses; if we exclude the movies of the 3rd genre the genres 1, 1, 2, 2, 1, 1 remain, that is 2 stresses.
In the second sample whatever genre Valentine excludes, he will have exactly 3 stresses.
|
{"inputs": ["2 2\n1 2\n", "2 2\n1 2\n", "7 3\n3 1 3 2 3 1 2\n", "7 3\n3 1 2 2 3 1 2\n", "7 3\n3 1 2 3 3 1 2\n", "7 3\n3 1 3 2 3 1 2\n", "10 3\n1 1 2 3 2 3 3 1 1 3\n", "10 2\n1 2 2 1 1 2 1 1 2 2\n"], "outputs": ["1", "1\n", "1", "1\n", "1\n", "1\n", "3", "1"]}
| 676
| 188
|
coding
|
Solve the programming task below in a Python markdown code block.
Congratulations !!! You have successfully completed the heist by looting all the gifts in Santa's locker. Now it's time to decide who gets to take all the gifts, you or the Grinch, there will be no splitting. So you and Grinch decide to play a game.
To start the game, an Integer N will be given. The game is played in turns and for each turn, the player can make any one of the following moves:
- Divide N by any of it's odd divisors greater than 1.
- Subtract 1 from N if N is greater than 1.
Divisor of a number includes the number itself.
The player who is unable to make a move loses the game.
Since you are the mastermind of the heist, you get to play the first move.
-----Input-----
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer — N (1 ≤ N ≤ 109).
-----Output-----
For each test case, print " Me" if you win, and " Grinch" if otherwise (without quotes).
-----Sample Input-----
7
1
2
3
4
5
6
12
-----Sample Output-----
Grinch
Me
Me
Grinch
Me
Grinch
Me
|
{"inputs": ["7\n1\n2\n3\n4\n5\n6\n12"], "outputs": ["Grinch\nMe\nMe\nGrinch\nMe\nGrinch\nMe"]}
| 303
| 42
|
coding
|
Solve the programming task below in a Python markdown code block.
You have to rebuild a string from an enumerated list.
For this task, you have to check if input is correct beforehand.
* Input must be a list of tuples
* Each tuple has two elements.
* Second element is an alphanumeric character.
* First element is the index of this character into the reconstructed string.
* Indexes start at 0 and have to match with output indexing: no gap is allowed.
* Finally tuples aren't necessarily ordered by index.
If any condition is invalid, the function should return `False`.
Input example:
```python
[(4,'y'),(1,'o'),(3,'t'),(0,'m'),(2,'n')]
```
Returns
```python
'monty'
```
Also feel free to reuse/extend the following starter code:
```python
def denumerate(enum_list):
```
|
{"functional": "_inputs = [[1], ['a'], [[0]], [[['a', 0]]], [[[1, 'a']]], [[[0, '']]]]\n_outputs = [[False], [False], [False], [False], [False], [False]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(denumerate(*i), o[0])"}
| 187
| 196
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There exists an undirected and unrooted tree with n nodes indexed from 0 to n - 1. You are given an integer n and a 2D integer array edges of length n - 1, where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree. You are also given an array coins of size n where coins[i] can be either 0 or 1, where 1 indicates the presence of a coin in the vertex i.
Initially, you choose to start at any vertex in the tree. Then, you can perform the following operations any number of times:
Collect all the coins that are at a distance of at most 2 from the current vertex, or
Move to any adjacent vertex in the tree.
Find the minimum number of edges you need to go through to collect all the coins and go back to the initial vertex.
Note that if you pass an edge several times, you need to count it into the answer several times.
Please complete the following python code precisely:
```python
class Solution:
def collectTheCoins(self, coins: List[int], edges: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(coins = [1,0,0,0,0,1], edges = [[0,1],[1,2],[2,3],[3,4],[4,5]]) == 2\n assert candidate(coins = [0,0,0,1,1,0,0,1], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[5,6],[5,7]]) == 2\n\n\ncheck(Solution().collectTheCoins)"}
| 268
| 124
|
coding
|
Solve the programming task below in a Python markdown code block.
# Remove Duplicates
You are to write a function called `unique` that takes an array of integers and returns the array with duplicates removed. It must return the values in the same order as first seen in the given array. Thus no sorting should be done, if 52 appears before 10 in the given array then it should also be that 52 appears before 10 in the returned array.
## Assumptions
* All values given are integers (they can be positive or negative).
* You are given an array but it may be empty.
* They array may have duplicates or it may not.
## Example
```python
print unique([1, 5, 2, 0, 2, -3, 1, 10])
[1, 5, 2, 0, -3, 10]
print unique([])
[]
print unique([5, 2, 1, 3])
[5, 2, 1, 3]
```
Also feel free to reuse/extend the following starter code:
```python
def unique(integers):
```
|
{"functional": "_inputs = [[[]], [[-1]], [[-1, 5, 10, -100, 3, 2]], [[1, 2, 3, 3, 2, 1, 2, 3, 1, 1, 3, 2]], [[1, 3, 2, 3, 2, 1, 2, 3, 1, 1, 3, 2]], [[3, 2, 3, 3, 2, 1, 2, 3, 1, 1, 3, 2]]]\n_outputs = [[[]], [[-1]], [[-1, 5, 10, -100, 3, 2]], [[1, 2, 3]], [[1, 3, 2]], [[3, 2, 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(unique(*i), o[0])"}
| 246
| 340
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a string array words and a string s, where words[i] and s comprise only of lowercase English letters.
Return the number of strings in words that are a prefix of s.
A prefix of a string is a substring that occurs at the beginning of the string. A substring is a contiguous sequence of characters within a string.
Please complete the following python code precisely:
```python
class Solution:
def countPrefixes(self, words: List[str], s: str) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(words = [\"a\",\"b\",\"c\",\"ab\",\"bc\",\"abc\"], s = \"abc\") == 3\n assert candidate(words = [\"a\",\"a\"], s = \"aa\") == 2\n\n\ncheck(Solution().countPrefixes)"}
| 121
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given three integers $n$, $a$, and $b$. Determine if there exist two permutations $p$ and $q$ of length $n$, for which the following conditions hold:
The length of the longest common prefix of $p$ and $q$ is $a$.
The length of the longest common suffix of $p$ and $q$ is $b$.
A permutation of length $n$ is an array containing each integer from $1$ to $n$ exactly once. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array), and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array).
-----Input-----
Each test contains multiple test cases. The first line contains a single integer $t$ ($1\leq t\leq 10^4$) — the number of test cases. The description of test cases follows.
The only line of each test case contains three integers $n$, $a$, and $b$ ($1\leq a,b\leq n\leq 100$).
-----Output-----
For each test case, if such a pair of permutations exists, output "Yes"; otherwise, output "No". You can output each letter in any case (upper or lower).
-----Examples-----
Input
4
1 1 1
2 1 2
3 1 1
4 1 1
Output
Yes
No
No
Yes
-----Note-----
In the first test case, $[1]$ and $[1]$ form a valid pair.
In the second test case and the third case, we can show that such a pair of permutations doesn't exist.
In the fourth test case, $[1,2,3,4]$ and $[1,3,2,4]$ form a valid pair.
|
{"inputs": ["4\n1 1 1\n2 1 2\n3 1 1\n4 1 1\n"], "outputs": ["Yes\nNo\nNo\nYes\n"]}
| 435
| 44
|
coding
|
Solve the programming task below in a Python markdown code block.
Bob is a dance teacher and he started dance classes recently. He observes a strange attendance pattern among his students. Initially, there are no students. On day i, a new student starts attending the class. The student stops attending the class, if and only if he has attended the class for i consecutive days.
Also, the student resumes attending the class, if and only if he has not attended the class for i consecutive days.
We denote the student who starts coming on day i as student i.
To mark attendance, o denotes present and x denotes absent.
For example, the schedule for student 1 from day 1 is as follows:
oxoxoxoxoxoxoxoxoxox...
The schedule for the student 3 from day 1 is as follows:
xxoooxxxoooxxxoooxxx...
(Student 3 starts attending the class from day 3, and stops attending from day 6, and then starts attending from day 9, and so on. )
The schedule for the student 5 from day 1 is as follows.
xxxxoooooxxxxxoooooxxxxx...
Bob wants his students to dance in pairs. However, if the number of students coming on day i is odd, then there will be someone who can't find a partner. So Bob wants to know if the number of students coming on day i is even or odd. We denote the number of students coming on day i as N(i). Please find out whether N(i) is even or odd.
Input format
The first line contains an integer, T, which denotes the number of test cases.
For each test case, there is an integer i
Output Format
For each test case, if N(i) is even, then print even.
If N(i) is odd, then print one line odd.
Constraints
1 ≤ T ≤ 100
1 ≤ i ≤ 10^{18}
Sample Input
4
1
2
3
4
Sample Output
odd
odd
odd
even
Explanation
The number of students coming on day 1 is 1: only student #1 attends the class. So N(1)=1 and it is odd.
The number of students coming on day 2 is 1: student #2, so n(2)=1 and it is odd.
The number of students coming on day 3 is 3: student #1, student #2, and student #3. So N(3)=3 and it is odd.
The number of students coming on day 4 is 2: student #3 and student #4. So N(4)=2 and it is even.
|
{"inputs": ["4\n1\n2\n3\n4\n"], "outputs": ["odd\nodd\nodd\neven\n"]}
| 572
| 29
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a regex to validate a 24 hours time string.
See examples to figure out what you should check for:
Accepted:
01:00 - 1:00
Not accepted:
24:00
You should check for correct length and no spaces.
Also feel free to reuse/extend the following starter code:
```python
def validate_time(time):
```
|
{"functional": "_inputs = [['1:00'], ['13:1'], ['12:60'], ['12: 60'], ['24:00'], ['00:00'], ['24o:00'], ['24:000'], [''], ['09:00'], ['2400'], ['foo12:00bar'], ['010:00'], ['1;00']]\n_outputs = [[True], [False], [False], [False], [False], [True], [False], [False], [False], [True], [False], [False], [False], [False]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(validate_time(*i), o[0])"}
| 91
| 285
|
coding
|
Solve the programming task below in a Python markdown code block.
Mihai has an $8 \times 8$ chessboard whose rows are numbered from $1$ to $8$ from top to bottom and whose columns are numbered from $1$ to $8$ from left to right.
Mihai has placed exactly one bishop on the chessboard. The bishop is not placed on the edges of the board. (In other words, the row and column of the bishop are between $2$ and $7$, inclusive.)
The bishop attacks in all directions diagonally, and there is no limit to the distance which the bishop can attack. Note that the cell on which the bishop is placed is also considered attacked.
An example of a bishop on a chessboard. The squares it attacks are marked in red.
Mihai has marked all squares the bishop attacks, but forgot where the bishop was! Help Mihai find the position of the bishop.
-----Input-----
The first line of the input contains a single integer $t$ ($1 \leq t \leq 36$) — the number of test cases. The description of test cases follows. There is an empty line before each test case.
Each test case consists of $8$ lines, each containing $8$ characters. Each of these characters is either '#' or '.', denoting a square under attack and a square not under attack, respectively.
-----Output-----
For each test case, output two integers $r$ and $c$ ($2 \leq r, c \leq 7$) — the row and column of the bishop.
The input is generated in such a way that there is always exactly one possible location of the bishop that is not on the edge of the board.
-----Examples-----
Input
3
.....#..
#...#...
.#.#....
..#.....
.#.#....
#...#...
.....#..
......#.
#.#.....
.#......
#.#.....
...#....
....#...
.....#..
......#.
.......#
.#.....#
..#...#.
...#.#..
....#...
...#.#..
..#...#.
.#.....#
#.......
Output
4 3
2 2
4 5
-----Note-----
The first test case is pictured in the statement. Since the bishop lies in the intersection row $4$ and column $3$, the correct output is 4 3.
|
{"inputs": ["3\n\n.....#..\n#...#...\n.#.#....\n..#.....\n.#.#....\n#...#...\n.....#..\n......#.\n\n#.#.....\n.#......\n#.#.....\n...#....\n....#...\n.....#..\n......#.\n.......#\n\n.#.....#\n..#...#.\n...#.#..\n....#...\n...#.#..\n..#...#.\n.#.....#\n#.......\n"], "outputs": ["4 3\n2 2\n4 5\n"]}
| 502
| 136
|
coding
|
Solve the programming task below in a Python markdown code block.
# Personalized greeting
Create a function that gives a personalized greeting. This function takes two parameters: `name` and `owner`.
Use conditionals to return the proper message:
case | return
--- | ---
name equals owner | 'Hello boss'
otherwise | 'Hello guest'
Also feel free to reuse/extend the following starter code:
```python
def greet(name, owner):
```
|
{"functional": "_inputs = [['Daniel', 'Daniel'], ['Greg', 'Daniel']]\n_outputs = [['Hello boss'], ['Hello guest']]\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(greet(*i), o[0])"}
| 93
| 168
|
coding
|
Solve the programming task below in a Python markdown code block.
There are just some things you can't do on television. In this case, you've just come back from having a "delicious" Barth burger and you're set to give an interview. The Barth burger has made you queezy, and you've forgotten some of the import rules of the "You Can't Do That on Television" set.
If you say any of the following words a large bucket of "water" will be dumped on you:
"water", "wet", "wash"
This is true for any form of those words, like "washing", "watered", etc.
If you say any of the following phrases you will be doused in "slime":
"I don't know", "slime"
If you say both in one sentence, a combination of water and slime, "sludge", will be dumped on you.
Write a function, bucketOf(str), that takes a string and determines what will be dumped on your head. If you haven't said anything you shouldn't have, the bucket should be filled with "air". The words should be tested regardless of case.
Examples:
Check out my other 80's Kids Katas:
80's Kids #1: How Many Licks Does It Take
80's Kids #2: Help Alf Find His Spaceship
80's Kids #3: Punky Brewster's Socks
80's Kids #4: Legends of the Hidden Temple
80's Kids #5: You Can't Do That on Television
80's Kids #6: Rock 'Em, Sock 'Em Robots
80's Kids #7: She's a Small Wonder
80's Kids #8: The Secret World of Alex Mack
80's Kids #9: Down in Fraggle Rock
80's Kids #10: Captain Planet
Also feel free to reuse/extend the following starter code:
```python
def bucket_of(said):
```
|
{"functional": "_inputs = [['water'], ['wet'], ['wash'], [\"i don't know\"], ['slime'], ['wet water'], ['slime water'], [\"I don't know if this will work\"], [\"I don't know if this will work without watering it first.\"], [''], ['is there SLIME in that?!'], [\"i won't say anything\"], ['WaTeR?'], ['but i can say sludge?'], [\"i'm just going to wash my hands of this\"], [\"you know what, i don't know what was in that Barth burger\"], ['slimeslimeslimeslimewater'], ['air'], ['w-w-w-w-wet!'], ['wat errrr i mean.. nothing'], ['sludge']]\n_outputs = [['water'], ['water'], ['water'], ['slime'], ['slime'], ['water'], ['sludge'], ['slime'], ['sludge'], ['air'], ['slime'], ['air'], ['water'], ['air'], ['water'], ['slime'], ['sludge'], ['air'], ['water'], ['air'], ['air']]\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(bucket_of(*i), o[0])"}
| 414
| 381
|
coding
|
Solve the programming task below in a Python markdown code block.
You are playing a variation of game 2048. Initially you have a multiset $s$ of $n$ integers. Every integer in this multiset is a power of two.
You may perform any number (possibly, zero) operations with this multiset.
During each operation you choose two equal integers from $s$, remove them from $s$ and insert the number equal to their sum into $s$.
For example, if $s = \{1, 2, 1, 1, 4, 2, 2\}$ and you choose integers $2$ and $2$, then the multiset becomes $\{1, 1, 1, 4, 4, 2\}$.
You win if the number $2048$ belongs to your multiset. For example, if $s = \{1024, 512, 512, 4\}$ you can win as follows: choose $512$ and $512$, your multiset turns into $\{1024, 1024, 4\}$. Then choose $1024$ and $1024$, your multiset turns into $\{2048, 4\}$ and you win.
You have to determine if you can win this game.
You have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 100$) – the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 100$) — the number of elements in multiset.
The second line of each query contains $n$ integers $s_1, s_2, \dots, s_n$ ($1 \le s_i \le 2^{29}$) — the description of the multiset. It is guaranteed that all elements of the multiset are powers of two.
-----Output-----
For each query print YES if it is possible to obtain the number $2048$ in your multiset, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
-----Example-----
Input
6
4
1024 512 64 512
1
2048
3
64 512 2
2
4096 4
7
2048 2 2048 2048 2048 2048 2048
2
2048 4096
Output
YES
YES
NO
NO
YES
YES
-----Note-----
In the first query you can win as follows: choose $512$ and $512$, and $s$ turns into $\{1024, 64, 1024\}$. Then choose $1024$ and $1024$, and $s$ turns into $\{2048, 64\}$ and you win.
In the second query $s$ contains $2048$ initially.
|
{"inputs": ["6\n4\n1024 512 8 512\n1\n2048\n3\n32 512 2\n2\n4096 1\n1\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n64 512 2\n2\n4096 4\n7\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n64 512 2\n2\n4096 4\n1\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n4096\n3\n64 512 2\n2\n4096 4\n7\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n64 512 2\n2\n4096 4\n7\n2048 4 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n64 512 2\n2\n4096 1\n1\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n32 512 2\n2\n4096 1\n1\n2048 2 2048 2048 2048 2048 2048\n2\n2048 4096\n", "6\n4\n1024 512 64 512\n1\n2048\n3\n64 512 2\n2\n4096 4\n7\n2048 8 2048 2048 2048 2048 2048\n2\n2048 4096\n"], "outputs": ["YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nNO\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n", "YES\nYES\nNO\nNO\nYES\nYES\n"]}
| 720
| 877
|
coding
|
Solve the programming task below in a Python markdown code block.
Nickname Generator
Write a function, `nicknameGenerator` that takes a string name as an argument and returns the first 3 or 4 letters as a nickname.
If the 3rd letter is a consonant, return the first 3 letters.
If the 3rd letter is a vowel, return the first 4 letters.
If the string is less than 4 characters, return "Error: Name too short".
**Notes:**
- Vowels are "aeiou", so discount the letter "y".
- Input will always be a string.
- Input will always have the first letter capitalised and the rest lowercase (e.g. Sam).
- The input can be modified
Also feel free to reuse/extend the following starter code:
```python
def nickname_generator(name):
```
|
{"functional": "_inputs = [['Jimmy'], ['Samantha'], ['Sam'], ['Kayne'], ['Melissa'], ['James'], ['Gregory'], ['Jeannie'], ['Kimberly'], ['Timothy'], ['Dani'], ['Saamy'], ['Saemy'], ['Saimy'], ['Saomy'], ['Saumy'], ['Boyna'], ['Kiyna'], ['Sayma'], ['Ni'], ['Jam'], ['Suv']]\n_outputs = [['Jim'], ['Sam'], ['Error: Name too short'], ['Kay'], ['Mel'], ['Jam'], ['Greg'], ['Jean'], ['Kim'], ['Tim'], ['Dan'], ['Saam'], ['Saem'], ['Saim'], ['Saom'], ['Saum'], ['Boy'], ['Kiy'], ['Say'], ['Error: Name too short'], ['Error: Name too short'], ['Error: Name too short']]\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(nickname_generator(*i), o[0])"}
| 176
| 323
|
coding
|
Solve the programming task below in a Python markdown code block.
AtCoDeer the deer recently bought three paint cans.
The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c.
Here, the color of each paint can is represented by an integer between 1 and 100, inclusive.
Since he is forgetful, he might have bought more than one paint can in the same color.
Count the number of different kinds of colors of these paint cans and tell him.
-----Constraints-----
- 1≦a,b,c≦100
-----Input-----
The input is given from Standard Input in the following format:
a b c
-----Output-----
Print the number of different kinds of colors of the paint cans.
-----Sample Input-----
3 1 4
-----Sample Output-----
3
Three different colors: 1, 3, and 4.
|
{"inputs": ["3 2 4", "2 2 2", "3 2 0", "3 4 0", "3 7 0", "8 0 1", "3 7 1", "6 4 0"], "outputs": ["3\n", "1\n", "3\n", "3\n", "3\n", "3\n", "3\n", "3\n"]}
| 201
| 94
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an n x n integer matrix. You can do the following operation any number of times:
Choose any two adjacent elements of matrix and multiply each of them by -1.
Two elements are considered adjacent if and only if they share a border.
Your goal is to maximize the summation of the matrix's elements. Return the maximum sum of the matrix's elements using the operation mentioned above.
Please complete the following python code precisely:
```python
class Solution:
def maxMatrixSum(self, matrix: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(matrix = [[1,-1],[-1,1]]) == 4\n assert candidate(matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]) == 16\n\n\ncheck(Solution().maxMatrixSum)"}
| 130
| 67
|
coding
|
Solve the programming task below in a Python markdown code block.
How many non decreasing sequences are there of length ${K}$, with the condition that numbers in sequence can take values only from $1,2,3,\cdots N$ and gcd of all numbers in the sequence must be ${1}$.
Input Format
The first line contains an integer ${T}$ i.e. the number of test cases.
${T}$ lines follow, each line containing two integers $N$ and ${K}$ separated by a single space.
Output Format
For each testcase, print in a newline the answer $\:\text{mod}\:(10^9+7)$.
Constraints
$1\leq T\leq5$
$1\leq N\leq10^5$
$1\leq K\leq10^5$
Sample Input
4
2 4
3 4
5 2
1 10
Sample Output
4
13
10
1
Explanation
For the first testcase, the sequences are
(1,1,1,1), (1,1,1,2), (1,1,2,2), (1,2,2,2) = 4
For the second testcase, the sequences are
(1,1,1,1), (1,1,1,2), (1,1,1,3), (1,1,2,2), (1,1,2,3), (1,1,3,3)
(1,3,3,3), (1,2,2,2), (1,2,2,3), (1,2,3,3), (2,2,2,3), (2,2,3,3), (2,3,3,3)
which are 13 in number.
For the third testcase, the sequences are
(1,1), (1,2), (1,3), (1,4), (1,5), (2,3), (2,5), (3, 4), (3, 5), (4, 5) = 10
for the fourth testcase, the only sequence is
(1,1,1,1,1,1,1,1,1,1)
|
{"inputs": ["4\n2 4 \n3 4\n5 2\n1 10\n"], "outputs": ["4\n13\n10\n1\n"]}
| 501
| 40
|
coding
|
Solve the programming task below in a Python markdown code block.
A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
-----Input-----
The first line contains two integers n and d (2 ≤ n ≤ 100, 1 ≤ d ≤ n - 1) — the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
-----Output-----
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
-----Examples-----
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
-----Note-----
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.
|
{"inputs": ["2 1\n11\n", "2 1\n11\n", "4 2\n1001\n", "4 2\n1001\n", "5 4\n11011\n", "5 4\n10001\n", "5 4\n11011\n", "5 4\n10001\n"], "outputs": ["1\n", "1\n", "-1\n", "-1\n", "1\n", "1\n", "1\n", "1\n"]}
| 528
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
After the educational reform Polycarp studies only two subjects at school, Safety Studies and PE (Physical Education). During the long months of the fourth term, he received n marks in them. When teachers wrote a mark in the journal, they didn't write in what subject the mark was for, they just wrote the mark.
Now it's time to show the journal to his strict parents. Polycarp knows that recently at the Parent Meeting the parents were told that he received a Safety Studies marks and b PE marks (a + b = n). Now Polycarp wants to write a subject's name in front of each mark so that:
* there are exactly a Safety Studies marks,
* there are exactly b PE marks,
* the total average score in both subjects is maximum.
An average subject grade is the sum of all marks in it, divided by the number of them. Of course, the division is performed in real numbers without rounding up or down. Polycarp aims to maximize the x1 + x2, where x1 is the average score in the first subject (Safety Studies), and x2 is the average score in the second one (Physical Education).
Input
The first line contains an integer n (2 ≤ n ≤ 105), n is the number of marks in Polycarp's Journal. The second line contains two positive integers a, b (1 ≤ a, b ≤ n - 1, a + b = n). The third line contains a sequence of integers t1, t2, ..., tn (1 ≤ ti ≤ 5), they are Polycarp's marks.
Output
Print the sequence of integers f1, f2, ..., fn, where fi (1 ≤ fi ≤ 2) is the number of a subject to which the i-th mark should be attributed. If there are several possible solutions, then print such that the sequence f1, f2, ..., fn is the smallest lexicographically.
The sequence p1, p2, ..., pn is lexicographically less than q1, q2, ..., qn if there exists such j (1 ≤ j ≤ n) that pi = qi for all 1 ≤ i < j, аnd pj < qj.
Examples
Input
5
3 2
4 4 5 4 4
Output
1 1 2 1 2
Input
4
2 2
3 5 4 5
Output
1 1 2 2
Input
6
1 5
4 4 4 5 4 4
Output
2 2 2 1 2 2
Note
In the first sample the average score in the first subject is equal to 4, and in the second one — to 4.5. The total average score is 8.5.
|
{"inputs": ["2\n1 1\n1 2\n", "2\n1 1\n4 4\n", "2\n1 1\n5 1\n", "2\n1 1\n1 1\n", "2\n1 1\n1 0\n", "2\n1 1\n1 3\n", "2\n1 1\n0 4\n", "2\n1 1\n5 0\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"]}
| 608
| 150
|
coding
|
Solve the programming task below in a Python markdown code block.
There are $b$ boys and $g$ girls participating in Olympiad of Metropolises. There will be a board games tournament in the evening and $n$ participants have accepted the invitation. The organizers do not know how many boys and girls are among them.
Organizers are preparing red badges for girls and blue ones for boys.
Vasya prepared $n+1$ decks of badges. The $i$-th (where $i$ is from $0$ to $n$, inclusive) deck contains $i$ blue badges and $n-i$ red ones. The total number of badges in any deck is exactly $n$.
Determine the minimum number of decks among these $n+1$ that Vasya should take, so that there will be a suitable deck no matter how many girls and boys there will be among the participants of the tournament.
-----Input-----
The first line contains an integer $b$ ($1 \le b \le 300$), the number of boys.
The second line contains an integer $g$ ($1 \le g \le 300$), the number of girls.
The third line contains an integer $n$ ($1 \le n \le b + g$), the number of the board games tournament participants.
-----Output-----
Output the only integer, the minimum number of badge decks that Vasya could take.
-----Examples-----
Input
5
6
3
Output
4
Input
5
3
5
Output
4
-----Note-----
In the first example, each of 4 decks should be taken: (0 blue, 3 red), (1 blue, 2 red), (2 blue, 1 red), (3 blue, 0 red).
In the second example, 4 decks should be taken: (2 blue, 3 red), (3 blue, 2 red), (4 blue, 1 red), (5 blue, 0 red). Piles (0 blue, 5 red) and (1 blue, 4 red) can not be used.
|
{"inputs": ["5\n6\n3\n", "5\n3\n5\n", "1\n1\n1\n", "1\n1\n2\n", "3\n3\n4\n", "4\n4\n5\n", "4\n4\n7\n", "3\n3\n5\n"], "outputs": ["4\n", "4\n", "2\n", "1\n", "3\n", "4\n", "2\n", "2\n"]}
| 445
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Pak Chanek plans to build a garage. He wants the garage to consist of a square and a right triangle that are arranged like the following illustration.
Define $a$ and $b$ as the lengths of two of the sides in the right triangle as shown in the illustration. An integer $x$ is suitable if and only if we can construct a garage with assigning positive integer values for the lengths $a$ and $b$ ($a<b$) so that the area of the square at the bottom is exactly $x$. As a good friend of Pak Chanek, you are asked to help him find the $N$-th smallest suitable number.
-----Input-----
The only line contains a single integer $N$ ($1 \leq N \leq 10^9$).
-----Output-----
An integer that represents the $N$-th smallest suitable number.
-----Examples-----
Input
3
Output
7
-----Note-----
The $3$-rd smallest suitable number is $7$. A square area of $7$ can be obtained by assigning $a=3$ and $b=4$.
|
{"inputs": ["3\n", "6\n", "5\n", "8\n", "4\n", "2\n", "1\n", "10\n"], "outputs": ["7\n", "11\n", "9\n", "13\n", "8\n", "5\n", "3\n", "16\n"]}
| 243
| 74
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef likes to play with big numbers. Today, he has a big positive integer N. He can select any two digits from this number (the digits can be same but their positions should be different) and orders them in any one of the two possible ways. For each of these ways, he creates a two digit number from it (might contain leading zeros). Then, he will pick a character corresponding to the ASCII value equal to this number, i.e. the number 65 corresponds to 'A', 66 to 'B' and so on till 90 for 'Z'. Chef is only interested in finding which of the characters in the range 'A' to 'Z' can possibly be picked this way.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The first line of the input contains an integer N.
-----Output-----
For each test case, output a string containing characters Chef can pick in sorted order If the resulting size of string is zero, you should output a new line.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10100000
-----Subtasks-----
- Subtask #1 (40 points) N ≤ 1010
- Subtask #2 (60 points) Original Constraints
-----Example-----
Input:
4
65
566
11
1623455078
Output:
A
AB
ACDFGHIJKLNPQRSTUVW
-----Explanation-----
Example case 1. Chef can pick digits 6 and 5 and create integers 56 and 65. The integer 65 corresponds to 'A'.
Example case 2. Chef can pick digits 6 and 5 and create 'A' as it equals 65. He can pick 6 and 6 (they are picked from position 2 and position 3, respectively) to create 'B' too. Hence answer is "AB".
Example case 3. It's not possible to create any character from 'A' to 'Z'. Hence, we just print a new line.
|
{"inputs": ["4\n65\n566\n11\n1623455078"], "outputs": ["A\nAB\nACDFGHIJKLNPQRSTUVW"]}
| 467
| 45
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a positive integer $x$.
You can apply the following operation to the number: remove one occurrence of any digit in such a way that the resulting number does not contain any leading zeroes and is still a positive integer. For example, $10142$ can be converted to $1142$, $1042$, $1012$ or $1014$ (note that $0142$ is not a valid outcome); $10$ can be converted to $1$ (but not to $0$ since it is not positive).
Your task is to find the minimum positive integer that you can obtain from $x$ if you can apply the aforementioned operation exactly $k$ times.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^5$) — the number of test cases.
The first line of each test case contains a single integer $x$ ($1 \le x < 10^{500000}$).
The second line contains a single integer $k$ ($0 \le k < |x|$), where $|x|$ is the length of the number $x$.
The sum of $|x|$ over all test cases does not exceed $5 \cdot 10^5$.
-----Output-----
For each test case, print one integer — the minimum positive number that you can obtain from $x$ if you can apply the operation exactly $k$ times.
-----Examples-----
Input
5
10000
4
1337
0
987654321
6
66837494128
5
7808652
3
Output
1
1337
321
344128
7052
-----Note-----
None
|
{"inputs": ["5\n10000\n4\n1337\n0\n987654321\n6\n66837494128\n5\n7808652\n3\n"], "outputs": ["1\n1337\n321\n344128\n7052\n"]}
| 417
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
A number, ${x}$, is called irresponsible when adding ${x}$ to $x+1$ requires a carry operation. For example, $5$, $17$, and ${91}$ are irresponsible numbers because adding them to ${6}$, ${18}$, and $92$ (respectively) requires a carry operation:
In $5+(5+1)=5+6=11$, a ${1}$ is carried over into the $10$'s place.
In $17+(17+1)=17+18=35$, a $2$ is carried over into the $10$'s place.
In $91+(91+1)=91+92=183$, a ${1}$ is carried over into the $\left(\begin{array}{c c}{{1}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}&{{0}}\\ {{0}}&{{0}}&{{0}}&{{0}}\\ \end{array}\right).$'s place.
You have two integers, ${x}$ and $n$. Construct a new number, ${s}$, by repeating ${x}$ a total of $n$ times. For example, if $x=3121$ and $n=4$, then $s=3121312131213121$.
Given ${x}$ and $n$, construct ${s}$ and find all the irreponsible numbers between ${1}$ and ${s}$. Then print the number of irresponsible numbers in the aforementioned range; as this number can be quite large, your answer must be modulo $10^9+7$.
Input Format
A single line with two space-separated integers denoting the respective values of ${x}$ and $n$.
Constraints
$1\leq x\leq10^{1,000,000}$
$1\leq n\leq10^{18}$
Subtasks
For $15\%$ of the maximum score:
$1\leq x\leq10^{6}$
$n=1$
For ${40\%}$ of the maximum score:
$1\leq x\leq10^{1,000,000}$
$n=1$
Output Format
Print a single integer denoting the number of irresponsible numbers between ${1}$ and ${s}$, modulo $10^9+7$.
Sample Input
1 2
Sample Output
4
Explanation
When we repeat $x=1$ a total of $n=2$ times we get ${11}$. The irresponsible numbers between ${1}$ and ${11}$ are $5$, ${6}$, $7$, and $8$. Because there are four irresponsible numbers, we print $4\times(10^9+7)=4$ on a new line.
|
{"inputs": ["1 2\n"], "outputs": ["4\n"]}
| 711
| 16
|
coding
|
Solve the programming task below in a Python markdown code block.
A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
-----Input-----
The first line of the input contains an integer $t$ ($1 \leq t \leq 10^3$) — the number of testcases.
The description of each test consists of one line containing one string consisting of six digits.
-----Output-----
Output $t$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise.
You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
-----Examples-----
Input
5
213132
973894
045207
000000
055776
Output
YES
NO
YES
YES
NO
-----Note-----
In the first test case, the sum of the first three digits is $2 + 1 + 3 = 6$ and the sum of the last three digits is $1 + 3 + 2 = 6$, they are equal so the answer is "YES".
In the second test case, the sum of the first three digits is $9 + 7 + 3 = 19$ and the sum of the last three digits is $8 + 9 + 4 = 21$, they are not equal so the answer is "NO".
In the third test case, the sum of the first three digits is $0 + 4 + 5 = 9$ and the sum of the last three digits is $2 + 0 + 7 = 9$, they are equal so the answer is "YES".
|
{"inputs": ["1\n114514\n", "1\n975310\n", "1\n666999\n", "1\n975319\n", "2\n193758\n123456\n", "2\n192758\n123456\n", "5\n213132\n973894\n045207\n000000\n055776\n"], "outputs": ["NO\n", "NO\n", "NO\n", "NO\n", "NO\nNO\n", "NO\nNO\n", "YES\nNO\nYES\nYES\nNO\n"]}
| 428
| 165
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef just got a box of chocolates as his birthday gift. The box contains $N$ chocolates in a row (numbered $1$ through $N$), where $N$ is even. For each valid $i$, the $i$-th chocolate has a sweetness value $W_i$.
Chef wants to eat all the chocolates in the first half of the box and leave all chocolates in the second half uneaten. Since he does not like chocolates that are too sweet, he will be unhappy if at least one of the chocolates he eats has the maximum sweetness among all the chocolates in the box.
A right cyclic shift by $k$ chocolates ($0 \le k < N$) consists of moving the last $k$ chocolates in the row to the beginning in the same order and moving each of the remaining $N-k$ chocolates $k$ places to the right. Before eating the first half of the chocolates, Chef wants to perform some right cyclic shift in such a way that he will not be unhappy after eating them. Find the number of ways to do this, i.e. the number of valid integers $k$ such that if Chef performs the right cyclic shift by $k$ chocolates and then eats the first half of the chocolates in the box, he does not become unhappy.
-----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 $W_1, W_2, \ldots, W_N$.
-----Output-----
For each test case, print a single line containing one integer ― the number of shifts for which Chef does not become unhappy.
-----Constraints-----
- $1 \le T \le 5$
- $1 \le N \le 10^5$
- $N$ is even
- $1 \le W_i \le 10^5$ for each valid $i$
-----Example Input-----
2
6
1 1 2 1 1 1
6
1 1 2 1 1 2
-----Example Output-----
3
0
-----Explanation-----
Example case 1: The three valid right shifts and the contents of the box for these shifts are:
- shift by $k = 1$: $(1, 1, 1, 2, 1, 1)$
- shift by $k = 2$: $(1, 1, 1, 1, 2, 1)$
- shift by $k = 3$: $(1, 1, 1, 1, 1, 2)$
|
{"inputs": ["2\n6\n1 1 2 1 1 1\n6\n1 1 2 1 1 2"], "outputs": ["3\n0"]}
| 588
| 42
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given three words s_1, s_2 and s_3, each composed of lowercase English letters, with spaces in between.
Print the acronym formed from the uppercased initial letters of the words.
-----Constraints-----
- s_1, s_2 and s_3 are composed of lowercase English letters.
- 1 ≤ |s_i| ≤ 10 (1≤i≤3)
-----Input-----
Input is given from Standard Input in the following format:
s_1 s_2 s_3
-----Output-----
Print the answer.
-----Sample Input-----
atcoder beginner contest
-----Sample Output-----
ABC
The initial letters of atcoder, beginner and contest are a, b and c. Uppercase and concatenate them to obtain ABC.
|
{"inputs": ["k nearest robhgien", "k tseraen robhgien", "l tseraeo robhgien", "l oearest robghien", "l oearest neihgbor", "l pearest neihgbor", "m pearest neihgbor", "m tseraep neihgbor"], "outputs": ["KNR\n", "KTR\n", "LTR\n", "LOR\n", "LON\n", "LPN\n", "MPN\n", "MTN\n"]}
| 171
| 118
|
coding
|
Solve the programming task below in a Python markdown code block.
There is a kangaroo at coordinate 0 on an infinite number line that runs from left to right, at time 0. During the period between time i-1 and time i, the kangaroo can either stay at his position, or perform a jump of length exactly i to the left or to the right. That is, if his coordinate at time i-1 is x, he can be at coordinate x-i, x or x+i at time i. The kangaroo's nest is at coordinate X, and he wants to travel to coordinate X as fast as possible. Find the earliest possible time to reach coordinate X.
Constraints
* X is an integer.
* 1≤X≤10^9
Input
The input is given from Standard Input in the following format:
X
Output
Print the earliest possible time for the kangaroo to reach coordinate X.
Examples
Input
6
Output
3
Input
2
Output
2
Input
11
Output
5
|
{"inputs": ["4", "1", "3", "6", "2", "12", "19", "24"], "outputs": ["3\n", "1\n", "2\n", "3", "2", "5\n", "6\n", "7\n"]}
| 217
| 63
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a set of all integers from $l$ to $r$ inclusive, $l < r$, $(r - l + 1) \le 3 \cdot 10^5$ and $(r - l)$ is always odd.
You want to split these numbers into exactly $\frac{r - l + 1}{2}$ pairs in such a way that for each pair $(i, j)$ the greatest common divisor of $i$ and $j$ is equal to $1$. Each number should appear in exactly one of the pairs.
Print the resulting pairs or output that no solution exists. If there are multiple solutions, print any of them.
-----Input-----
The only line contains two integers $l$ and $r$ ($1 \le l < r \le 10^{18}$, $r - l + 1 \le 3 \cdot 10^5$, $(r - l)$ is odd).
-----Output-----
If any solution exists, print "YES" in the first line. Each of the next $\frac{r - l + 1}{2}$ lines should contain some pair of integers. GCD of numbers in each pair should be equal to $1$. All $(r - l + 1)$ numbers should be pairwise distinct and should have values from $l$ to $r$ inclusive.
If there are multiple solutions, print any of them.
If there exists no solution, print "NO".
-----Example-----
Input
1 8
Output
YES
2 7
4 1
3 8
6 5
|
{"inputs": ["1 8\n", "1 2\n", "2 3\n", "4 9\n", "3 6\n", "2 7\n", "2 7\n", "1 2\n"], "outputs": ["YES\n1 2\n3 4\n5 6\n7 8\n", "YES\n1 2\n", "YES\n2 3\n", "YES\n4 5\n6 7\n8 9\n", "YES\n3 4\n5 6\n", "YES\n2 3\n4 5\n6 7\n", "YES\n2 3\n4 5\n6 7\n", "YES\n1 2\n"]}
| 344
| 158
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given $n$ dominoes. Each domino has a left and a right cell. Each cell can be colored either black or white. Some cells are already colored, while some aren't yet.
The coloring is said to be valid if and only if it is possible to rearrange the dominoes in some order such that for each $1 \le i \le n$ the color of the right cell of the $i$-th domino is different from the color of the left cell of the $((i mod n)+1)$-st domino.
Note that you can't rotate the dominoes, so the left cell always remains the left cell, and the right cell always remains the right cell.
Count the number of valid ways to color the yet uncolored cells of dominoes. Two ways are considered different if there is a cell that is colored white in one way and black in the other. In particular, colorings BW WB and WB BW different (and both invalid).
As this number can be very big, output it modulo $998\,244\,353$.
-----Input-----
The first line of the input contains a single integer $n$ ($1 \le n \le 10^5$) — the number of dominoes.
The next $n$ lines describe dominoes. Each line contains two characters which represent the left and the right cell. Character B means that the corresponding cell is black, character W means that the corresponding cell is white, and ? means that the cell is yet to be colored.
-----Output-----
Print a single integer — the answer to the problem.
-----Examples-----
Input
1
?W
Output
1
Input
2
??
W?
Output
2
Input
4
BB
??
W?
??
Output
10
-----Note-----
In the first test case, there is only one domino, and we need the color of its right cell to be different from the color of its left cell. There is only one way to achieve this.
In the second test case, there are only $2$ such colorings:
BB WW and WB WB.
|
{"inputs": ["1\n?W\n", "1\nW?\n", "1\n?W\n", "2\n??\nW?\n", "2\n??\n?W\n", "2\n??\nW?\n", "4\nBB\n??\nW?\n??\n", "4\nBB\n??\n?W\n??\n"], "outputs": ["1\n", "1\n", "1", "2\n", "2\n", "2", "10\n", "10\n"]}
| 467
| 119
|
coding
|
Solve the programming task below in a Python markdown code block.
Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.
Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.
We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.
Clearly there cannot be any bouncy numbers below one-hundred, but just over half of the numbers below one-thousand (525) are bouncy. In fact, the least number for which the proportion of bouncy numbers first reaches 50% is 538.
Surprisingly, bouncy numbers become more and more common and by the time we reach 21780 the proportion of bouncy numbers is equal to 90%.
#### Your Task
Complete the bouncyRatio function.
The input will be the target ratio.
The output should be the smallest number such that the proportion of bouncy numbers reaches the target ratio.
You should throw an Error for a ratio less than 0% or greater than 99%.
**Source**
- https://projecteuler.net/problem=112
**Updates**
- 26/10/2015: Added a higher precision test case.
Also feel free to reuse/extend the following starter code:
```python
def bouncy_ratio(percent):
```
|
{"functional": "_inputs = [[0.1], [0.15], [0.5], [0.75], [0.9]]\n_outputs = [[132], [160], [538], [3088], [21780]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(bouncy_ratio(*i), o[0])"}
| 323
| 204
|
coding
|
Solve the programming task below in a Python markdown code block.
A: IP Address (Internet Protocol Address)
problem
Since one number string is given, find the number of valid delimiters for IPv4 IP addresses. However, the effective delimiters for IPv4 IP addresses are as follows.
* The sequence of numbers is divided into four, and each of the separated columns satisfies all of the following.
* Not an empty string.
* When read as a decimal number, it is an integer between 0 and 255.
* If the number is 0, then the column is `0` (` 00` etc. are not allowed).
* If the number is non-zero, the first digit is not `0` (`01` etc. are not allowed).
Input format
S
Constraint
* 4 \ leq | S | \ leq 12
* S contains only numbers.
Output format
Output the number on one line according to the valid delimiter.
Input example 1
123456789
Output example 1
1
There is one valid delimiter, `123.45.67.89`.
Input example 2
768426
Output example 2
6
Example
Input
123456789
Output
1
|
{"inputs": ["17", "15", "14", "25", "16", "59", "13", "30"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 282
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
A: Information Search
problem
The posting list is a list in which there is a correspondence between the search term and the appearing document ID. For example
* Hokkaido: 1, 2, 4, 9
* Sightseeing: 1, 3, 4, 7
And so on.
From the above posting list, if you search for and, the document with ID 1, 4 will be hit, and if you search for or, ID 1, 2, 3, 4, 7, 9 will be hit.
Here, and search means "listing elements contained in either list", or search means "listing elements contained in at least one of the lists".
Since the posting list is given, output the results of and search and or search respectively.
Input format
n m
a_1 a_2 $ \ ldots $ a_n
b_1 b_2 $ \ ldots $ b_m
All inputs consist of integers.
The first line gives the lengths n and m of the two posting lists to search, separated by spaces.
The second and third lines are given the IDs contained in their respective posting lists, separated by blanks.
Constraint
* 1 \ leq n, m \ leq 2 \ times 10 ^ 5
* a_i <a_j (i <j)
* b_i <b_j (i <j)
* 1 \ leq a_i, b_i \ leq 10 ^ 9
Output format
Let A be the number of hits in the and search, and B be the number of hits in the or search.
Print on the first line in the order A B, separated by blanks.
Output the IDs hit by and search on the following line A in ascending order.
Output the IDs hit by or search on the following B line in ascending order.
Input example 1
4 4
1 2 4 9
1 3 4 7
Output example 1
2 6
1
Four
1
2
3
Four
7
9
Input example 2
4 4
1 3 5 7
2 4 6 8
Output example 2
0 8
1
2
3
Four
Five
6
7
8
Input example 3
3 5
one two Three
1 2 3 4 5
Output example 3
3 5
1
2
3
1
2
3
Four
Five
Example
Input
4 4
1 2 4 9
1 3 4 7
Output
2 6
1
4
1
2
3
4
7
9
|
{"inputs": ["4 4\n1 2 5 9\n1 3 4 7", "4 4\n1 2 5 9\n2 3 4 7", "4 4\n1 2 4 9\n0 3 4 7", "4 4\n1 2 5 9\n0 3 4 7", "4 4\n1 3 5 9\n0 3 4 7", "4 4\n1 2 5 9\n1 2 4 7", "4 4\n1 2 5 9\n1 3 4 8", "4 4\n1 2 7 9\n0 3 4 7"], "outputs": ["1 7\n1\n1\n2\n3\n4\n5\n7\n9\n", "1 7\n2\n1\n2\n3\n4\n5\n7\n9\n", "1 7\n4\n0\n1\n2\n3\n4\n7\n9\n", "0 8\n0\n1\n2\n3\n4\n5\n7\n9\n", "1 7\n3\n0\n1\n3\n4\n5\n7\n9\n", "2 6\n1\n2\n1\n2\n4\n5\n7\n9\n", "1 7\n1\n1\n2\n3\n4\n5\n8\n9\n", "1 7\n7\n0\n1\n2\n3\n4\n7\n9\n"]}
| 599
| 350
|
coding
|
Solve the programming task below in a Python markdown code block.
Given the number pledged for a year, current value and name of the month, return string that gives information about the challenge status:
- ahead of schedule
- behind schedule
- on track
- challenge is completed
Examples:
`(12, 1, "February")` - should return `"You are on track."`
`(12, 1, "March")` - should return `"You are 1 behind schedule."`
`(12, 5, "March")` - should return `"You are 3 ahead of schedule."`
`(12, 12, "September")` - should return `"Challenge is completed."`
Details:
- you do not need to do any prechecks (input will always be a natural number and correct name of the month)
- months should be as even as possible (i.e. for 100 items: January, February, March and April - 9, other months 8)
- count only the item for completed months (i.e. for March check the values from January and February) and it means that for January you should always return `"You are on track."`.
Also feel free to reuse/extend the following starter code:
```python
def check_challenge(pledged, current, month):
```
|
{"functional": "_inputs = [[12, 5, 'January'], [12, 1, 'February'], [12, 1, 'March'], [12, 12, 'September'], [12, 5, 'March'], [100, 5, 'March'], [100, 52, 'July'], [100, 51, 'July'], [100, 53, 'July']]\n_outputs = [['You are on track.'], ['You are on track.'], ['You are 1 behind schedule.'], ['Challenge is completed.'], ['You are 3 ahead of schedule!'], ['You are 13 behind schedule.'], ['You are on track.'], ['You are 1 behind schedule.'], ['You are 1 ahead of schedule!']]\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(check_challenge(*i), o[0])"}
| 276
| 321
|
coding
|
Solve the programming task below in a Python markdown code block.
For any positive integer, we define a digit rotation as either moving the first digit
to the end of the number (left digit rotation), or the last digit to the front of the number (right digit rotation).
For example, the number 12345 could be left digit rotated to 23451, or right digit rotated to 51234.
If there are any leading zeros after digit rotation, they must be removed.
So 10203 could be left digit rotated to 2031, then left digit rotated again to 312.
Given an integer N, determine the largest integer that can result from performing a series of one or more
digit rotations on N.
------ Input ------
Input will begin with an integer T (at most 1000), the number of test cases.
Each test case consists of a positive integer N<100000000 (10^{8}) on a line by itself.
------ Output ------
For each test case, print the largest integer that can result from performing one or more
digit rotations on N.
----- Sample Input 1 ------
6
12345
54321
10901
211011
7
90
----- Sample Output 1 ------
51234
54321
11090
211011
7
9
|
{"inputs": ["6\n2528\n18211\n575\n268\n1\n257", "6\n4360\n18211\n575\n268\n1\n257", "6\n4360\n18211\n575\n268\n1\n443", "6\n4360\n18211\n575\n268\n1\n145", "6\n5788\n18211\n575\n268\n1\n145", "6\n5788\n32221\n575\n268\n1\n145", "6\n1689\n7692\n14761\n5838\n3\n68", "6\n1689\n7692\n14761\n8668\n3\n68"], "outputs": ["8252\n82111\n755\n826\n1\n725\n", "6043\n82111\n755\n826\n1\n725\n", "6043\n82111\n755\n826\n1\n443\n", "6043\n82111\n755\n826\n1\n514\n", "8857\n82111\n755\n826\n1\n514\n", "8857\n32221\n755\n826\n1\n514\n", "9168\n9276\n76114\n8583\n3\n86\n", "9168\n9276\n76114\n8866\n3\n86\n"]}
| 321
| 450
|
coding
|
Solve the programming task below in a Python markdown code block.
I, Fischl, Prinzessin der Verurteilung, descend upon this land by the call of fate an — Oh, you are also a traveler from another world? Very well, I grant you permission to travel with me.
It is no surprise Fischl speaks with a strange choice of words. However, this time, not even Oz, her raven friend, can interpret her expressions! Maybe you can help us understand what this young princess is saying?
You are given a string of n lowercase Latin letters, the word that Fischl just spoke. You think that the MEX of this string may help you find the meaning behind this message. The MEX of the string is defined as the shortest string that doesn't appear as a contiguous substring in the input. If multiple strings exist, the lexicographically smallest one is considered the MEX. Note that the empty substring does NOT count as a valid MEX.
A string a is lexicographically smaller than a string b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.
A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
Find out what the MEX of the string is!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 1000) — the length of the word. The second line for each test case contains a single string of n lowercase Latin letters.
The sum of n over all test cases will not exceed 1000.
Output
For each test case, output the MEX of the string on a new line.
Example
Input
3
28
qaabzwsxedcrfvtgbyhnujmiklop
13
cleanairactbd
10
aannttoonn
Output
ac
f
b
|
{"inputs": ["1\n25\nabcdefghijklmnopqrstuvwxy\n", "1\n25\nyxwvutsrqponmlkjihgfedcba\n", "1\n25\nabcdefghijklmnooqrstuvwxy\n", "1\n25\nyxwvutrrqponmlkjihgfedcba\n", "1\n25\nyxwvutsrlponmqkjihgfedcba\n", "1\n41\nsugimotomikasaackermannelectromasterjsoap\n", "1\n41\nsugimotomikasaacjermannelectromasterjsoap\n", "1\n21\nsugimotomikasaacjermbjnelectromasterosoap\n"], "outputs": ["z\n", "z\n", "p\n", "s\n", "z\n", "b\n", "b\n", "d\n"]}
| 498
| 198
|
coding
|
Solve the programming task below in a Python markdown code block.
-----Problem Statement-----
A classroom has several students, half of whom are boys and half of whom are girls. You need to arrange all of them in a line for the morning assembly such that the following conditions are satisfied:
- The students must be in order of non-decreasing height.
- Two boys or two girls must not be adjacent to each other.
You have been given the heights of the boys in the array $b$ and the heights of the girls in the array $g$. Find out whether you can arrange them in an order which satisfies the given conditions. Print "YES" if it is possible, or "NO" if it is not.
For example, let's say there are $n = 3$ boys and $n = 3$ girls, where the boys' heights are $b = [5, 3, 8]$ and the girls' heights are $g = [2, 4, 6]$. These students can be arranged in the order $[g_0, b_1, g_1, b_0, g_2, b_2]$, which is $[2, 3, 4, 5, 6, 8]$. Because this is in order of non-decreasing height, and no two boys or two girls are adjacent to each other, this satisfies the conditions. Therefore, the answer is "YES".
-----Input-----
- The first line contains an integer, $t$, denoting the number of test cases.
- The first line of each test case contains an integer, $n$, denoting the number of boys and girls in the classroom.
- The second line of each test case contains $n$ space separated integers, $b_1,b_2, ... b_n$, denoting the heights of the boys.
- The second line of each test case contains $n$ space separated integers, $g_1,g_2,... g_n$, denoting the heights of the girls.
-----Output-----
Print exactly $t$ lines. In the $i^{th}$ of them, print a single line containing "$YES$" without quotes if it is possible to arrange the students in the $i^{th}$ test case, or "$NO$" without quotes if it is not.
-----Constraints-----
- $1 \leq t \leq 10$
- $1 \leq n \leq 100$
- $1 \leq b_i, g_i \leq 100$
-----Sample Input-----
1
2
1 3
2 4
-----Sample Output-----
YES
-----EXPLANATION-----
The following arrangement would satisfy the given conditions: $[b_1, g_1, b_2, g_2]$. This is because the boys and girls and separated, and the height is in non-decreasing order.
|
{"inputs": ["1\n2\n1 3\n2 4"], "outputs": ["YES"]}
| 605
| 22
|
coding
|
Solve the programming task below in a Python markdown code block.
Mark is asked to take a group photo of $2n$ people. The $i$-th person has height $h_i$ units.
To do so, he ordered these people into two rows, the front row and the back row, each consisting of $n$ people. However, to ensure that everyone is seen properly, the $j$-th person of the back row must be at least $x$ units taller than the $j$-th person of the front row for each $j$ between $1$ and $n$, inclusive.
Help Mark determine if this is possible.
-----Input-----
The first line contains one integer $t$ ($1\leq t\leq 100$) — the number of test cases. Each test case consists of two lines.
The first line of each test case contains two positive integers $n$ and $x$ ($1\leq n\leq 100$, $1\leq x\leq 10^3$) — the number of people in each row and the minimum difference Mark wants.
The second line of each test case contains $2n$ positive integers $h_1,h_2,\ldots,h_{2n}$ ($1\leq h_i\leq 10^3$) — the height of each person in units.
Note that the sum of $n$ over all test cases is not bounded.
-----Output-----
For each test case, print a single line containing "YES" if Mark could arrange people satisfying his condition and "NO" otherwise.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answers).
-----Examples-----
Input
3
3 6
1 3 9 10 12 16
3 1
2 5 2 2 2 5
1 2
8 6
Output
YES
NO
YES
-----Note-----
In the first test case, one possible order is to have the third, fifth, and sixth person on the back row and the second, first, and fourth on the front row. The heights of the people will look like this.
Back
$9$
$12$
$16$
Front
$3$
$1$
$10$
It works because
$h_3-h_2 = 9-3 \geq 6$,
$h_5-h_1 = 12-1\geq 6$, and
$h_6-h_4 = 16-10\geq 6$.
In the second test case, it can be shown there is no way to order people in a way that satisfies the condition.
In the third test case, the only way to arrange people to satisfy the condition is to have the first person on the back row and the second person on the front row.
|
{"inputs": ["3\n3 6\n1 3 9 10 12 16\n3 1\n2 5 2 2 2 5\n1 2\n8 6\n"], "outputs": ["YES\nNO\nYES\n"]}
| 625
| 61
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in [Hindi], [Mandarin Chinese], [Russian], [Vietnamese], and [Bengali] as well.
You are given a range of integers $\{L, L+1, \ldots, R\}$. An integer $X$ is said to be *reachable* if it can be represented as a sum of two not necessarily distinct integers in this range. Find the number of distinct reachable integers.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first and only line of each test case contains two space-separated integers $L$ and $R$.
------ Output ------
For each test case, print a single line containing one integer — the number of reachable integers.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ L ≤ R ≤ 10^{6}$
----- Sample Input 1 ------
2
2 2
2 3
----- Sample Output 1 ------
1
3
----- explanation 1 ------
Example case 1: The only reachable integer is $2 + 2 = 4$.
Example case 2: $4$, $5$ and $6$ are reachable, since $2+2=4$, $2+3=5$ and $3+3=6$.
|
{"inputs": ["2\n2 2\n2 3"], "outputs": ["1\n3"]}
| 312
| 22
|
coding
|
Solve the programming task below in a Python markdown code block.
Pasha has two hamsters: Arthur and Alexander. Pasha put n apples in front of them. Pasha knows which apples Arthur likes. Similarly, Pasha knows which apples Alexander likes. Pasha doesn't want any conflict between the hamsters (as they may like the same apple), so he decided to distribute the apples between the hamsters on his own. He is going to give some apples to Arthur and some apples to Alexander. It doesn't matter how many apples each hamster gets but it is important that each hamster gets only the apples he likes. It is possible that somebody doesn't get any apples.
Help Pasha distribute all the apples between the hamsters. Note that Pasha wants to distribute all the apples, not just some of them.
-----Input-----
The first line contains integers n, a, b (1 ≤ n ≤ 100; 1 ≤ a, b ≤ n) — the number of apples Pasha has, the number of apples Arthur likes and the number of apples Alexander likes, correspondingly.
The next line contains a distinct integers — the numbers of the apples Arthur likes. The next line contains b distinct integers — the numbers of the apples Alexander likes.
Assume that the apples are numbered from 1 to n. The input is such that the answer exists.
-----Output-----
Print n characters, each of them equals either 1 or 2. If the i-h character equals 1, then the i-th apple should be given to Arthur, otherwise it should be given to Alexander. If there are multiple correct answers, you are allowed to print any of them.
-----Examples-----
Input
4 2 3
1 2
2 3 4
Output
1 1 2 2
Input
5 5 2
3 4 1 2 5
2 3
Output
1 1 1 1 1
|
{"inputs": ["1 1 1\n1\n1\n", "2 1 1\n2\n1\n", "2 1 1\n1\n2\n", "2 1 1\n2\n1\n", "1 1 1\n1\n1\n", "2 1 1\n1\n2\n", "1 1 0\n1\n1\n", "1 1 0\n1\n0\n"], "outputs": ["1\n", "2 1\n", "1 2\n", "2 1 ", "1 ", "1 2 ", "1\n", "1\n"]}
| 406
| 139
|
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 tasks, where tasks[i] represents the difficulty level of a task. In each round, you can complete either 2 or 3 tasks of the same difficulty level.
Return the minimum rounds required to complete all the tasks, or -1 if it is not possible to complete all the tasks.
Please complete the following python code precisely:
```python
class Solution:
def minimumRounds(self, tasks: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(tasks = [2,2,3,3,2,4,4,4,4,4]) == 4\n assert candidate(tasks = [2,3,3]) == -1\n\n\ncheck(Solution().minimumRounds)"}
| 118
| 66
|
coding
|
Solve the programming task below in a Python markdown code block.
*Chef has recently introduced a [feature] which allows you to open any user’s submitted code (not just your own), and ask an AI to explain that code in English. For example, you can go to https://www.codechef.com/viewsolution/70530506 and click on "Analyse This Code".*
But there is a restriction that the feature works only on codes which are at most 1000 characters long. Given the number of characters, C, in a particular code, output whether the feature is available on this code or not.
------ Input Format ------
The only line of input will contain a single integer C, denoting the number of characters in the code.
------ Output Format ------
Output a single line which contains either "Yes", if the feature is available on this code, or "No", if not.
You may print each character of the string in either uppercase or lowercase (for example, the strings NO, nO, No, and no will all be treated as identical).
------ Constraints ------
$1 ≤ C ≤ 10000$
----- Sample Input 1 ------
50
----- Sample Output 1 ------
Yes
----- explanation 1 ------
The code's length is only $50$, and $50 ≤ 1000$. So, the feature is available, and the answer is "Yes".
----- Sample Input 2 ------
1000
----- Sample Output 2 ------
Yes
----- explanation 2 ------
The code's length is $1000$, and $1000 ≤ 1000$. So, the feature is available, and the answer is "Yes".
----- Sample Input 3 ------
1001
----- Sample Output 3 ------
No
----- explanation 3 ------
The code's length is $1001$, and $1001 \nleq 1000$. So, the feature is not available, and the answer is "No".
|
{"inputs": ["50\n", "1000\n", "1001\n"], "outputs": ["Yes", "Yes", "No"]}
| 435
| 34
|
coding
|
Solve the programming task below in a Python markdown code block.
Petya loves hockey very much. One day, as he was watching a hockey match, he fell asleep. Petya dreamt of being appointed to change a hockey team's name. Thus, Petya was given the original team name w and the collection of forbidden substrings s1, s2, ..., sn. All those strings consist of uppercase and lowercase Latin letters. String w has the length of |w|, its characters are numbered from 1 to |w|.
First Petya should find all the occurrences of forbidden substrings in the w string. During the search of substrings the case of letter shouldn't be taken into consideration. That is, strings "aBC" and "ABc" are considered equal.
After that Petya should perform the replacement of all letters covered by the occurrences. More formally: a letter in the position i should be replaced by any other one if for position i in string w there exist pair of indices l, r (1 ≤ l ≤ i ≤ r ≤ |w|) such that substring w[l ... r] is contained in the collection s1, s2, ..., sn, when using case insensitive comparison. During the replacement the letter's case should remain the same. Petya is not allowed to replace the letters that aren't covered by any forbidden substring.
Letter letter (uppercase or lowercase) is considered lucky for the hockey players. That's why Petya should perform the changes so that the letter occurred in the resulting string as many times as possible. Help Petya to find such resulting string. If there are several such strings, find the one that comes first lexicographically.
Note that the process of replacements is not repeated, it occurs only once. That is, if after Petya's replacements the string started to contain new occurrences of bad substrings, Petya pays no attention to them.
Input
The first line contains the only integer n (1 ≤ n ≤ 100) — the number of forbidden substrings in the collection. Next n lines contain these substrings. The next line contains string w. All those n + 1 lines are non-empty strings consisting of uppercase and lowercase Latin letters whose length does not exceed 100. The last line contains a lowercase letter letter.
Output
Output the only line — Petya's resulting string with the maximum number of letters letter. If there are several answers then output the one that comes first lexicographically.
The lexicographical comparison is performed by the standard < operator in modern programming languages. The line a is lexicographically smaller than the line b, if a is a prefix of b, or there exists such an i (1 ≤ i ≤ |a|), that ai < bi, and for any j (1 ≤ j < i) aj = bj. |a| stands for the length of string a.
Examples
Input
3
bers
ucky
elu
PetrLoveLuckyNumbers
t
Output
PetrLovtTttttNumtttt
Input
4
hello
party
abefglghjdhfgj
IVan
petrsmatchwin
a
Output
petrsmatchwin
Input
2
aCa
cba
abAcaba
c
Output
abCacba
|
{"inputs": ["3\na\nA\na\nA\nb\n", "3\na\nA\na\nA\na\n", "3\na\nA\nb\nA\nb\n", "3\na\nA\nb\nB\na\n", "3\na\nA\na\nB\na\n", "3\nb\nA\nb\nA\nb\n", "3\nab\nBa\naB\nABBA\nl\n", "3\nab\nBa\naB\nABBA\na\n"], "outputs": ["B\n", "B\n", "B\n", "A\n", "B\n", "B\n", "LLLL\n", "BAAB\n"]}
| 693
| 155
|
coding
|
Solve the programming task below in a Python markdown code block.
Recently Vasya found a golden ticket — a sequence which consists of $n$ digits $a_1a_2\dots a_n$. Vasya considers a ticket to be lucky if it can be divided into two or more non-intersecting segments with equal sums. For example, ticket $350178$ is lucky since it can be divided into three segments $350$, $17$ and $8$: $3+5+0=1+7=8$. Note that each digit of sequence should belong to exactly one segment.
Help Vasya! Tell him if the golden ticket he found is lucky or not.
-----Input-----
The first line contains one integer $n$ ($2 \le n \le 100$) — the number of digits in the ticket.
The second line contains $n$ digits $a_1 a_2 \dots a_n$ ($0 \le a_i \le 9$) — the golden ticket. Digits are printed without spaces.
-----Output-----
If the golden ticket is lucky then print "YES", otherwise print "NO" (both case insensitive).
-----Examples-----
Input
5
73452
Output
YES
Input
4
1248
Output
NO
-----Note-----
In the first example the ticket can be divided into $7$, $34$ and $52$: $7=3+4=5+2$.
In the second example it is impossible to divide ticket into segments with equal sum.
|
{"inputs": ["2\n00\n", "2\n44\n", "2\n55\n", "2\n02\n", "2\n36\n", "2\n11\n", "2\n00\n", "2\n55\n"], "outputs": ["YES\n", "YES\n", "YES\n", "NO\n", "NO\n", "YES\n", "YES\n", "YES\n"]}
| 334
| 94
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given two string arrays words1 and words2.
A string b is a subset of string a if every letter in b occurs in a including multiplicity.
For example, "wrr" is a subset of "warrior" but is not a subset of "world".
A string a from words1 is universal if for every string b in words2, b is a subset of a.
Return an array of all the universal strings in words1. You may return the answer in any order.
Please complete the following python code precisely:
```python
class Solution:
def wordSubsets(self, words1: List[str], words2: List[str]) -> List[str]:
```
|
{"functional": "def check(candidate):\n assert candidate(words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"e\",\"o\"]) == [\"facebook\",\"google\",\"leetcode\"]\n assert candidate(words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"l\",\"e\"]) == [\"apple\",\"google\",\"leetcode\"]\n assert candidate(words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"e\",\"oo\"]) == [\"facebook\",\"google\"]\n assert candidate(words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"lo\",\"eo\"]) == [\"google\",\"leetcode\"]\n assert candidate(words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"ec\",\"oc\",\"ceo\"]) == [\"facebook\",\"leetcode\"]\n\n\ncheck(Solution().wordSubsets)"}
| 159
| 217
|
coding
|
Solve the programming task below in a Python markdown code block.
Jeff has become friends with Furik. Now these two are going to play one quite amusing game.
At the beginning of the game Jeff takes a piece of paper and writes down a permutation consisting of n numbers: p1, p2, ..., pn. Then the guys take turns to make moves, Jeff moves first. During his move, Jeff chooses two adjacent permutation elements and then the boy swaps them. During his move, Furic tosses a coin and if the coin shows "heads" he chooses a random pair of adjacent elements with indexes i and i + 1, for which an inequality pi > pi + 1 holds, and swaps them. But if the coin shows "tails", Furik chooses a random pair of adjacent elements with indexes i and i + 1, for which the inequality pi < pi + 1 holds, and swaps them. If the coin shows "heads" or "tails" and Furik has multiple ways of adjacent pairs to take, then he uniformly takes one of the pairs. If Furik doesn't have any pair to take, he tosses a coin one more time. The game ends when the permutation is sorted in the increasing order.
Jeff wants the game to finish as quickly as possible (that is, he wants both players to make as few moves as possible). Help Jeff find the minimum mathematical expectation of the number of moves in the game if he moves optimally well.
You can consider that the coin shows the heads (or tails) with the probability of 50 percent.
Input
The first line contains integer n (1 ≤ n ≤ 3000). The next line contains n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation p. The numbers are separated by spaces.
Output
In a single line print a single real value — the answer to the problem. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
2
1 2
Output
0.000000
Input
5
3 5 2 4 1
Output
13.000000
Note
In the first test the sequence is already sorted, so the answer is 0.
|
{"inputs": ["2\n2 1\n", "2\n1 2\n", "5\n2 3 4 5 1\n", "5\n2 3 5 4 1\n", "5\n3 5 1 4 2\n", "5\n3 5 2 4 1\n", "9\n4 1 8 6 7 5 2 9 3\n", "9\n1 7 8 5 3 4 6 9 2\n"], "outputs": ["1", "0", "8", "9\n", "12\n", "13", "33", "33"]}
| 481
| 152
|
coding
|
Solve the programming task below in a Python markdown code block.
Your task is very simple. Just write a function `isAlphabetic(s)`, which takes an input string `s` in lowercase and returns `true`/`false` depending on whether the string is in alphabetical order or not.
For example, `isAlphabetic('kata')` is False as 'a' comes after 'k', but `isAlphabetic('ant')` is True.
Good luck :)
Also feel free to reuse/extend the following starter code:
```python
def alphabetic(s):
```
|
{"functional": "_inputs = [['asd'], ['codewars'], ['door'], ['cell'], ['z'], ['']]\n_outputs = [[False], [False], [True], [True], [True], [True]]\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(alphabetic(*i), o[0])"}
| 123
| 186
|
coding
|
Solve the programming task below in a Python markdown code block.
There is a big staircase with $N$ steps (numbered $1$ through $N$) in ChefLand. Let's denote the height of the top of step $i$ by $h_i$. Chef Ada is currently under the staircase at height $0$ and she wants to reach the top of the staircase (the top of the last step). However, she can only jump from height $h_i$ to the top of a step at height $h_f$ if $h_f-h_i \le K$. To help Ada, we are going to construct some intermediate steps; each of them may be constructed between any two steps, or before the first step, and have any height. What is the minimum number of steps that need to be added to the staircase so that Ada could reach the top?
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $K$.
- The second line contains $N$ space-seperated 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 steps.
-----Constraints-----
- $1 \le T \le 64$
- $1 \le N \le 128$
- $1 \le K \le 1,024$
- $1 \le h_i \le 1,024$ for each valid $i$
- $h_i < h_{i+1}$ for each valid $i$
-----Example Input-----
1
4 3
2 4 8 16
-----Example Output-----
3
|
{"inputs": ["1\n4 3\n2 4 8 16"], "outputs": ["3"]}
| 392
| 25
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There is a street with n * 2 plots, where there are n plots on each side of the street. The plots on each side are numbered from 1 to n. On each plot, a house can be placed.
Return the number of ways houses can be placed such that no two houses are adjacent to each other on the same side of the street. Since the answer may be very large, return it modulo 109 + 7.
Note that if a house is placed on the ith plot on one side of the street, a house can also be placed on the ith plot on the other side of the street.
Please complete the following python code precisely:
```python
class Solution:
def countHousePlacements(self, n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 1) == 4\n assert candidate(n = 2) == 9\n\n\ncheck(Solution().countHousePlacements)"}
| 177
| 45
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.