task_type
stringclasses 1
value | problem
stringlengths 209
3.39k
| answer
stringlengths 35
6.15k
| problem_tokens
int64 60
774
| answer_tokens
int64 12
2.04k
|
|---|---|---|---|---|
coding
|
Solve the programming task below in a Python markdown code block.
You have a two-dimensional list in the following format:
```python
data = [[2, 5], [3, 4], [8, 7]]
```
Each sub-list contains two items, and each item in the sub-lists is an integer.
Write a function `process_data()` that processes each sub-list like so:
* `[2, 5]` --> `2 - 5` --> `-3`
* `[3, 4]` --> `3 - 4` --> `-1`
* `[8, 7]` --> `8 - 7` --> `1`
and then returns the product of all the processed sub-lists: `-3 * -1 * 1` --> `3`.
For input, you can trust that neither the main list nor the sublists will be empty.
Also feel free to reuse/extend the following starter code:
```python
def process_data(data):
```
|
{"functional": "_inputs = [[[[2, 5], [3, 4], [8, 7]]], [[[2, 9], [2, 4], [7, 5]]], [[[5, 4], [6, 4]]], [[[2, 1], [5, 3], [7, 4], [10, 6]]]]\n_outputs = [[3], [28], [2], [24]]\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(process_data(*i), o[0])"}
| 207
| 240
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
Determine the client's membership level based on the invested `amount` of money and the given thresholds for membership levels.
There are four membership levels (from highest to lowest): `Platinum, Gold, Silver, Bronze`
The minimum investment is the threshold limit for `Bronze` membership. If the given amount is less than the `Bronze` treshold limit return `Not a member`.
A client belongs to a membership level when his invested amount is greater than or equal the level's threshold amount.
# Examples:
```
|--------+----------+------+--------+--------+--------------+------------------|
| Amount | Platinum | Gold | Silver | Bronze | Result | Explanations |
|--------+----------+------+--------+--------+--------------+------------------|
| 7000 | 10000 | 8000 | 6000 | 4000 | Silver | Amount >= Silver |
| 3000 | 10000 | 8000 | 6000 | 5000 | Not a member | Amount < Bronze |
| 8000 | 12000 | 8000 | 7000 | 5000 | Gold | Amount >= Gold |
|--------+----------+------+--------+--------+--------------+------------------|
```
# Restrictions
1. The first line of your code has to be `def membership(amount, platinum, gold, silver, bronze):`
2. Your code except for the firt line mustn't contain the words `platinum, gold, silver, bronze` or they reversed forms (e.g. `dlog`) or any string which contains these words or they reversed forms. (The check is **case-insensitive**.)
3. Must not contain: `+, %, {, }`.
# Disclaimer
This kata is about creativity not proper coding style. Your colleagues/boss won't like you if you make production code like this. :)
#### Don't forget to rate the kata after you finish it. :)
Happy coding!
suic
Also feel free to reuse/extend the following starter code:
```python
def membership(amount, platinum, gold, silver, bronze):
```
|
{"functional": "_inputs = [[100000, 1000000, 100000, 10000, 1000], [1001, 1000000, 100000, 10000, 1000], [998, 1000000, 100000, 10000, 1000], [0, 1000000, 100000, 10000, 1000]]\n_outputs = [['Gold'], ['Bronze'], ['Not a member'], ['Not a member']]\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(membership(*i), o[0])"}
| 501
| 308
|
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 sorted in non-decreasing order.
Build and return an integer array result with the same length as nums such that result[i] is equal to the summation of absolute differences between nums[i] and all the other elements in the array.
In other words, result[i] is equal to sum(|nums[i]-nums[j]|) where 0 <= j < nums.length and j != i (0-indexed).
Please complete the following python code precisely:
```python
class Solution:
def getSumAbsoluteDifferences(self, nums: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [2,3,5]) == [4,3,5]\n assert candidate(nums = [1,4,6,8,10]) == [24,15,13,15,21]\n\n\ncheck(Solution().getSumAbsoluteDifferences)"}
| 142
| 78
|
coding
|
Solve the programming task below in a Python markdown code block.
As you know America’s Presidential Elections are about to take place and the most popular leader of the Republican party Donald Trump is famous for throwing allegations against anyone he meets.
He goes to a rally and meets n people which he wants to offend. For each person i he can choose an integer between 1 to max[i].
He wants to decide in how many ways he can offend all these persons (N) given the condition that all numbers chosen by him for each person are distinct.
So he needs your help to find out the number of ways in which he can do that. If no solution is possible print 0
-----Input-----
The first line of the input contains an integer T (1<=T<=100) 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 denoting the number of people Trump wants to offend. The second line contains N space-separated integers maxnumber[0], maxnumber[1], ..., maxnumber[n-1] denoting the maxnumber that trump can choose for each person.
-----Output-----
For each test case, output a single line containing the number of ways Trump can assign numbers to the people, modulo 1,000,000,007. If it's impossible to assign distinct integers to the people, print 0
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ N ≤ 50
- 1 ≤ Maxnumber[i] ≤ 3000
-----Example-----
Input:
3
1
4
2
10 5
4
2 3 1 3
Output:
4
45
0
-----Explanation-----
In case 1, He can choose any number from 1 to 4
In case 2,Out of the total 50 combination he can not take (1,1) ,(2,2) , (3,3) ,(4,4) or (5,5).
|
{"inputs": ["3\n1\n4\n2\n10 5\n4\n2 3 1 3"], "outputs": ["4\n45\n0"]}
| 434
| 38
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are standing at position 0 on an infinite number line. There is a destination at position target.
You can make some number of moves numMoves so that:
On each move, you can either go left or right.
During the ith move (starting from i == 1 to i == numMoves), you take i steps in the chosen direction.
Given the integer target, return the minimum number of moves required (i.e., the minimum numMoves) to reach the destination.
Please complete the following python code precisely:
```python
class Solution:
def reachNumber(self, target: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(target = 2) == 3\n assert candidate(target = 3) == 2\n\n\ncheck(Solution().reachNumber)"}
| 144
| 43
|
coding
|
Solve the programming task below in a Python markdown code block.
We will say that two integer sequences of length N, x_1, x_2, ..., x_N and y_1, y_2, ..., y_N, are similar when |x_i - y_i| \leq 1 holds for all i (1 \leq i \leq N).
In particular, any integer sequence is similar to itself.
You are given an integer N and an integer sequence of length N, A_1, A_2, ..., A_N.
How many integer sequences b_1, b_2, ..., b_N are there such that b_1, b_2, ..., b_N is similar to A and the product of all elements, b_1 b_2 ... b_N, is even?
Constraints
* 1 \leq N \leq 10
* 1 \leq A_i \leq 100
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the number of integer sequences that satisfy the condition.
Examples
Input
2
2 3
Output
7
Input
3
3 3 3
Output
26
Input
1
100
Output
1
Input
10
90 52 56 71 44 8 13 30 57 84
Output
58921
|
{"inputs": ["2\n2 4", "1\n000", "2\n3 6", "1\n011", "2\n2 6", "1\n010", "2\n3 4", "1\n111"], "outputs": ["5\n", "1\n", "7\n", "2\n", "5\n", "1\n", "7\n", "2\n"]}
| 321
| 94
|
coding
|
Solve the programming task below in a Python markdown code block.
Today is your birthday. You have decided to give away candies to your friends.
You have N friends and M candies. Suppose the 1^{st} friend has L buckets, 2^{nd} has L+1 buckets, 3^{rd} has L+2 buckets, and so on — in general, the i^{th} friend has L + i - 1 buckets.
You start distributing candies from the N^{th} friend and go towards the 1^{st} friend.
For each friend, you put the maximum number of candies in each bucket such that all the buckets for that friend have an equal number of candies in them. Now, you take the remaining candies, move to the next friend, and repeat the above step.
Find the number of candies which will remain with you after visiting all your friends.
------ Input Format ------
- The first line of input will contain a single integer T, the number of test cases. Then the test cases follow.
- Each test case consists of a single line of input, containing three space-separated integers N, M, L — representing the number of friends, number of candies that you have, and the number of buckets with the 1^{st} friend respectively.
------ Output Format ------
For each test case, output a single integer representing the total number of candies left with you after distributing candies to all your friends.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$0 ≤ N, M ≤ 10^{18}$
$1 ≤ L ≤ 10^{18}$
----- Sample Input 1 ------
4
2 8 2
3 9 2
3 10 2
4 100 10
----- Sample Output 1 ------
0
1
0
9
----- explanation 1 ------
Test case $1$: There are two friends. The $1^{st}$ friend has $2$ buckets and the $2^{nd}$ friend has $3$ buckets. You will give $6$ candies to $2^{nd}$ friend ($2$ in each bucket). Now you are left with $2$ candies, which you will give to the $1^{st}$ friend ($1$ in each bucket). You will be left with $0$ candies at the end.
Test case $2$: There are $3$ friends and $9$ candies. The $1^{st}$ friend has $2$ buckets, $2^{nd}$ friend has $3$ buckets, and $3^{rd}$ friend has $4$ buckets. You will give $8$ candies to the $3^{rd}$ friend ($2$ in each bucket). Now the $2^{nd}$ friend and $1^{st}$ friend will get $0$ candies. You will be left with $1$ candy at the end.
Test case $3$: There are $3$ friends and $10$ candies. You will give $8$ candies to the $3^{rd}$ friend ($2$ in each bucket). Next, the $2^{nd}$ friend will get $0$ candies. Finally, the $1^{st}$ friend will get $2$ candies ($1$ in each bucket). You will be left with $0$ candies at the end.
|
{"inputs": ["4\n2 8 2\n3 9 2\n3 10 2\n4 100 10"], "outputs": ["0\n1\n0\n9"]}
| 702
| 46
|
coding
|
Solve the programming task below in a Python markdown code block.
Real stupidity beats artificial intelligence every time.
— Terry Pratchett, Hogfather, Discworld
You are given a string $s$ of length $n$ and a number $k$. Let's denote by $rev(s)$ the reversed string $s$ (i.e. $rev(s) = s_n s_{n-1} ... s_1$). You can apply one of the two kinds of operations to the string:
replace the string $s$ with $s + rev(s)$
replace the string $s$ with $rev(s) + s$
How many different strings can you get as a result of performing exactly $k$ operations (possibly of different kinds) on the original string $s$?
In this statement we denoted the concatenation of strings $s$ and $t$ as $s + t$. In other words, $s + t = s_1 s_2 ... s_n t_1 t_2 ... t_m$, where $n$ and $m$ are the lengths of strings $s$ and $t$ respectively.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 100$) — number of test cases. Next $2 \cdot t$ lines contain $t$ test cases:
The first line of a test case contains two integers $n$ and $k$ ($1 \le n \le 100$, $0 \le k \le 1000$) — the length of the string and the number of operations respectively.
The second string of a test case contains one string $s$ of length $n$ consisting of lowercase Latin letters.
-----Output-----
For each test case, print the answer (that is, the number of different strings that you can get after exactly $k$ operations) on a separate line.
It can be shown that the answer does not exceed $10^9$ under the given constraints.
-----Examples-----
Input
4
3 2
aab
3 3
aab
7 1
abacaba
2 0
ab
Output
2
2
1
1
-----Note-----
In the first test case of the example:
After the first operation the string $s$ can become either aabbaa or baaaab. After the second operation there are 2 possibilities for $s$: aabbaaaabbaa and baaaabbaaaab.
|
{"inputs": ["1\n2 1\nab\n", "1\n3 1\naab\n", "1\n3 1\nabc\n", "1\n4 1\nabcd\n", "1\n4 2\nabca\n", "4\n3 2\naab\n3 3\naab\n7 1\nabacaba\n2 0\nab\n"], "outputs": ["2\n", "2\n", "2\n", "2\n", "2\n", "2\n2\n1\n1\n"]}
| 523
| 117
|
coding
|
Solve the programming task below in a Python markdown code block.
BerPhone X is almost ready for release with n applications being preinstalled on the phone. A category of an application characterizes a genre or a theme of this application (like "game", "business", or "education"). The categories are given as integers between 1 and n, inclusive; the i-th application has category c_i.
You can choose m — the number of screens and s — the size of each screen. You need to fit all n icons of the applications (one icon representing one application) meeting the following requirements:
* On each screen, all the icons must belong to applications of the same category (but different screens can contain icons of applications of the same category);
* Each screen must be either completely filled with icons (the number of icons on the screen is equal to s) or almost filled with icons (the number of icons is equal to s-1).
Your task is to find the minimal possible number of screens m.
Input
The first line contains an integer t (1 ≤ t ≤ 10 000) — the number of test cases in the input. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 2⋅10^6) — the number of the icons. The second line contains n integers c_1, c_2, ..., c_n (1 ≤ c_i ≤ n), where c_i is the category of the i-th application.
It is guaranteed that the sum of the values of n for all test cases in the input does not exceed 2⋅10^6.
Output
Print t integers — the answers to the given test cases in the order they follow in the input. The answer to a test case is an integer m — the minimum number of screens on which all n icons can be placed satisfying the given requirements.
Example
Input
3
11
1 5 1 5 1 5 1 1 1 1 5
6
1 2 2 2 2 1
5
4 3 3 1 2
Output
3
3
4
Note
In the first test case of the example, all the icons can be placed on three screens of size 4: a screen with 4 icons of the category 1, a screen with 3 icons of the category 1, and a screen with 4 icons of the category 5.
|
{"inputs": ["3\n11\n1 5 1 3 1 5 1 1 1 1 5\n6\n1 2 2 2 2 1\n5\n4 3 3 1 2\n", "3\n11\n1 5 1 3 1 2 1 1 1 1 5\n6\n1 2 2 2 4 1\n5\n4 3 3 1 2\n", "3\n11\n1 5 1 3 2 2 1 1 1 1 5\n6\n1 2 2 2 4 2\n5\n4 3 3 1 2\n", "3\n11\n1 5 1 2 2 2 1 1 1 1 5\n6\n1 2 2 2 4 2\n5\n4 3 3 1 2\n", "3\n11\n2 5 1 5 1 5 1 1 1 1 5\n6\n1 2 2 2 2 1\n5\n4 3 3 1 2\n", "3\n11\n1 5 1 3 1 2 1 1 1 1 5\n6\n1 2 2 2 2 1\n5\n1 3 3 1 2\n", "3\n11\n1 5 1 3 1 2 2 1 1 1 5\n6\n1 2 2 2 2 1\n5\n1 3 3 1 2\n", "3\n11\n1 5 1 3 2 2 1 1 1 1 5\n6\n1 2 2 2 4 2\n5\n4 3 3 2 2\n"], "outputs": ["7\n3\n4\n", "7\n4\n4\n", "6\n4\n4\n", "4\n4\n4\n", "6\n3\n4\n", "7\n3\n3\n", "6\n3\n3\n", "6\n4\n3\n"]}
| 522
| 510
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an unsorted integer array nums. Return the smallest positive integer that is not present in nums.
You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space.
Please complete the following python code precisely:
```python
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,2,0]) == 3\n assert candidate(nums = [3,4,-1,1]) == 2\n assert candidate(nums = [7,8,9,11,12]) == 1\n\n\ncheck(Solution().firstMissingPositive)"}
| 90
| 76
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has a sequence of positive integers $A_1, A_2, \ldots, A_N$. He wants to choose some elements of this sequence (possibly none or all of them) and compute their MEX, i.e. the smallest positive integer which does not occur among the chosen elements. For example, the MEX of $[1, 2, 4]$ is $3$.
Help Chef find the largest number of elements of the sequence $A$ which he can choose such that their MEX is equal to $M$, or determine that it is impossible.
-----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 $M$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum number of elements Chef can choose, or $-1$ if he cannot choose elements in such a way that their MEX is $M$.
-----Constraints-----
- $1 \le T \le 100$
- $2 \le M \le N \le 10^5$
- $1 \le A_i \le 10^9$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $10^6$
-----Example Input-----
1
3 3
1 2 4
-----Example Output-----
3
-----Explanation-----
Example case 1: The MEX of whole array is 3. Hence, we can choose all the elements.
|
{"inputs": ["1\n3 3\n1 2 4\n"], "outputs": ["3"]}
| 388
| 23
|
coding
|
Solve the programming task below in a Python markdown code block.
In a small town the population is `p0 = 1000` at the beginning of a year. The population
regularly increases by `2 percent` per year and moreover `50` new inhabitants per year
come to live in the town.
How many years does the town need to see its population
greater or equal to `p = 1200` inhabitants?
```
At the end of the first year there will be:
1000 + 1000 * 0.02 + 50 => 1070 inhabitants
At the end of the 2nd year there will be:
1070 + 1070 * 0.02 + 50 => 1141 inhabitants (number of inhabitants is an integer)
At the end of the 3rd year there will be:
1141 + 1141 * 0.02 + 50 => 1213
It will need 3 entire years.
```
More generally given parameters:
`p0, percent, aug (inhabitants coming or leaving each year), p (population to surpass)`
the function `nb_year` should return `n` number of entire years needed to
get a population greater or equal to `p`.
aug is an integer, percent a positive or null number, p0 and p are positive integers (> 0)
```
Examples:
nb_year(1500, 5, 100, 5000) -> 15
nb_year(1500000, 2.5, 10000, 2000000) -> 10
```
Note: Don't forget to convert the percent parameter as a percentage in the body of your function: if the parameter percent is 2 you have to convert it to 0.02.
Also feel free to reuse/extend the following starter code:
```python
def nb_year(p0, percent, aug, p):
```
|
{"functional": "_inputs = [[1500, 5, 100, 5000], [1500000, 2.5, 10000, 2000000], [1500000, 0.25, 1000, 2000000], [1500000, 0.25, -1000, 2000000], [1500000, 0.25, 1, 2000000], [1500000, 0.0, 10000, 2000000]]\n_outputs = [[15], [10], [94], [151], [116], [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(nb_year(*i), o[0])"}
| 454
| 341
|
coding
|
Solve the programming task below in a Python markdown code block.
You work in the quality control department of technical support for a large company. Your job is to make sure all client issues have been resolved.
Today you need to check a copy of a dialog between a client and a technical support manager. According to the rules of work, each message of the client must be followed by one or several messages, which are the answer of a support manager. However, sometimes clients ask questions so quickly that some of the manager's answers to old questions appear after the client has asked some new questions.
Due to the privacy policy, the full text of messages is not available to you, only the order of messages is visible, as well as the type of each message: a customer question or a response from the technical support manager. It is guaranteed that the dialog begins with the question of the client.
You have to determine, if this dialog may correspond to the rules of work described above, or the rules are certainly breached.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 500$). Description of the test cases follows.
The first line of each test case contains one integer $n$ ($1 \le n \le 100$) — the total number of messages in the dialog.
The second line of each test case consists of $n$ characters "Q" and "A", describing types of messages in the dialog in chronological order. Character "Q" denotes the message with client question, and character "A" — the message with technical support manager answer. It is guaranteed that the first character in the line equals to "Q".
-----Output-----
For each test case print "Yes" (without quotes) if dialog may correspond to the rules of work, or "No" (without quotes) otherwise.
-----Examples-----
Input
5
4
QQAA
4
QQAQ
3
QAA
1
Q
14
QAQQAQAAQQQAAA
Output
Yes
No
Yes
No
Yes
-----Note-----
In the first test case the two questions from the client are followed with two specialist's answers. So this dialog may correspond to the rules of work.
In the second test case one of the first two questions was not answered.
In the third test case the technical support manager sent two messaged as the answer to the only message of the client.
|
{"inputs": ["5\n4\nQQAA\n4\nQQAQ\n3\nQAA\n1\nQ\n14\nQAQQAQAAQQQAAA\n"], "outputs": ["Yes\nNo\nYes\nNo\nYes\n"]}
| 511
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given two integers N \ ( N ≥ 2) and S. You have to construct an array A containing N integers such that:
0 ≤ A_{i} ≤ S for each 1 ≤ i ≤ N
A_{1} + A_{2} + \ldots + A_{N} = S
A_{1} \mathbin{\&} A_{2} \mathbin{\&} \ldots \mathbin{\&} A_{N} = 0, where \mathbin{\&} denotes [bitwise AND] operator.
The maximum element of the array is minimized.
Find the maximum element of the array A.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- The first and only line of each test case contains two space-separated integers N and S — the length of array and sum of array elements respectively.
------ Output Format ------
For each test case, output on a new line the maximum element of the array A.
------ Constraints ------
$1 ≤ T ≤ 10^{4}$
$2 ≤ N ≤ 10^{9}$
$1 ≤ S ≤ 10^{9}$
----- Sample Input 1 ------
4
2 7
3 6
5 21
100 256455
----- Sample Output 1 ------
4
3
5
2570
----- explanation 1 ------
Test case $1$: One possible array is $A = [4,3]$. Here $4 +3=7$ and $4 \mathbin{\&} 3=0$.
Test case $2$: One possible array is $[1, 2, 3]$. Here $1+2+3=6$ and $1 \mathbin{\&} 2 \mathbin{\&} 3=0$.
Test case $3$: One possible array is $[2, 4, 5,5,5]$. Here $2+4+5+5+5=21$ and $2 \mathbin{\&} 4 \mathbin{\&} 5 \mathbin{\&} 5 \mathbin{\&} 5=0$.
|
{"inputs": ["4\n2 7\n3 6\n5 21\n100 256455\n"], "outputs": ["4\n3\n5\n2570\n"]}
| 497
| 47
|
coding
|
Solve the programming task below in a Python markdown code block.
Given is a string S representing the day of the week today.
S is SUN, MON, TUE, WED, THU, FRI, or SAT, for Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, and Saturday, respectively.
After how many days is the next Sunday (tomorrow or later)?
-----Constraints-----
- S is SUN, MON, TUE, WED, THU, FRI, or SAT.
-----Input-----
Input is given from Standard Input in the following format:
S
-----Output-----
Print the number of days before the next Sunday.
-----Sample Input-----
SAT
-----Sample Output-----
1
It is Saturday today, and tomorrow will be Sunday.
|
{"inputs": ["SUN", "SAT", "SAT\n", "SUN\n", "FRI\n", "MON\n", "THU\n", "TUE\n"], "outputs": ["7", "1", "1\n", "7\n", "2\n", "6\n", "3\n", "5\n"]}
| 156
| 71
|
coding
|
Solve the programming task below in a Python markdown code block.
One day Vasya decided to have a look at the results of Berland 1910 Football Championship’s finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are n lines in that description each of which described one goal. Every goal was marked with the name of the team that had scored it. Help Vasya, learn the name of the team that won the finals. It is guaranteed that the match did not end in a tie.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of lines in the description. Then follow n lines — for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match did not end in a tie and the description contains no more than two different teams.
Output
Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner.
Examples
Input
1
ABC
Output
ABC
Input
5
A
ABA
ABA
A
A
Output
A
|
{"inputs": ["1\nABB\n", "1\nAAB\n", "1\nBAB\n", "1\nBAC\n", "1\nACB\n", "1\nCAB\n", "1\nC@B\n", "1\nB@C\n"], "outputs": ["ABB\n", "AAB\n", "BAB\n", "BAC\n", "ACB\n", "CAB\n", "C@B\n", "B@C\n"]}
| 272
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given string $s$ of length $n$ consisting of 0-s and 1-s. You build an infinite string $t$ as a concatenation of an infinite number of strings $s$, or $t = ssss \dots$ For example, if $s =$ 10010, then $t =$ 100101001010010...
Calculate the number of prefixes of $t$ with balance equal to $x$. The balance of some string $q$ is equal to $cnt_{0, q} - cnt_{1, q}$, where $cnt_{0, q}$ is the number of occurrences of 0 in $q$, and $cnt_{1, q}$ is the number of occurrences of 1 in $q$. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
-----Input-----
The first line contains the single integer $T$ ($1 \le T \le 100$) — the number of test cases.
Next $2T$ lines contain descriptions of test cases — two lines per test case. The first line contains two integers $n$ and $x$ ($1 \le n \le 10^5$, $-10^9 \le x \le 10^9$) — the length of string $s$ and the desired balance, respectively.
The second line contains the binary string $s$ ($|s| = n$, $s_i \in \{\text{0}, \text{1}\}$).
It's guaranteed that the total sum of $n$ doesn't exceed $10^5$.
-----Output-----
Print $T$ integers — one per test case. For each test case print the number of prefixes or $-1$ if there is an infinite number of such prefixes.
-----Example-----
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
-----Note-----
In the first test case, there are 3 good prefixes of $t$: with length $28$, $30$ and $32$.
|
{"inputs": ["1\n1 1\n0\n", "1\n1 0\n1\n", "1\n1 0\n1\n", "1\n1 1\n0\n", "1\n1 -1\n1\n", "1\n2 2\n00\n", "1\n2 2\n00\n", "1\n1 -1\n1\n"], "outputs": ["1\n", "1\n", "1\n", "1\n", "1\n", "1\n", "1\n", "1\n"]}
| 551
| 120
|
coding
|
Solve the programming task below in a Python markdown code block.
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
|
{"inputs": ["1 1\n0\n", "1 1\n?\n", "1 1\n-1\n", "3 1\n4 ? 5\n", "3 2\n4 ? 5\n", "3 2\n? 1 2\n", "3 1\n-5 ? 0\n", "3 1\n-1 ? 1\n"], "outputs": ["0\n", "0\n", "-1 ", "Incorrect sequence\n", "4 0 5 ", "0 1 2\n", "-5 -1 0\n", "-1 0 1\n"]}
| 580
| 136
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Mandarin Chinese] and [Russian].
Chef opted for Bio-Statistics as an Open-Elective course in his university, but soon got bored, and decided to text his friends during lectures. The instructor caught Chef, and decided to punish him, by giving him a special assignment.
There are $N$ numbers in a list $A = A_{1}, A_{2}, \ldots, A_{N}$. Chef needs to find the [mode] of the frequencies of the numbers. If there are multiple modal values, report the smallest one. In other words, find the frequency of all the numbers, and then find the frequency which has the highest frequency. If multiple such frequencies exist, report the smallest (non-zero) one.
More formally, for every $v$ such that there exists at least one $i$ such that $A_{i} = v$, find the number of $j$ such that $A_{j} = v$, and call that the frequency of $v$, denoted by $freq(v)$. Then find the value $w$ such that $freq(v) = w$ for the most number of $v$s considered in the previous step. If there are multiple values $w$ which satisfy this, output the smallest among them.
As you are one of Chef's friends, help him complete the assignment.
------ Input: ------
The first line contains an integer $T$, the number of test cases.
The first line of each test case contains an integer $N$, the number of values in Chef's assignment.
The second line of each test case contains $N$ space-separated integers, $A_{i}$, denoting the values in Chef's assignment.
------ Output: ------
For each test case, print the mode of the frequencies of the numbers, in a new line.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ N ≤ 10000$
$1 ≤ A_{i} ≤ 10$
------ Subtasks ------
30 points : $1 ≤ N ≤ 100$
70 points : Original constraints.
----- Sample Input 1 ------
2
8
5 9 2 9 7 2 5 3
9
5 9 2 9 7 2 5 3 1
----- Sample Output 1 ------
2
1
----- explanation 1 ------
- Test case 1: $(2$, $9$ and $5)$ have frequency $2$, while $(3$ and $7)$ have frequency $1$. Three numbers have frequency $2$, while $2$ numbers have frequency $1$. Thus, the mode of the frequencies is $2$.
- Test case 2: $(2$, $9$ and $5)$ have frequency $2$, while $(3$, $1$ and $7)$ have frequency $1$. Three numbers have frequency $2$, and $3$ numbers have frequency $1$. Since there are two modal values $1$ and $2$, we report the smaller one: $1$.
|
{"inputs": ["2\n8\n5 9 2 9 7 2 5 3\n9\n5 9 2 9 7 2 5 3 1"], "outputs": ["2\n1"]}
| 663
| 52
|
coding
|
Solve the programming task below in a Python markdown code block.
Little girl Tanya climbs the stairs inside a multi-storey building. Every time Tanya climbs a stairway, she starts counting steps from $1$ to the number of steps in this stairway. She speaks every number aloud. For example, if she climbs two stairways, the first of which contains $3$ steps, and the second contains $4$ steps, she will pronounce the numbers $1, 2, 3, 1, 2, 3, 4$.
You are given all the numbers pronounced by Tanya. How many stairways did she climb? Also, output the number of steps in each stairway.
The given sequence will be a valid sequence that Tanya could have pronounced when climbing one or more stairways.
-----Input-----
The first line contains $n$ ($1 \le n \le 1000$) — the total number of numbers pronounced by Tanya.
The second line contains integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 1000$) — all the numbers Tanya pronounced while climbing the stairs, in order from the first to the last pronounced number. Passing a stairway with $x$ steps, she will pronounce the numbers $1, 2, \dots, x$ in that order.
The given sequence will be a valid sequence that Tanya could have pronounced when climbing one or more stairways.
-----Output-----
In the first line, output $t$ — the number of stairways that Tanya climbed. In the second line, output $t$ numbers — the number of steps in each stairway she climbed. Write the numbers in the correct order of passage of the stairways.
-----Examples-----
Input
7
1 2 3 1 2 3 4
Output
2
3 4
Input
4
1 1 1 1
Output
4
1 1 1 1
Input
5
1 2 3 4 5
Output
1
5
Input
5
1 2 1 2 1
Output
3
2 2 1
|
{"inputs": ["1\n1\n", "1\n1\n", "2\n1 2\n", "2\n1 2\n", "2\n1 1\n", "3\n1 1 2\n", "3\n1 1 2\n", "3\n1 1 1\n"], "outputs": ["1\n1 ", "1\n1 ", "1\n2 ", "1\n2 ", "2\n1 1 ", "2\n1 2 ", "2\n1 2 ", "3\n1 1 1 "]}
| 469
| 123
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer n. We say that two integers x and y form a prime number pair if:
1 <= x <= y <= n
x + y == n
x and y are prime numbers
Return the 2D sorted list of prime number pairs [xi, yi]. The list should be sorted in increasing order of xi. If there are no prime number pairs at all, return an empty array.
Note: A prime number is a natural number greater than 1 with only two factors, itself and 1.
Please complete the following python code precisely:
```python
class Solution:
def findPrimePairs(self, n: int) -> List[List[int]]:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 10) == [[3,7],[5,5]]\n assert candidate(n = 2) == []\n\n\ncheck(Solution().findPrimePairs)"}
| 158
| 53
|
coding
|
Solve the programming task below in a Python markdown code block.
Given are two integer sequences of N elements each: A_1,...,A_N and B_1,...,B_N. Determine if it is possible to do the following operation at most N-2 times (possibly zero) so that, for every integer i from 1 to N, A_i \leq B_i holds:
* Choose two distinct integers x and y between 1 and N (inclusive), and swap the values of A_x and A_y.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq A_i,B_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
B_1 B_2 ... B_N
Output
If the objective is achievable, print `Yes`; if it is not, print `No`.
Examples
Input
3
1 3 2
1 2 3
Output
Yes
Input
3
1 2 3
2 2 2
Output
No
Input
6
3 1 2 6 3 4
2 2 8 3 4 3
Output
Yes
|
{"inputs": ["3\n1 3 3\n2 2 2", "3\n1 3 2\n2 2 3", "3\n1 3 6\n2 2 2", "3\n1 3 2\n3 2 3", "3\n1 3 6\n2 2 4", "3\n2 3 2\n3 2 3", "3\n1 3 6\n3 2 4", "3\n2 3 2\n5 2 3"], "outputs": ["No\n", "Yes\n", "No\n", "Yes\n", "No\n", "Yes\n", "No\n", "Yes\n"]}
| 274
| 158
|
coding
|
Solve the programming task below in a Python markdown code block.
Autocomplete is a program function that enables inputting the text (in editors, command line shells, browsers etc.) completing the text by its inputted part. Vasya is busy working on a new browser called 'BERowser'. He happens to be working on the autocomplete function in the address line at this very moment. A list consisting of n last visited by the user pages and the inputted part s are known. Your task is to complete s to make it an address of one of the pages from the list. You have to find the lexicographically smallest address having a prefix s.
Input
The first line contains the s line which is the inputted part. The second line contains an integer n (1 ≤ n ≤ 100) which is the number of visited pages. Then follow n lines which are the visited pages, one on each line. All the lines have lengths of from 1 to 100 symbols inclusively and consist of lowercase Latin letters only.
Output
If s is not the beginning of any of n addresses of the visited pages, print s. Otherwise, print the lexicographically minimal address of one of the visited pages starting from s.
The lexicographical order is the order of words in a dictionary. The lexicographical comparison of lines is realized by the '<' operator in the modern programming languages.
Examples
Input
next
2
nextpermutation
nextelement
Output
nextelement
Input
find
4
find
findfirstof
findit
fand
Output
find
Input
find
4
fondfind
fondfirstof
fondit
fand
Output
find
|
{"inputs": ["find\n4\nfind\nfindfirstof\nfindit\nf", "fjnd\n4\nfind\nfindfirstof\nfindit\nf", "njfd\n4\nfind\nfotsqifdmig\nfindit\nf", "dfjn\n4\nfind\nfotsqifdmig\nfindit\nf", "dfjm\n4\nfinc\ngimdfiqstpf\nfiidnt\nf", "fjnd\n4\nfind\nfindfiqstof\nfindit\nf", "fjnd\n4\nfind\nfotsqifdnif\nfindit\nf", "fjnd\n4\nfind\nfotsqifdmif\nfindit\nf"], "outputs": ["find\n", "fjnd\n", "njfd\n", "dfjn\n", "dfjm\n", "fjnd\n", "fjnd\n", "fjnd\n"]}
| 356
| 207
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an array of events where events[i] = [startDayi, endDayi]. Every event i starts at startDayi and ends at endDayi.
You can attend an event i at any day d where startTimei <= d <= endTimei. You can only attend one event at any time d.
Return the maximum number of events you can attend.
Please complete the following python code precisely:
```python
class Solution:
def maxEvents(self, events: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(events = [[1,2],[2,3],[3,4]]) == 3\n assert candidate(events= [[1,2],[2,3],[3,4],[1,2]]) == 4\n\n\ncheck(Solution().maxEvents)"}
| 125
| 67
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a string S consisting of digits between 1 and 9, inclusive.
You can insert the letter + into some of the positions (possibly none) between two letters in this string.
Here, + must not occur consecutively after insertion.
All strings that can be obtained in this way can be evaluated as formulas.
Evaluate all possible formulas, and print the sum of the results.
-----Constraints-----
- 1 \leq |S| \leq 10
- All letters in S are digits between 1 and 9, inclusive.
-----Input-----
The input is given from Standard Input in the following format:
S
-----Output-----
Print the sum of the evaluated value over all possible formulas.
-----Sample Input-----
125
-----Sample Output-----
176
There are 4 formulas that can be obtained: 125, 1+25, 12+5 and 1+2+5. When each formula is evaluated,
- 125
- 1+25=26
- 12+5=17
- 1+2+5=8
Thus, the sum is 125+26+17+8=176.
|
{"inputs": ["0", "1", "2", "4", "3", "5", "9", "8"], "outputs": ["0\n", "1\n", "2\n", "4\n", "3\n", "5\n", "9\n", "8\n"]}
| 274
| 62
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given two positive integers $\class{ML__boldsymbol}{\boldsymbol{a}}$ and $\boldsymbol{b}$ in binary representation. You should find the following sum modulo $10^9+7$:
$\sum\limits_{i=0}^{314159}\left(a\:x or\left(b\:s h l\:i\right)\right)$
where operation $\boldsymbol{x}\textbf{or}$ means exclusive OR operation, operation $\mbox{shl}$ means binary shift to the left.
Please note, that we consider ideal model of binary integers. That is there is infinite number of bits in each number, and there are no disappearings (or cyclic shifts) of bits.
Input Format
The first line contains number $\class{ML__boldsymbol}{\boldsymbol{a}}$ $(1\leq a<2^{10^{5}})$ in binary representation. The second line contains number $\boldsymbol{b}$ $(1\leq b<2^{10^{5}})$ in the same format. All the numbers do not contain leading zeros.
Output Format
Output a single integer $-$ the required sum modulo $10^9+7$.
Sample Input
10
1010
Sample Output
489429555
|
{"inputs": ["10\n1010\n"], "outputs": ["489429555\n"]}
| 295
| 28
|
coding
|
Solve the programming task below in a Python markdown code block.
# Introduction
Digital Cypher assigns to each letter of the alphabet unique number. For example:
```
a b c d e f g h i j k l m
1 2 3 4 5 6 7 8 9 10 11 12 13
n o p q r s t u v w x y z
14 15 16 17 18 19 20 21 22 23 24 25 26
```
Instead of letters in encrypted word we write the corresponding number, eg. The word scout:
```
s c o u t
19 3 15 21 20
```
Then we add to each obtained digit consecutive digits from the key. For example. In case of key equal to `1939` :
```
s c o u t
19 3 15 21 20
+ 1 9 3 9 1
---------------
20 12 18 30 21
m a s t e r p i e c e
13 1 19 20 5 18 16 9 5 3 5
+ 1 9 3 9 1 9 3 9 1 9 3
--------------------------------
14 10 22 29 6 27 19 18 6 12 8
```
# Task
Write a function that accepts `str` string and `key` number and returns an array of integers representing encoded `str`.
# Input / Output
The `str` input string consists of lowercase characters only.
The `key` input number is a positive integer.
# Example
```
Encode("scout",1939); ==> [ 20, 12, 18, 30, 21]
Encode("masterpiece",1939); ==> [ 14, 10, 22, 29, 6, 27, 19, 18, 6, 12, 8]
```
# Digital cypher series
- [Digital cypher vol 1](https://www.codewars.com/kata/592e830e043b99888600002d)
- [Digital cypher vol 2](https://www.codewars.com/kata/592edfda5be407b9640000b2)
- [Digital cypher vol 3 - missing key](https://www.codewars.com/kata/5930d8a4b8c2d9e11500002a)
Also feel free to reuse/extend the following starter code:
```python
def encode(message, key):
```
|
{"functional": "_inputs = [['scout', 1939], ['masterpiece', 1939]]\n_outputs = [[[20, 12, 18, 30, 21]], [[14, 10, 22, 29, 6, 27, 19, 18, 6, 12, 8]]]\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(encode(*i), o[0])"}
| 752
| 229
|
coding
|
Solve the programming task below in a Python markdown code block.
We arrange the numbers between 1 and N (1 <= N <= 10000) in increasing order and decreasing order like this:
1 2 3 4 5 6 7 8 9 . . . N
N . . . 9 8 7 6 5 4 3 2 1
Two numbers faced each other form a pair. Your task is to compute the number of pairs P such that both numbers in the pairs are prime.
Input
Input contains several test cases. Each test case consists of an integer N in one line.
Output
For each line of input, output P .
Example
Input
1
4
7
51
Output
0
2
2
6
|
{"inputs": ["1\n0\n6\n1", "1\n0\n9\n1", "1\n1\n8\n3", "1\n8\n9\n1", "1\n1\n2\n3", "1\n5\n0\n3", "1\n8\n7\n51", "1\n3\n20\n1"], "outputs": ["0\n0\n2\n0\n", "0\n0\n3\n0\n", "0\n0\n2\n1\n", "0\n2\n3\n0\n", "0\n0\n0\n1\n", "0\n1\n0\n1\n", "0\n2\n2\n6\n", "0\n1\n2\n0\n"]}
| 170
| 160
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a 0-indexed integer array nums consisting of n non-negative integers.
You are also given an array queries, where queries[i] = [xi, yi]. The answer to the ith query is the sum of all nums[j] where xi <= j < n and (j - xi) is divisible by yi.
Return an array answer where answer.length == queries.length and answer[i] is the answer to the ith query modulo 109 + 7.
Please complete the following python code precisely:
```python
class Solution:
def solve(self, nums: List[int], queries: List[List[int]]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [0,1,2,3,4,5,6,7], queries = [[0,3],[5,1],[4,2]]) == [9,18,10]\n assert candidate(nums = [100,200,101,201,102,202,103,203], queries = [[0,7]]) == [303]\n\n\ncheck(Solution().solve)"}
| 151
| 118
|
coding
|
Solve the programming task below in a Python markdown code block.
Create a function that accepts 3 inputs, a string, a starting location, and a length. The function needs to simulate the string endlessly repeating in both directions and return a substring beginning at the starting location and continues for length.
Example:
```python
endless_string('xyz', -23, 6) == 'yzxyzx'
```
To visualize:
Negative Positive
3 2 1 * 1 2 3
0987654321098765432109876543210123456789012345678901234567890
xyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzx
******
-23 for a length of 6 == 'yzxyzx'
Some more examples:
```python
endless_string('xyz', 0, 4) == 'xyzx'
endless_string('xyz', 19, 2) == 'yz'
endless_string('xyz', -4, -4) == 'zxyz'
```
A negative length needs to include the starting postion and return the characters to the left of the starting position.
Also feel free to reuse/extend the following starter code:
```python
def endless_string(string, start, length):
```
|
{"functional": "_inputs = [['xyz', -23, 6], ['xyz', 0, 4], ['xyz', 19, 2], ['xyz', -4, -4], ['abcdefghijklmnopqrstuvwxyz', 29, 1], ['Hello! How are you?', -14, 27], ['1x2x3x4x', 1532, 100], ['1x2x3x4x', -1532, -100], ['112233', 0, 0], ['112233', -1, 0], ['112233', 15824, 0]]\n_outputs = [['yzxyzx'], ['xyzx'], ['yz'], ['zxyz'], ['d'], ['! How are you?Hello! How ar'], ['3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x'], ['x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3x4x1x2x3'], [''], [''], ['']]\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(endless_string(*i), o[0])"}
| 329
| 540
|
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 grid where we place some 1 x 1 x 1 cubes that are axis-aligned with the x, y, and z axes.
Each value v = grid[i][j] represents a tower of v cubes placed on top of the cell (i, j).
We view the projection of these cubes onto the xy, yz, and zx planes.
A projection is like a shadow, that maps our 3-dimensional figure to a 2-dimensional plane. We are viewing the "shadow" when looking at the cubes from the top, the front, and the side.
Return the total area of all three projections.
Please complete the following python code precisely:
```python
class Solution:
def projectionArea(self, grid: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate([[1,2],[3,4]]) == 17\n assert candidate(grid = [[2]]) == 5\n assert candidate([[1,0],[0,2]]) == 8\n\n\ncheck(Solution().projectionArea)"}
| 181
| 64
|
coding
|
Solve the programming task below in a Python markdown code block.
Alex just got a new hula hoop, he loves it but feels discouraged because his little brother is better than him
Write a program where Alex can input (n) how many times the hoop goes round and it will return him an encouraging message :)
-If Alex gets 10 or more hoops, return the string "Great, now move on to tricks".
-If he doesn't get 10 hoops, return the string "Keep at it until you get it".
Also feel free to reuse/extend the following starter code:
```python
def hoop_count(n):
```
|
{"functional": "_inputs = [[6], [10], [22]]\n_outputs = [['Keep at it until you get it'], ['Great, now move on to tricks'], ['Great, now move on to tricks']]\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(hoop_count(*i), o[0])"}
| 131
| 187
|
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.
During a boring night at the restaurant, Chef decided to play with spaghetti. He has $R-L+1$ spaghetti: exactly one spaghetti with each length between $L$ and $R$ inclusive.
Chef decided to take some of his spaghetti and stick them together to form one very long spaghetti. The length of this spaghetti is the sum of the lengths of the spaghetti he took. In particular, he may take all spaghetti and he may take only one spaghetti as well. How many different spaghetti can he make?
Two spaghetti are considered different if their lengths are different.
------ 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 different spaghetti Chef can make.
------ Constraints ------
$1 ≤ T ≤ 1,000$
$1 ≤ L, R ≤ 10^{9}$
------ Subtasks ------
Subtask #1 (25 points): $L = 1$
Subtask #2 (55 points): $L, R ≤ 10^{4}$
Subtask #3 (20 points): original constraints
----- Sample Input 1 ------
2
1 2
3 5
----- Sample Output 1 ------
3
7
|
{"inputs": ["2\n1 2\n3 5"], "outputs": ["3\n7"]}
| 354
| 22
|
coding
|
Solve the programming task below in a Python markdown code block.
There is a building with n rooms, numbered 1 to n.
We can move from any room to any other room in the building.
Let us call the following event a move: a person in some room i goes to another room j~ (i \neq j).
Initially, there was one person in each room in the building.
After that, we know that there were exactly k moves happened up to now.
We are interested in the number of people in each of the n rooms now. How many combinations of numbers of people in the n rooms are possible?
Find the count modulo (10^9 + 7).
-----Constraints-----
- All values in input are integers.
- 3 \leq n \leq 2 \times 10^5
- 2 \leq k \leq 10^9
-----Input-----
Input is given from Standard Input in the following format:
n k
-----Output-----
Print the number of possible combinations of numbers of people in the n rooms now, modulo (10^9 + 7).
-----Sample Input-----
3 2
-----Sample Output-----
10
Let c_1, c_2, and c_3 be the number of people in Room 1, 2, and 3 now, respectively. There are 10 possible combination of (c_1, c_2, c_3):
- (0, 0, 3)
- (0, 1, 2)
- (0, 2, 1)
- (0, 3, 0)
- (1, 0, 2)
- (1, 1, 1)
- (1, 2, 0)
- (2, 0, 1)
- (2, 1, 0)
- (3, 0, 0)
For example, (c_1, c_2, c_3) will be (0, 1, 2) if the person in Room 1 goes to Room 2 and then one of the persons in Room 2 goes to Room 3.
|
{"inputs": ["1 2", "4 2", "4 4", "5 4", "6 2", "9 2", "3 4", "3 2"], "outputs": ["1\n", "31\n", "35\n", "126\n", "181\n", "1081\n", "10\n", "10"]}
| 458
| 88
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You want to water n plants in your garden with a watering can. The plants are arranged in a row and are labeled from 0 to n - 1 from left to right where the ith plant is located at x = i. There is a river at x = -1 that you can refill your watering can at.
Each plant needs a specific amount of water. You will water the plants in the following way:
Water the plants in order from left to right.
After watering the current plant, if you do not have enough water to completely water the next plant, return to the river to fully refill the watering can.
You cannot refill the watering can early.
You are initially at the river (i.e., x = -1). It takes one step to move one unit on the x-axis.
Given a 0-indexed integer array plants of n integers, where plants[i] is the amount of water the ith plant needs, and an integer capacity representing the watering can capacity, return the number of steps needed to water all the plants.
Please complete the following python code precisely:
```python
class Solution:
def wateringPlants(self, plants: List[int], capacity: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(plants = [2,2,3,3], capacity = 5) == 14\n assert candidate(plants = [1,1,1,4,2,3], capacity = 4) == 30\n assert candidate(plants = [7,7,7,7,7,7,7], capacity = 8) == 49\n\n\ncheck(Solution().wateringPlants)"}
| 263
| 106
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an integer sequence of length N, a_1,a_2,...,a_N.
For each 1≤i≤N, you have three choices: add 1 to a_i, subtract 1 from a_i or do nothing.
After these operations, you select an integer X and count the number of i such that a_i=X.
Maximize this count by making optimal choices.
-----Constraints-----
- 1≤N≤10^5
- 0≤a_i<10^5 (1≤i≤N)
- a_i is an integer.
-----Input-----
The input is given from Standard Input in the following format:
N
a_1 a_2 .. a_N
-----Output-----
Print the maximum possible number of i such that a_i=X.
-----Sample Input-----
7
3 1 4 1 5 9 2
-----Sample Output-----
4
For example, turn the sequence into 2,2,3,2,6,9,2 and select X=2 to obtain 4, the maximum possible count.
|
{"inputs": ["1\n99999\n", "7\n3 1 4 1 5 9 2\n", "10\n0 1 2 3 4 5 6 7 8 9\n"], "outputs": ["1\n", "4\n", "3\n"]}
| 239
| 71
|
coding
|
Solve the programming task below in a Python markdown code block.
Have you heard about Megamind? Megamind and Metro Man are two aliens who came to earth. Megamind wanted to destroy the earth, while Metro Man wanted to stop him and protect mankind. After a lot of fighting, Megamind finally threw Metro Man up into the sky. Metro Man was defeated and was never seen again. Megamind wanted to be a super villain. He believed that the difference between a villain and a super villain is nothing but presentation. Megamind became bored, as he had nobody or nothing to fight against since Metro Man was gone. So, he wanted to create another hero against whom he would fight for recreation. But accidentally, another villain named Hal Stewart was created in the process, who also wanted to destroy the earth. Also, at some point Megamind had fallen in love with a pretty girl named Roxanne Ritchi. This changed him into a new man. Now he wants to stop Hal Stewart for the sake of his love. So, the ultimate fight starts now.
* Megamind has unlimited supply of guns named Magic-48. Each of these guns has `shots` rounds of magic spells.
* Megamind has perfect aim. If he shoots a magic spell it will definitely hit Hal Stewart. Once hit, it decreases the energy level of Hal Stewart by `dps` units.
* However, since there are exactly `shots` rounds of magic spells in each of these guns, he may need to swap an old gun with a fully loaded one. This takes some time. Let’s call it swapping period.
* Since Hal Stewart is a mutant, he has regeneration power. His energy level increases by `regen` unit during a swapping period.
* Hal Stewart will be defeated immediately once his energy level becomes zero or negative.
* Hal Stewart initially has the energy level of `hp` and Megamind has a fully loaded gun in his hand.
* Given the values of `hp`, `dps`, `shots` and `regen`, find the minimum number of times Megamind needs to shoot to defeat Hal Stewart. If it is not possible to defeat him, return `-1` instead.
# Example
Suppose, `hp` = 13, `dps` = 4, `shots` = 3 and `regen` = 1. There are 3 rounds of spells in the gun. Megamind shoots all of them. Hal Stewart’s energy level decreases by 12 units, and thus his energy level becomes 1. Since Megamind’s gun is now empty, he will get a new gun and thus it’s a swapping period. At this time, Hal Stewart’s energy level will increase by 1 unit and will become 2. However, when Megamind shoots the next spell, Hal’s energy level will drop by 4 units and will become −2, thus defeating him. So it takes 4 shoots in total to defeat Hal Stewart. However, in this same example if Hal’s regeneration power was 50 instead of 1, it would have been impossible to defeat Hal.
Also feel free to reuse/extend the following starter code:
```python
def mega_mind(hp, dps, shots, regen):
```
|
{"functional": "_inputs = [[12, 4, 3, 2], [9, 4, 2, 7], [13, 4, 3, 1], [13, 4, 3, 50], [36, 4, 3, 2], [15, 4, 3, 12], [100000, 99999, 100000, 100000], [100000, 100000, 100000, 100000], [100000, 1, 50000, 49999], [100000, 1, 1000, 999], [17, 4, 4, 16], [23, 4, 4, 13], [1, 4, 4, 15], [22, 4, 4, 13], [16, 4, 4, 16], [20, 4, 4, 15]]\n_outputs = [[3], [4], [4], [-1], [11], [-1], [2], [1], [2500050000], [99001000], [-1], [16], [1], [12], [4], [20]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(mega_mind(*i), o[0])"}
| 684
| 490
|
coding
|
Solve the programming task below in a Python markdown code block.
Let f(n) be the number of triples of integers (x,y,z) that satisfy both of the following conditions:
* 1 \leq x,y,z
* x^2 + y^2 + z^2 + xy + yz + zx = n
Given an integer N, find each of f(1),f(2),f(3),\ldots,f(N).
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^4
Input
Input is given from Standard Input in the following format:
N
Output
Print N lines. The i-th line should contain the value f(i).
Example
Input
20
Output
0
0
0
0
0
1
0
0
0
0
3
0
0
0
0
0
3
3
0
0
|
{"inputs": ["3", "2", "4", "8", "1", "5", "6", "9"], "outputs": ["0\n0\n0\n", "0\n0\n", "0\n0\n0\n0\n", "0\n0\n0\n0\n0\n1\n0\n0\n", "0\n", "0\n0\n0\n0\n0\n", "0\n0\n0\n0\n0\n1\n", "0\n0\n0\n0\n0\n1\n0\n0\n0\n"]}
| 201
| 122
|
coding
|
Solve the programming task below in a Python markdown code block.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of $n$ numbers from $1$ to $200$. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
$a_{1} \le a_{2}$,
$a_{n} \le a_{n-1}$ and
$a_{i} \le max(a_{i-1}, \,\, a_{i+1})$ for all $i$ from $2$ to $n-1$.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from $1$ to $200$. Since the number of ways can be big, print it modulo $998244353$.
-----Input-----
First line of input contains one integer $n$ ($2 \le n \le 10^{5}$) — size of the array.
Second line of input contains $n$ integers $a_{i}$ — elements of array. Either $a_{i} = -1$ or $1 \le a_{i} \le 200$. $a_{i} = -1$ means that $i$-th element can't be read.
-----Output-----
Print number of ways to restore the array modulo $998244353$.
-----Examples-----
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
-----Note-----
In the first example, only possible value of $a_{2}$ is $2$.
In the second example, $a_{1} = a_{2}$ so there are $200$ different values because all restored elements should be integers between $1$ and $200$.
|
{"inputs": ["2\n2 9\n", "2\n1 9\n", "2\n1 2\n", "2\n1 3\n", "2\n2 21\n", "2\n1 21\n", "2\n3 30\n", "2\n1 30\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 422
| 106
|
coding
|
Solve the programming task below in a Python markdown code block.
Fukushima Prefecture is also famous for producing fruits, and among them, peaches and apples boast one of the highest production volumes in Japan. By the way, when I made a print manuscript of an English pamphlet for sale, I mistakenly wrote the description about apples and the description about peaches in reverse.
You've been tasked with fixing apple and peach, but it's kind of annoying. Enter a single line of English text and create a program that outputs the English text with all the character strings apple in it replaced with peach and all the character strings peach replaced with apple.
Input
English text (including half-width alphanumeric characters, spaces, and symbols) is given on one line. The length of the string entered is 1000 or less.
Output
Outputs English sentences with the character strings apple and peach exchanged on one line.
Example
Input
the cost of one peach is higher than that of one apple.
Output
the cost of one apple is higher than that of one peach.
|
{"inputs": ["the cost of one peach is higher than th`t of one apple.", "the cost of ooe peach is higher than th`t of one apple.", "the cost of ooe peach is higher than th`t of eno apple.", "the cpst of ooe peach is higher than th`t of eno apple.", "the cpst of ooe peach is higher than t`ht of eno apple.", "eht cpst of ooe peach is higher than t`ht of eno apple.", "eht dpst of ooe peach is higher than t`ht of eno apple.", "the dpst of ooe peach is higher than t`ht of eno apple."], "outputs": ["the cost of one apple is higher than th`t of one peach.\n", "the cost of ooe apple is higher than th`t of one peach.\n", "the cost of ooe apple is higher than th`t of eno peach.\n", "the cpst of ooe apple is higher than th`t of eno peach.\n", "the cpst of ooe apple is higher than t`ht of eno peach.\n", "eht cpst of ooe apple is higher than t`ht of eno peach.\n", "eht dpst of ooe apple is higher than t`ht of eno peach.\n", "the dpst of ooe apple is higher than t`ht of eno peach.\n"]}
| 217
| 311
|
coding
|
Solve the programming task below in a Python markdown code block.
There are n kangaroos with pockets. Each kangaroo has a size (integer number). A kangaroo can go into another kangaroo's pocket if and only if the size of kangaroo who hold the kangaroo is at least twice as large as the size of kangaroo who is held.
Each kangaroo can hold at most one kangaroo, and the kangaroo who is held by another kangaroo cannot hold any kangaroos.
The kangaroo who is held by another kangaroo cannot be visible from outside. Please, find a plan of holding kangaroos with the minimal number of kangaroos who is visible.
-----Input-----
The first line contains a single integer — n (1 ≤ n ≤ 5·10^5). Each of the next n lines contains an integer s_{i} — the size of the i-th kangaroo (1 ≤ s_{i} ≤ 10^5).
-----Output-----
Output a single integer — the optimal number of visible kangaroos.
-----Examples-----
Input
8
2
5
7
6
9
8
4
2
Output
5
Input
8
9
1
6
2
6
5
8
3
Output
5
|
{"inputs": ["1\n1\n", "1\n1\n", "1\n2\n", "1\n3\n", "1\n6\n", "3\n1\n2\n4\n", "3\n1\n2\n4\n", "4\n1\n1\n1\n2\n"], "outputs": ["1\n", "1\n", "1\n", "1\n", "1\n", "2\n", "2\n", "3\n"]}
| 268
| 100
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given 2 numbers is `n` and `k`. You need to find the number of integers between 1 and n (inclusive) that contains exactly `k` non-zero digit.
Example1
`
almost_everywhere_zero(100, 1) return 19`
by following condition we have 19 numbers that have k = 1 digits( not count zero )
` [1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100]`
Example2
`
almost_everywhere_zero(11, 2) return 1`
we have only `11` that has 2 digits(ten not count because zero is not count)
` 11`
constrains
`1≤n<pow(10,100)`
`1≤k≤100`
Also feel free to reuse/extend the following starter code:
```python
def almost_everywhere_zero(n, k):
```
|
{"functional": "_inputs = [[100, 1], [11, 2], [20, 2], [101, 2], [10001, 2], [10001000, 2], [500309160, 2], [10000000000000000000000, 3], [10000000000000000000000, 21], [1203, 4]]\n_outputs = [[19], [1], [9], [82], [487], [1729], [2604], [1122660], [2407217760893271902598], [81]]\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(almost_everywhere_zero(*i), o[0])"}
| 250
| 352
|
coding
|
Solve the programming task below in a Python markdown code block.
Rng is preparing a problem set for a qualification round of CODEFESTIVAL.
He has N candidates of problems. The difficulty of the i-th candidate is D_i.
There must be M problems in the problem set, and the difficulty of the i-th problem must be T_i. Here, one candidate of a problem cannot be used as multiple problems.
Determine whether Rng can complete the problem set without creating new candidates of problems.
Constraints
* 1 \leq N \leq 200,000
* 1 \leq D_i \leq 10^9
* 1 \leq M \leq 200,000
* 1 \leq T_i \leq 10^9
* All numbers in the input are integers.
Input
Input is given from Standard Input in the following format:
N
D_1 D_2 ... D_N
M
T_1 T_2 ... T_M
Output
Print `YES` if Rng can complete the problem set without creating new candidates of problems; print `NO` if he cannot.
Examples
Input
5
3 1 4 1 5
3
5 4 3
Output
YES
Input
7
100 200 500 700 1200 1600 2000
6
100 200 500 700 1600 1600
Output
NO
Input
1
800
5
100 100 100 100 100
Output
NO
Input
15
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
9
5 4 3 2 1 2 3 4 5
Output
YES
|
{"inputs": ["5\n3 1 4 1 5\n3\n5 4 3", "1\n9\n7\n110 100 110 110 100", "1\n9\n7\n100 100 110 110 100", "1\n9\n7\n100 100 110 111 100", "1\n9\n2\n100 100 110 111 100", "1\n9\n2\n100 100 111 111 100", "1\n9\n2\n100 000 111 111 100", "1\n9\n2\n101 000 111 111 100"], "outputs": ["YES", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n"]}
| 438
| 247
|
coding
|
Solve the programming task below in a Python markdown code block.
A [perfect power](https://en.wikipedia.org/wiki/Perfect_power) is a classification of positive integers:
> In mathematics, a **perfect power** is a positive integer that can be expressed as an integer power of another positive integer. More formally, n is a perfect power if there exist natural numbers m > 1, and k > 1 such that m^(k) = n.
Your task is to check wheter a given integer is a perfect power. If it is a perfect power, return a pair `m` and `k` with m^(k) = n as a proof. Otherwise return `Nothing`, `Nil`, `null`, `NULL`, `None` or your language's equivalent.
**Note:** For a perfect power, there might be several pairs. For example `81 = 3^4 = 9^2`, so `(3,4)` and `(9,2)` are valid solutions. However, the tests take care of this, so if a number is a perfect power, return any pair that proves it.
### Examples
```python
isPP(4) => [2,2]
isPP(9) => [3,2]
isPP(5) => None
```
Also feel free to reuse/extend the following starter code:
```python
def isPP(n):
```
|
{"functional": "_inputs = [[4], [9], [5]]\n_outputs = [[[2, 2]], [[3, 2]], [None]]\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(isPP(*i), o[0])"}
| 289
| 172
|
coding
|
Solve the programming task below in a Python markdown code block.
A new school year is approaching, which also means students will be taking tests.
The tests in this kata are to be graded in different ways. A certain number of points will be given for each correct answer and a certain number of points will be deducted for each incorrect answer. For ommitted answers, points will either be awarded, deducted, or no points will be given at all.
Return the number of points someone has scored on varying tests of different lengths.
The given parameters will be:
* An array containing a series of `0`s, `1`s, and `2`s, where `0` is a correct answer, `1` is an omitted answer, and `2` is an incorrect answer.
* The points awarded for correct answers
* The points awarded for omitted answers (note that this may be negative)
* The points **deducted** for incorrect answers (hint: this value has to be subtracted)
**Note:**
The input will always be valid (an array and three numbers)
## Examples
\#1:
```
[0, 0, 0, 0, 2, 1, 0], 2, 0, 1 --> 9
```
because:
* 5 correct answers: `5*2 = 10`
* 1 omitted answer: `1*0 = 0`
* 1 wrong answer: `1*1 = 1`
which is: `10 + 0 - 1 = 9`
\#2:
```
[0, 1, 0, 0, 2, 1, 0, 2, 2, 1], 3, -1, 2) --> 3
```
because: `4*3 + 3*-1 - 3*2 = 3`
Also feel free to reuse/extend the following starter code:
```python
def score_test(tests, right, omit, wrong):
```
|
{"functional": "_inputs = [[[0, 0, 0, 0, 2, 1, 0], 2, 0, 1], [[0, 1, 0, 0, 2, 1, 0, 2, 2, 1], 3, -1, 2], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 5, -1, 2], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 0], 6, 0, 1.5], [[0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 2, 1, 2, 0, 2, 1], 10, -5, 10], [[0, 2, 0, 2, 0, 2, 0, 2], 10, 0, 5], [[0, 1, 2, 0, 0, 2, 0, 1, 2, 1, 0, 0, 1, 0, 2, 1, 0, 2, 2, 0], 9, 3, 2]]\n_outputs = [[9], [3], [70], [87], [-60], [20], [84]]\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(score_test(*i), o[0])"}
| 429
| 545
|
coding
|
Solve the programming task below in a Python markdown code block.
You will be given a string.
You need to return an array of three strings by gradually pulling apart the string.
You should repeat the following steps until the string length is 1:
a) remove the final character from the original string, add to solution string 1.
b) remove the first character from the original string, add to solution string 2.
The final solution string value is made up of the remaining character from the original string, once originalstring.length == 1.
Example:
"exampletesthere"
becomes:
["erehtse","example","t"]
The Kata title gives a hint of one technique to solve.
Also feel free to reuse/extend the following starter code:
```python
def pop_shift(s):
```
|
{"functional": "_inputs = [['reusetestcasesbitcointakeovertheworldmaybewhoknowsperhaps'], ['turnsoutrandomtestcasesareeasierthanwritingoutbasicones'], ['exampletesthere'], ['letstalkaboutjavascriptthebestlanguage'], ['iwanttotraveltheworldwritingcodeoneday'], ['letsallgoonholidaysomewhereverycold']]\n_outputs = [[['spahrepswonkohwebyamdlroweht', 'reusetestcasesbitcointakeove', 'r']], [['senocisabtuognitirwnahtreis', 'turnsoutrandomtestcasesaree', 'a']], [['erehtse', 'example', 't']], [['egaugnaltsebehttpir', 'letstalkaboutjavasc', '']], [['yadenoedocgnitirwdl', 'iwanttotravelthewor', '']], [['dlocyreverehwemos', 'letsallgoonholida', 'y']]]\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(pop_shift(*i), o[0])"}
| 164
| 359
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
The string is called `prime` if it cannot be constructed by concatenating some (more than one) equal strings together.
For example, "abac" is prime, but "xyxy" is not("xyxy"="xy"+"xy").
Given a string determine if it is prime or not.
# Input/Output
- `[input]` string `s`
string containing only lowercase English letters
- `[output]` a boolean value
`true` if the string is prime, `false` otherwise
Also feel free to reuse/extend the following starter code:
```python
def prime_string(s):
```
|
{"functional": "_inputs = [['abac'], ['abab'], ['aaaa'], ['x'], ['abc'], ['fdsyffdsyffdsyffdsyffdsyf'], ['utdutdtdutd'], ['abba']]\n_outputs = [[True], [False], [False], [True], [True], [False], [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(prime_string(*i), o[0])"}
| 146
| 220
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
The count-and-say sequence is a sequence of digit strings defined by the recursive formula:
countAndSay(1) = "1"
countAndSay(n) is the run-length encoding of countAndSay(n - 1).
Run-length encoding (RLE) is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string "3322251" we replace "33" with "23", replace "222" with "32", replace "5" with "15" and replace "1" with "11". Thus the compressed string becomes "23321511".
Given a positive integer n, return the nth element of the count-and-say sequence.
Please complete the following python code precisely:
```python
class Solution:
def countAndSay(self, n: int) -> str:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 4) == \"1211\"\n assert candidate(n = 1) == \"1\"\n\n\ncheck(Solution().countAndSay)"}
| 235
| 49
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given two integers a and b. Determine if a+b=15 or a\times b=15 or neither holds.
Note that a+b=15 and a\times b=15 do not hold at the same time.
Constraints
* 1 \leq a,b \leq 15
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a b
Output
If a+b=15, print `+`; if a\times b=15, print `*`; if neither holds, print `x`.
Examples
Input
4 11
Output
+
Input
3 5
Output
*
Input
1 1
Output
x
|
{"inputs": ["8 7", "3 7", "2 1", "3 8", "4 1", "8 5", "3 0", "4 0"], "outputs": ["+\n", "x\n", "x\n", "x\n", "x\n", "x\n", "x\n", "x\n"]}
| 171
| 78
|
coding
|
Solve the programming task below in a Python markdown code block.
Unlucky year in Berland is such a year that its number n can be represented as n = x^{a} + y^{b}, where a and b are non-negative integer numbers.
For example, if x = 2 and y = 3 then the years 4 and 17 are unlucky (4 = 2^0 + 3^1, 17 = 2^3 + 3^2 = 2^4 + 3^0) and year 18 isn't unlucky as there is no such representation for it.
Such interval of years that there are no unlucky years in it is called The Golden Age.
You should write a program which will find maximum length of The Golden Age which starts no earlier than the year l and ends no later than the year r. If all years in the interval [l, r] are unlucky then the answer is 0.
-----Input-----
The first line contains four integer numbers x, y, l and r (2 ≤ x, y ≤ 10^18, 1 ≤ l ≤ r ≤ 10^18).
-----Output-----
Print the maximum length of The Golden Age within the interval [l, r].
If all years in the interval [l, r] are unlucky then print 0.
-----Examples-----
Input
2 3 1 10
Output
1
Input
3 5 10 22
Output
8
Input
2 3 3 5
Output
0
-----Note-----
In the first example the unlucky years are 2, 3, 4, 5, 7, 9 and 10. So maximum length of The Golden Age is achived in the intervals [1, 1], [6, 6] and [8, 8].
In the second example the longest Golden Age is the interval [15, 22].
|
{"inputs": ["2 3 3 5\n", "3 2 6 7\n", "3 3 1 1\n", "4 4 1 1\n", "2 2 1 1\n", "2 3 1 1\n", "3 2 6 7\n", "4 4 1 1\n"], "outputs": ["0\n", "1\n", "1\n", "1\n", "1\n", "1\n", "1", "1"]}
| 415
| 116
|
coding
|
Solve the programming task below in a Python markdown code block.
Today s kilometer long auto race takes place in Berland. The track is represented by a straight line as long as s kilometers. There are n cars taking part in the race, all of them start simultaneously at the very beginning of the track. For every car is known its behavior — the system of segments on each of which the speed of the car is constant. The j-th segment of the i-th car is pair (vi, j, ti, j), where vi, j is the car's speed on the whole segment in kilometers per hour and ti, j is for how many hours the car had been driving at that speed. The segments are given in the order in which they are "being driven on" by the cars.
Your task is to find out how many times during the race some car managed to have a lead over another car. A lead is considered a situation when one car appears in front of another car. It is known, that all the leads happen instantly, i. e. there are no such time segment of positive length, during which some two cars drive "together". At one moment of time on one and the same point several leads may appear. In this case all of them should be taken individually. Meetings of cars at the start and finish are not considered to be counted as leads.
Input
The first line contains two integers n and s (2 ≤ n ≤ 100, 1 ≤ s ≤ 106) — the number of cars and the length of the track in kilometers. Then follow n lines — the description of the system of segments for each car. Every description starts with integer k (1 ≤ k ≤ 100) — the number of segments in the system. Then k space-separated pairs of integers are written. Each pair is the speed and time of the segment. These integers are positive and don't exceed 1000. It is guaranteed, that the sum of lengths of all segments (in kilometers) for each car equals to s; and all the leads happen instantly.
Output
Print the single number — the number of times some car managed to take the lead over another car during the race.
Examples
Input
2 33
2 5 1 2 14
1 3 11
Output
1
Input
2 33
2 1 3 10 3
1 11 3
Output
0
Input
5 33
2 1 3 3 10
1 11 3
2 5 3 3 6
2 3 1 10 3
2 6 3 3 5
Output
2
|
{"inputs": ["2 33\n2 5 1 2 14\n1 3 11\n", "2 33\n2 1 3 10 3\n1 11 3\n", "2 6\n3 1 2 2 1 1 2\n3 2 1 1 2 2 1\n", "2 5\n3 2 1 1 1 2 1\n3 1 1 2 1 1 2\n", "2 5\n3 2 1 1 1 2 1\n3 1 2 2 1 1 1\n", "2 166755\n2 733 187 362 82\n3 813 147 565 57 557 27\n", "5 33\n2 1 3 3 10\n1 11 3\n2 5 3 3 6\n2 3 1 10 3\n2 6 3 3 5\n", "3 228385\n2 307 733 43 78\n2 252 801 157 169\n3 86 346 133 886 467 173\n"], "outputs": [" 1\n", " 0\n", " 0\n", " 0\n", "0\n", " 0\n", " 2\n", " 0\n"]}
| 575
| 382
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.
Please complete the following python code precisely:
```python
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
```
|
{"functional": "def check(candidate):\n assert is_same_list(candidate(head = list_node([1,1,2])), list_node([1,2]))\n assert is_same_list(candidate(head = list_node([1,1,2,3,3])), list_node([1,2,3]))\n\n\ncheck(Solution().deleteDuplicates)"}
| 119
| 77
|
coding
|
Solve the programming task below in a Python markdown code block.
This challenge is based on [the kata](https://www.codewars.com/kata/n-smallest-elements-in-original-order) by GiacomoSorbi. Before doing this one it is advisable to complete the non-performance version first.
___
# Task
You will be given an array of random integers and a number `n`. You have to extract `n` smallest integers out of it **preserving the original order**.
# Examples
```python
performant_smallest([1, 2, 3, 4, 5], 3) == [1, 2, 3]
performant_smallest([5, 4, 3, 2, 1], 3) == [3, 2, 1]
performant_smallest([1, 2, 3, 4, 1], 3) == [1, 2, 1]
performant_smallest([2, 1, 3, 2, 3], 3) == [2, 1, 2]
```
# Notes
* There will be duplicates in the array, and they have to be returned in the order of their each separate appearence.
* This kata is an example of the "know your data" principle. Remember this while searching for the correct approach.
# Performance tests
```python
Tests: 15
Array size: 800,000
Values range: [1; 50]
Number of elements to return: 25-50% of the array
```
Also feel free to reuse/extend the following starter code:
```python
def performant_smallest(arr, n):
```
|
{"functional": "_inputs = [[[1, 2, 3, 4, 5], 3], [[5, 4, 3, 2, 1], 3], [[1, 2, 3, 4, 1], 3], [[2, 1, 3, 2, 3], 3]]\n_outputs = [[[1, 2, 3]], [[3, 2, 1]], [[1, 2, 1]], [[2, 1, 2]]]\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(performant_smallest(*i), o[0])"}
| 376
| 259
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef has two integers A and B. In one operation he can choose any integer d, and make one of the following two moves :
Add d to A and subtract d from B.
Add d to B and subtract d from A.
Chef is allowed to make as many operations as he wants. Can he make A and B equal?
------ Input Format ------
- First line will contain T, number of test cases. Then the test cases follow.
- Each test case contains of a single line of input, two integers A, B.
------ Output Format ------
For each test case, if Chef can make the two numbers equal print YES else print NO.
You may print each character of the string in uppercase or lowercase (for example, the strings yEs, Yes, YeS, and YES will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$1 ≤ A,B ≤ 1000$
----- Sample Input 1 ------
2
3 3
1 2
----- Sample Output 1 ------
Yes
No
----- explanation 1 ------
Test case $1$: Since $A$ and $B$ are already equal, Chef does not need any operations.
Test case $2$: It can be shown that $A$ and $B$ can never be made equal using any number of given operations.
|
{"inputs": ["2\n3 3\n1 2\n"], "outputs": ["Yes\nNo\n"]}
| 294
| 24
|
coding
|
Solve the programming task below in a Python markdown code block.
Sitting in a station waiting room, Joisino is gazing at her train ticket.
The ticket is numbered with four digits A, B, C and D in this order, each between 0 and 9 (inclusive).
In the formula A op1 B op2 C op3 D = 7, replace each of the symbols op1, op2 and op3 with + or - so that the formula holds.
The given input guarantees that there is a solution. If there are multiple solutions, any of them will be accepted.
-----Constraints-----
- 0≤A,B,C,D≤9
- All input values are integers.
- It is guaranteed that there is a solution.
-----Input-----
Input is given from Standard Input in the following format:
ABCD
-----Output-----
Print the formula you made, including the part =7.
Use the signs + and -.
Do not print a space between a digit and a sign.
-----Sample Input-----
1222
-----Sample Output-----
1+2+2+2=7
This is the only valid solution.
|
{"inputs": ["2364", "1114", "2005", "1455", "1152", "3246", "6120", "2768"], "outputs": ["2+3+6-4=7\n", "1+1+1+4=7\n", "2+0+0+5=7\n", "1-4+5+5=7\n", "1-1+5+2=7\n", "3+2-4+6=7\n", "6-1+2+0=7\n", "2+7+6-8=7\n"]}
| 235
| 150
|
coding
|
Solve the programming task below in a Python markdown code block.
Little Dima has two sequences of points with integer coordinates: sequence (a1, 1), (a2, 2), ..., (an, n) and sequence (b1, 1), (b2, 2), ..., (bn, n).
Now Dima wants to count the number of distinct sequences of points of length 2·n that can be assembled from these sequences, such that the x-coordinates of points in the assembled sequence will not decrease. Help him with that. Note that each element of the initial sequences should be used exactly once in the assembled sequence.
Dima considers two assembled sequences (p1, q1), (p2, q2), ..., (p2·n, q2·n) and (x1, y1), (x2, y2), ..., (x2·n, y2·n) distinct, if there is such i (1 ≤ i ≤ 2·n), that (pi, qi) ≠ (xi, yi).
As the answer can be rather large, print the remainder from dividing the answer by number m.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The third line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 109). The numbers in the lines are separated by spaces.
The last line contains integer m (2 ≤ m ≤ 109 + 7).
Output
In the single line print the remainder after dividing the answer to the problem by number m.
Examples
Input
1
1
2
7
Output
1
Input
2
1 2
2 3
11
Output
2
Note
In the first sample you can get only one sequence: (1, 1), (2, 1).
In the second sample you can get such sequences : (1, 1), (2, 2), (2, 1), (3, 2); (1, 1), (2, 1), (2, 2), (3, 2). Thus, the answer is 2.
|
{"inputs": ["1\n1\n2\n3\n", "1\n1\n3\n3\n", "1\n1\n5\n3\n", "1\n1\n5\n2\n", "1\n1\n2\n7\n", "2\n1 2\n1 2\n4\n", "2\n1 2\n2 2\n4\n", "2\n2 2\n1 2\n4\n"], "outputs": ["1\n", "1\n", "1\n", "1\n", "1\n", "1\n", "3\n", "3\n"]}
| 484
| 130
|
coding
|
Solve the programming task below in a Python markdown code block.
Rachel has some candies and she decided to distribute them among $N$ kids. The ith kid receives $A_i$ candies. The kids are happy iff the difference between the highest and lowest number of candies received is less than $X$.
Find out if the children are happy or not.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- The first line contains $N$ and $X$.
- The second line contains $N$ integers $A_1,A_2,...,A_N$.
-----Output:-----
For each test case print either "YES"(without quotes) if the kids are happy else "NO"(without quotes)
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N, X \leq 10^5$
- $1 \leq A_i \leq 10^5$
-----Sample Input:-----
2
5 6
3 5 6 8 1
3 10
5 2 9
-----Sample Output:-----
NO
YES
-----EXPLANATION:-----
- Example 1: Difference between maximum and minimum candies received is 8-1=7. 7 is greater than 6, therefore, the kids are not happy.
|
{"inputs": ["2\n5 6\n3 5 6 8 1\n3 10\n5 2 9"], "outputs": ["NO\nYES"]}
| 295
| 39
|
coding
|
Solve the programming task below in a Python markdown code block.
Let S(n) denote the sum of the digits in the decimal notation of n.
For example, S(101) = 1 + 0 + 1 = 2.
Given an integer N, determine if S(N) divides N.
-----Constraints-----
- 1 \leq N \leq 10^9
-----Input-----
Input is given from Standard Input in the following format:
N
-----Output-----
If S(N) divides N, print Yes; if it does not, print No.
-----Sample Input-----
12
-----Sample Output-----
Yes
In this input, N=12.
As S(12) = 1 + 2 = 3, S(N) divides N.
|
{"inputs": ["12\n", "101\n", "999999999\n", "693828976\n", "873041724\n", "689670774\n", "972655544\n", "506479109\n"], "outputs": ["Yes\n", "No\n", "Yes\n", "No\n", "Yes\n", "Yes\n", "No\n", "Yes\n"]}
| 165
| 121
|
coding
|
Solve the programming task below in a Python markdown code block.
There are $N$ buckets numbered $1$ through $N$. The buckets contain balls; each ball has a color between $1$ and $K$. Let's denote the number of balls with color $j$ that are initially in bucket $i$ by $a_{i, j}$.
For each $i$ from $1$ to $N-1$ (in this order), someone draws a ball uniformly at random from bucket $i$ and puts it into bucket $i+1$, then continues to draw the next ball. After putting a ball in bucket $N$, this person draws a ball, again uniformly at random, from bucket $N$.
For each color from $1$ to $K$, find the probability that the ball drawn from bucket $N$ has this color.
-----Input-----
- The first line of the input contains two space-separated integers $N$ and $K$.
- $N$ lines follow. For each $i$ ($1 \le i \le N$), the $i$-th of these lines contains $K$ space-separated integers $a_{i, 1}, a_{i, 2}, \ldots, a_{i, K}$.
-----Output-----
Print a single line containing $K$ space-separated real numbers. For each valid $i$, the $i$-th of these numbers should denote the probability that the last drawn ball has color $i$. your answer will be considered correct if absolute or relative error does not exceed $10^{-6}$
-----Constraints-----
- $1 \le N, K \le 1,000$
- $0 \le a_{i, j} \le 10$ for each valid $i, j$
- initially, there is at least one ball in bucket $1$
-----Subtasks-----
Subtask #1 (30 points): $1 \le N, K \le 100$
Subtask #2 (70 points): original constraints
-----Example Input-----
2 2
0 1
1 1
-----Example Output-----
0.333333 0.666667
-----Explanation-----
|
{"inputs": ["2 2\n0 1\n1 1"], "outputs": ["0.333333 0.666667"]}
| 469
| 38
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an m x n binary matrix mat, return the length of the longest line of consecutive one in the matrix.
The line could be horizontal, vertical, diagonal, or anti-diagonal.
Please complete the following python code precisely:
```python
class Solution:
def longestLine(self, mat: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(mat = [[0,1,1,0],[0,1,1,0],[0,0,0,1]]) == 3\n assert candidate(mat = [[1,1,1,1],[0,1,1,0],[0,0,0,1]]) == 4\n\n\ncheck(Solution().longestLine)"}
| 87
| 88
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
You are given a graph $G$ with $N$ vertices (numbered $1$ through $N$) and $M$ edges. You should partition the vertices of $G$ into two sets $A$ and $B$ such that:
each vertex of $G$ belongs to exactly one of these sets
$A$ is non-empty
$A$ is an independent set in $G$, i.e. for each pair of vertices $u, v \in A$, $G$ does not contain an edge $(u, v)$
for each vertex $a \in A$ and each vertex $b \in B$, there is an edge $(a, b)$ in $G$
Find the number of such partitions $(A, B)$. Also, give an example of one of these partitions or determine that no such partition exists.
Two partitions are considered different if there is a vertex that is in the set $A$ in one partition and in the set $B$ in the other partition.
------ 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 $M$.
Each of the next $M$ lines contains two space-separated integers $u$ and $v$ denoting that vertices $u$ and $v$ are connected by an edge.
------ Output ------
For each test case, print two lines.
The first of these lines should contain a single integer — the number of partitions satisfying the given conditions.
The second line should contain a single string with length $N$. If there are no partitions satisfying the given conditions, each character of this string should be '0'. Otherwise, this string should describe one such partition — for each valid $i$, the $i$-th character should be '1' if vertex $i$ belongs to $A$ or '0' if it belongs to $B$.
------ Constraints ------
$1 ≤ T ≤ 5 \cdot 10^{5}$
$1 ≤ N, M ≤ 5 \cdot 10^{5}$
$1 ≤ u, v ≤ N$
there are no self-loops or duplicate edges in the graph
the sum of $N$ over all test cases does not exceed $5 \cdot 10^{5}$
the sum of $M$ over all test cases does not exceed $5 \cdot 10^{5}$
------ Subtasks ------
Subtask #1 (30 points): $N,M,T ≤ 100$
Subtask #2 (70 points): original constraints
----- Sample Input 1 ------
1
5 7
1 3
1 4
1 5
2 3
2 4
2 5
3 4
----- Sample Output 1 ------
1
11000
----- explanation 1 ------
Example case 1: The only possible partition satisfying the given conditions is $A = \{1, 2\}, B = \{3, 4, 5\}$.
|
{"inputs": ["1\n5 7\n1 3\n1 4\n1 5\n2 3\n2 4\n2 5\n3 4"], "outputs": ["1\n11000"]}
| 705
| 50
|
coding
|
Solve the programming task below in a Python markdown code block.
In order to celebrate Twice's 5th anniversary, Tzuyu and Sana decided to play a game.
Tzuyu gave Sana two integers $a$ and $b$ and a really important quest.
In order to complete the quest, Sana has to output the smallest possible value of ($a \oplus x$) + ($b \oplus x$) for any given $x$, where $\oplus$ denotes the bitwise XOR operation.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^{4}$). Description of the test cases follows.
The only line of each test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^{9}$).
-----Output-----
For each testcase, output the smallest possible value of the given expression.
-----Example-----
Input
6
6 12
4 9
59 832
28 14
4925 2912
1 1
Output
10
13
891
18
6237
0
-----Note-----
For the first test case Sana can choose $x=4$ and the value will be ($6 \oplus 4$) + ($12 \oplus 4$) = $2 + 8$ = $10$. It can be shown that this is the smallest possible value.
|
{"inputs": ["6\n6 12\n4 4\n7 832\n55 8\n2891 508\n1 1\n", "6\n6 12\n4 4\n1 832\n55 8\n7888 2912\n1 2\n", "6\n6 1\n4 3\n53 832\n28 8\n4925 2912\n3 1\n", "6\n6 3\n4 3\n90 832\n28 8\n4402 2912\n3 2\n", "6\n6 12\n4 4\n90 832\n55 8\n3049 508\n1 1\n", "6\n6 1\n4 3\n53 832\n28 8\n4925 2912\n3 0\n", "6\n6 12\n4 4\n90 832\n55 8\n2891 508\n1 1\n", "6\n11 12\n5 4\n1 832\n55 8\n7888 624\n1 2\n"], "outputs": ["10\n0\n839\n63\n2743\n0\n", "10\n0\n833\n63\n5552\n3\n", "7\n7\n885\n20\n6237\n2\n", "5\n7\n794\n20\n6738\n1\n", "10\n0\n794\n63\n2581\n0\n", "7\n7\n885\n20\n6237\n3\n", "10\n0\n794\n63\n2743\n0\n", "7\n1\n833\n63\n7328\n3\n"]}
| 335
| 473
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There are n persons numbered from 0 to n - 1 and a door. Each person can enter or exit through the door once, taking one second.
You are given a non-decreasing integer array arrival of size n, where arrival[i] is the arrival time of the ith person at the door. You are also given an array state of size n, where state[i] is 0 if person i wants to enter through the door or 1 if they want to exit through the door.
If two or more persons want to use the door at the same time, they follow the following rules:
If the door was not used in the previous second, then the person who wants to exit goes first.
If the door was used in the previous second for entering, the person who wants to enter goes first.
If the door was used in the previous second for exiting, the person who wants to exit goes first.
If multiple persons want to go in the same direction, the person with the smallest index goes first.
Return an array answer of size n where answer[i] is the second at which the ith person crosses the door.
Note that:
Only one person can cross the door at each second.
A person may arrive at the door and wait without entering or exiting to follow the mentioned rules.
Please complete the following python code precisely:
```python
class Solution:
def timeTaken(self, arrival: List[int], state: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(arrival = [0,1,1,2,4], state = [0,1,0,0,1]) == [0,3,1,2,4]\n assert candidate(arrival = [0,0,0], state = [1,0,1]) == [0,2,1]\n\n\ncheck(Solution().timeTaken)"}
| 315
| 93
|
coding
|
Solve the programming task below in a Python markdown code block.
You wish to buy video games from the famous online video game store Mist.
Usually, all games are sold at the same price, $\boldsymbol{p}$ dollars. However, they are planning to have the seasonal Halloween Sale next month in which you can buy games at a cheaper price. Specifically, the first game will cost $\boldsymbol{p}$ dollars, and every subsequent game will cost $\boldsymbol{d}$ dollars less than the previous one. This continues until the cost becomes less than or equal to $m$ dollars, after which every game will cost $m$ dollars. How many games can you buy during the Halloween Sale?
Example
$p=20$
$\boldsymbol{d}=3$
$m=6$
$s=70$.
The following are the costs of the first $\mbox{11}$, in order:
$20,17,14,11,8,6,6,6,6,6,6$
Start at $p=20$ units cost, reduce that by $\boldsymbol{d}=3$ units each iteration until reaching a minimum possible price, $m=6$. Starting with $s=70$ units of currency in your Mist wallet, you can buy 5 games: $20+17+14+11+8=70$.
Function Description
Complete the howManyGames function in the editor below.
howManyGames has the following parameters:
int p: the price of the first game
int d: the discount from the previous game price
int m: the minimum cost of a game
int s: the starting budget
Input Format
The first and only line of input contains four space-separated integers $\boldsymbol{p}$, $\boldsymbol{d}$, $m$ and $\boldsymbol{\mathrm{~s~}}$.
Constraints
$1\leq m\leq p\leq100$
$1\leq d\leq100$
$1\leq s\leq10^4$
Sample Input 0
20 3 6 80
Sample Output 0
6
Explanation 0
Assumptions other than starting funds, $\boldsymbol{\mathrm{~S~}}$, match the example in the problem statement. With a budget of $\textbf{80}$, you can buy $\boldsymbol{6}$ games at a cost of $20+17+14+11+8+6=76$. A $7^{th}$ game for an additional $\boldsymbol{6}$ units exceeds the budget.
Sample Input 1
20 3 6 85
Sample Output 1
7
Explanation 1
This is the same as the previous case, except this time the starting budget $s=85$ units of currency. This time, you can buy $7$ games since they cost $20+17+14+11+8+6+6=82$. An additional game at $\boldsymbol{6}$ units will exceed the budget.
|
{"inputs": ["20 3 6 80\n", "20 3 6 85\n"], "outputs": ["6\n", "7\n"]}
| 677
| 38
|
coding
|
Solve the programming task below in a Python markdown code block.
Many modern text editors automatically check the spelling of the user's text. Some editors even suggest how to correct typos.
In this problem your task to implement a small functionality to correct two types of typos in a word. We will assume that three identical letters together is a typo (for example, word "helllo" contains a typo). Besides, a couple of identical letters immediately followed by another couple of identical letters is a typo too (for example, words "helloo" and "wwaatt" contain typos).
Write a code that deletes the minimum number of letters from a word, correcting described typos in the word. You are allowed to delete letters from both ends and from the middle of the word.
-----Input-----
The single line of the input contains word s, its length is from 1 to 200000 characters. The given word s consists of lowercase English letters.
-----Output-----
Print such word t that it doesn't contain any typos described in the problem statement and is obtained from s by deleting the least number of letters.
If there are multiple solutions, print any of them.
-----Examples-----
Input
helloo
Output
hello
Input
woooooow
Output
woow
-----Note-----
The second valid answer to the test from the statement is "heloo".
|
{"inputs": ["x\n", "x\n", "y\n", "z\n", "{\n", "|\n", "zz\n", "xy\n"], "outputs": ["x\n", "x\n", "y\n", "z\n", "{\n", "|\n", "zz\n", "xy\n"]}
| 283
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef came across a new online judge that has N problems, and decided that he wants to solve them.
Chef takes A_{i} consecutive minutes to solve the i-th problem, and will take a break of B_{i} minutes immediately after solving it.
That is, Chef will solve a problem, then take a break. Solve another problem, then take another break, and so on.
Chef has K minutes of free time. If he chooses the problems and their order optimally, what is the maximum number of problems he can solve in this time?
Note that a problem is considered solved if Chef finishes solving it by the K-th minute, even if the break time of the last problem extends past minute K. See the sample tests below for an example.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- Each test case consists of three lines of input.
- The first line of each test case contains two space-separated integers N and K — the number of problems in the online judge and Chef's free time, respectively.
- The second line of each test case contains N space-separated integers — the values A_{1}, A_{2}, \ldots, A_{N}.
- The third line of each test case contains N space-separated integers — the values B_{1}, B_{2}, \ldots, B_{N}.
------ Output Format ------
For each test case, output on a new line the maximum number of problems that Chef can solve within K minutes.
------ Constraints ------
$1 ≤ T ≤ 2\cdot 10^{4}$
$1 ≤ N ≤ 2\cdot 10^{5}$
$1 ≤ K ≤ 10^{8}$
$1 ≤ A_{i} ≤ 10^{8}$
$0 ≤ B_{i} ≤ 10^{8}$
- The sum of $N$ over all test cases won't exceed $2\cdot 10^{5}$.
----- Sample Input 1 ------
4
3 10
3 4 5
2 4 2
3 8
3 4 5
2 4 2
5 20
23 54 124 54 83
2 9 5 2 10
5 20
4 7 12 34 13
30 4 3 0 9
----- Sample Output 1 ------
2
1
0
2
----- explanation 1 ------
Test case $1$: Chef can solve the first problem followed by the second problem.
- $3$ minutes for the first problem
- $2$ minutes of break time after solving it, for a total of $5$ minutes
- $5$ minutes for the third problem, for a total of $10$ minutes
- There's two minutes of break time left which goes beyond $10$ minutes, but that's ok: Chef finished solving $2$ problems within $10$ minutes.
Test case $2$: The same times as the first sample, but with $K = 8$. Now, Chef can solve any one problem, but cannot solve a second one no matter what.
Test case $3$: Chef can't solve anything within $20$ minutes.
Test case $4$: Chef can solve the third problem followed by the first problem.
|
{"inputs": ["4\n3 10\n3 4 5\n2 4 2\n3 8\n3 4 5\n2 4 2\n5 20\n23 54 124 54 83\n2 9 5 2 10\n5 20\n4 7 12 34 13\n30 4 3 0 9\n"], "outputs": ["2\n1\n0\n2\n"]}
| 736
| 114
|
coding
|
Solve the programming task below in a Python markdown code block.
Given is an integer x that is greater than or equal to 0, and less than or equal to 1.
Output 1 if x is equal to 0, or 0 if x is equal to 1.
-----Constraints-----
- 0 \leq x \leq 1
- x is an integer
-----Input-----
Input is given from Standard Input in the following format:
x
-----Output-----
Print 1 if x is equal to 0, or 0 if x is equal to 1.
-----Sample Input-----
1
-----Sample Output-----
0
|
{"inputs": ["1", "0", "1\n", "0\n", "000", "000"], "outputs": ["0", "1", "0\n", "1\n", "1\n", "1\n"]}
| 133
| 52
|
coding
|
Solve the programming task below in a Python markdown code block.
The Quark Codejam's number QC(n, m) represents the number of ways to partition a set of n things into m nonempty subsets. For example, there are seven ways to split a four-element set into two parts:
{1, 2, 3} ∪ {4}, {1, 2, 4} ∪ {3}, {1, 3, 4} ∪ {2}, {2, 3, 4} ∪ {1},
{1, 2} ∪ {3, 4}, {1, 3} ∪ {2, 4}, {1, 4} ∪ {2, 3}.
We can compute QC(n, m) using the recurrence,
QC(n, m) = mQC(n − 1, m) + QC(n − 1, m − 1), for integers 1 < m < n.
but your task is a somewhat different: given integers n and m, compute the parity of QC(n, m), i.e. QC(n, m) mod 2.
Example :
QC(4, 2) mod 2 = 1.
Write a program that reads two positive integers n and m, computes QC(n, m) mod 2, and writes the
result.
-----Input-----
The input begins with a single positive integer on a line by itself indicating the number of the cases. This line is followed by the input cases.
The input consists two integers n and m separated by a space, with 1 ≤ m ≤ n ≤ 1000000000.
-----Output-----
For each test case, print the output.
The output should be the integer S(n, m) mod 2.
Sample Input
1
4 2
Sample Output
1
|
{"inputs": ["1\n4 2"], "outputs": ["1"]}
| 393
| 16
|
coding
|
Solve the programming task below in a Python markdown code block.
Today a plane was hijacked by a maniac. All the passengers of the flight are taken as hostage. Chef is also one of them.
He invited one of the passengers to play a game with him. If he loses the game, he will release all the passengers, otherwise he will kill all of them. A high risk affair it is.
Chef volunteered for this tough task. He was blindfolded by Hijacker. Hijacker brought a big black bag from his pockets. The contents of the bag is not visible. He tells Chef that the bag contains R red, G green and B blue colored balloons.
Hijacker now asked Chef to take out some balloons from the box such that there are at least K balloons of the same color and hand him over. If the taken out balloons does not contain at least K balloons of the same color, then the hijacker will shoot everybody. Chef is very scared and wants to leave this game as soon as possible, so he will draw the minimum number of balloons so as to save the passengers. Can you please help scared Chef to find out the minimum number of balloons he should take out.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a three space-separated integers R, G and B.
The second line contains only one integer K.
-----Output-----
For each test case, output a single line containing one integer - the minimum number of balloons Chef need to take out from the bag.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ R, G, B ≤ 109
- 1 ≤ K ≤ max{R, G, B}
-----Subtasks-----
- Subtask 1 (44 points): 1 ≤ R, G, B ≤ 10
- Subtask 2 (56 points): No additional constraints
-----Example-----
Input:
2
3 3 3
1
3 3 3
2
Output:
1
4
-----Explanation-----
Example case 2. In the worst-case scenario first three balloons will be of the three different colors and only after fourth balloon Chef will have two balloons of the same color. So, Chef might need to fetch 4 balloons
|
{"inputs": ["2\n3 3 3\n1\n3 3 3\n2"], "outputs": ["1\n4"]}
| 495
| 30
|
coding
|
Solve the programming task below in a Python markdown code block.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a_1, a_2, ..., a_{n} are good.
Now she is interested in good sequences. A sequence x_1, x_2, ..., x_{k} is called good if it satisfies the following three conditions: The sequence is strictly increasing, i.e. x_{i} < x_{i} + 1 for each i (1 ≤ i ≤ k - 1). No two adjacent elements are coprime, i.e. gcd(x_{i}, x_{i} + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q). All elements of the sequence are good integers.
Find the length of the longest good sequence.
-----Input-----
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of good integers. The second line contains a single-space separated list of good integers a_1, a_2, ..., a_{n} in strictly increasing order (1 ≤ a_{i} ≤ 10^5; a_{i} < a_{i} + 1).
-----Output-----
Print a single integer — the length of the longest good sequence.
-----Examples-----
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
-----Note-----
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
|
{"inputs": ["1\n1\n", "1\n4\n", "1\n1\n", "1\n4\n", "1\n2\n", "1\n3\n", "1\n5\n", "1\n6\n"], "outputs": ["1\n", "1\n", "1", "1", "1\n", "1\n", "1\n", "1\n"]}
| 414
| 84
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a program which computes the digit number of sum of two integers a and b.
Constraints
* 0 ≤ a, b ≤ 1,000,000
* The number of datasets ≤ 200
Input
There are several test cases. Each test case consists of two non-negative integers a and b which are separeted by a space in a line. The input terminates with EOF.
Output
Print the number of digits of a + b for each data set.
Example
Input
5 7
1 99
1000 999
Output
2
3
4
|
{"inputs": ["0 1\n2 3\n1001 6", "0 0\n3 0\n0101 6", "1 1\n5 0\n0001 6", "1 1\n5 0\n0001 9", "0 1\n2 3\n1011 6", "0 1\n2 3\n1101 6", "0 0\n2 3\n1101 6", "0 0\n3 3\n1101 6"], "outputs": ["1\n1\n4\n", "1\n1\n3\n", "1\n1\n1\n", "1\n1\n2\n", "1\n1\n4\n", "1\n1\n4\n", "1\n1\n4\n", "1\n1\n4\n"]}
| 145
| 198
|
coding
|
Solve the programming task below in a Python markdown code block.
Cowboy Vlad has a birthday today! There are $n$ children who came to the celebration. In order to greet Vlad, the children decided to form a circle around him. Among the children who came, there are both tall and low, so if they stand in a circle arbitrarily, it may turn out, that there is a tall and low child standing next to each other, and it will be difficult for them to hold hands. Therefore, children want to stand in a circle so that the maximum difference between the growth of two neighboring children would be minimal possible.
Formally, let's number children from $1$ to $n$ in a circle order, that is, for every $i$ child with number $i$ will stand next to the child with number $i+1$, also the child with number $1$ stands next to the child with number $n$. Then we will call the discomfort of the circle the maximum absolute difference of heights of the children, who stand next to each other.
Please help children to find out how they should reorder themselves, so that the resulting discomfort is smallest possible.
-----Input-----
The first line contains a single integer $n$ ($2 \leq n \leq 100$) — the number of the children who came to the cowboy Vlad's birthday.
The second line contains integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) denoting heights of every child.
-----Output-----
Print exactly $n$ integers — heights of the children in the order in which they should stand in a circle. You can start printing a circle with any child.
If there are multiple possible answers, print any of them.
-----Examples-----
Input
5
2 1 1 3 2
Output
1 2 3 2 1
Input
3
30 10 20
Output
10 20 30
-----Note-----
In the first example, the discomfort of the circle is equal to $1$, since the corresponding absolute differences are $1$, $1$, $1$ and $0$. Note, that sequences $[2, 3, 2, 1, 1]$ and $[3, 2, 1, 1, 2]$ form the same circles and differ only by the selection of the starting point.
In the second example, the discomfort of the circle is equal to $20$, since the absolute difference of $10$ and $30$ is equal to $20$.
|
{"inputs": ["2\n8 1\n", "2\n5 32\n", "2\n5 42\n", "2\n5 28\n", "2\n5 16\n", "2\n5 27\n", "2\n5 17\n", "2\n9 17\n"], "outputs": ["1 8\n", "5 32\n", "5 42\n", "5 28\n", "5 16\n", "5 27\n", "5 17\n", "9 17\n"]}
| 558
| 132
|
coding
|
Solve the programming task below in a Python markdown code block.
Find \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}.
Here \gcd(a,b,c) denotes the greatest common divisor of a, b, and c.
-----Constraints-----
- 1 \leq K \leq 200
- K is an integer.
-----Input-----
Input is given from Standard Input in the following format:
K
-----Output-----
Print the value of \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}.
-----Sample Input-----
2
-----Sample Output-----
9
\gcd(1,1,1)+\gcd(1,1,2)+\gcd(1,2,1)+\gcd(1,2,2)+\gcd(2,1,1)+\gcd(2,1,2)+\gcd(2,2,1)+\gcd(2,2,2)=1+1+1+1+1+1+1+2=9
Thus, the answer is 9.
|
{"inputs": ["4", "8", "3", "5", "7", "0", "1", "9"], "outputs": ["76\n", "624\n", "30\n", "141\n", "400\n", "0\n", "1\n", "885\n"]}
| 267
| 72
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the root of a binary search tree, return a balanced binary search tree with the same node values. If there is more than one answer, return any of them.
A binary search tree is balanced if the depth of the two subtrees of every node never differs by more than 1.
Please complete the following python code precisely:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def balanceBST(self, root: TreeNode) -> TreeNode:
```
|
{"functional": "def check(candidate):\n assert is_same_tree(candidate(root = tree_node([1,None,2,None,3,None,4,None,None])), tree_node([2,1,3,None,None,None,4]))\n\n\ncheck(Solution().balanceBST)"}
| 158
| 59
|
coding
|
Solve the programming task below in a Python markdown code block.
~~~if-not:java
You have to code a function **getAllPrimeFactors** wich take an integer as parameter and return an array containing its prime decomposition by ascending factors, if a factors appears multiple time in the decomposition it should appear as many time in the array.
exemple: `getAllPrimeFactors(100)` returns `[2,2,5,5]` in this order.
This decomposition may not be the most practical.
You should also write **getUniquePrimeFactorsWithCount**, a function which will return an array containing two arrays: one with prime numbers appearing in the decomposition and the other containing their respective power.
exemple: `getUniquePrimeFactorsWithCount(100)` returns `[[2,5],[2,2]]`
You should also write **getUniquePrimeFactorsWithProducts** an array containing the prime factors to their respective powers.
exemple: `getUniquePrimeFactorsWithProducts(100)` returns `[4,25]`
~~~
~~~if:java
You have to code a function **getAllPrimeFactors** wich take an integer as parameter and return an array containing its prime decomposition by ascending factors, if a factors appears multiple time in the decomposition it should appear as many time in the array.
exemple: `getAllPrimeFactors(100)` returns `[2,2,5,5]` in this order.
This decomposition may not be the most practical.
You should also write **getUniquePrimeFactorsWithCount**, a function which will return an array containing two arrays: one with prime numbers appearing in the decomposition and the other containing their respective power.
exemple: `getUniquePrimeFactorsWithCount(100)` returns `[[2,5],[2,2]]`
You should also write **getPrimeFactorPotencies** an array containing the prime factors to their respective powers.
exemple: `getPrimeFactorPotencies(100)` returns `[4,25]`
~~~
Errors, if:
* `n` is not a number
* `n` not an integer
* `n` is negative or 0
The three functions should respectively return `[]`, `[[],[]]` and `[]`.
Edge cases:
* if `n=0`, the function should respectively return `[]`, `[[],[]]` and `[]`.
* if `n=1`, the function should respectively return `[1]`, `[[1],[1]]`, `[1]`.
* if `n=2`, the function should respectively return `[2]`, `[[2],[1]]`, `[2]`.
The result for `n=2` is normal. The result for `n=1` is arbitrary and has been chosen to return a usefull result. The result for `n=0` is also arbitrary
but can not be chosen to be both usefull and intuitive. (`[[0],[0]]` would be meaningfull but wont work for general use of decomposition, `[[0],[1]]` would work but is not intuitive.)
Also feel free to reuse/extend the following starter code:
```python
def getAllPrimeFactors(n):
```
|
{"functional": "_inputs = [[10], [100], [1000], [1000001], [0], [1], [2], ['a'], [1.1], [-1]]\n_outputs = [[[2, 5]], [[2, 2, 5, 5]], [[2, 2, 2, 5, 5, 5]], [[101, 9901]], [[]], [[1]], [[2]], [[]], [[]], [[]]]\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(getAllPrimeFactors(*i), o[0])"}
| 671
| 255
|
coding
|
Solve the programming task below in a Python markdown code block.
In this problem, a $n \times m$ rectangular matrix $a$ is called increasing if, for each row of $i$, when go from left to right, the values strictly increase (that is, $a_{i,1}<a_{i,2}<\dots<a_{i,m}$) and for each column $j$, when go from top to bottom, the values strictly increase (that is, $a_{1,j}<a_{2,j}<\dots<a_{n,j}$).
In a given matrix of non-negative integers, it is necessary to replace each value of $0$ with some positive integer so that the resulting matrix is increasing and the sum of its elements is maximum, or find that it is impossible.
It is guaranteed that in a given value matrix all values of $0$ are contained only in internal cells (that is, not in the first or last row and not in the first or last column).
-----Input-----
The first line contains integers $n$ and $m$ ($3 \le n, m \le 500$) — the number of rows and columns in the given matrix $a$.
The following lines contain $m$ each of non-negative integers — the values in the corresponding row of the given matrix: $a_{i,1}, a_{i,2}, \dots, a_{i,m}$ ($0 \le a_{i,j} \le 8000$).
It is guaranteed that for all $a_{i,j}=0$, $1 < i < n$ and $1 < j < m$ are true.
-----Output-----
If it is possible to replace all zeros with positive numbers so that the matrix is increasing, print the maximum possible sum of matrix elements. Otherwise, print -1.
-----Examples-----
Input
4 5
1 3 5 6 7
3 0 7 0 9
5 0 0 0 10
8 9 10 11 12
Output
144
Input
3 3
1 2 3
2 0 4
4 5 6
Output
30
Input
3 3
1 2 3
3 0 4
4 5 6
Output
-1
Input
3 3
1 2 3
2 3 4
3 4 2
Output
-1
-----Note-----
In the first example, the resulting matrix is as follows:
1 3 5 6 7
3 6 7 8 9
5 7 8 9 10
8 9 10 11 12
In the second example, the value $3$ must be put in the middle cell.
In the third example, the desired resultant matrix does not exist.
|
{"inputs": ["3 3\n1 2 3\n2 0 4\n4 5 6\n", "3 3\n1 2 3\n3 0 4\n4 5 6\n", "3 3\n1 2 3\n2 3 4\n3 4 2\n", "3 3\n1 1 1\n1 1 1\n1 1 1\n", "3 3\n1 2 3\n2 3 4\n3 4 4\n", "3 3\n1 2 3\n2 3 4\n3 5 5\n", "3 3\n1 2 3\n2 3 5\n3 4 5\n", "3 3\n1 2 3\n2 3 4\n3 5 5\n"], "outputs": ["30\n", "-1\n", "-1\n", "-1\n", "-1\n", "-1\n", "-1\n", "-1\n"]}
| 619
| 231
|
coding
|
Solve the programming task below in a Python markdown code block.
There is unrest in the Galactic Senate. Several thousand solar systems have declared their intentions to leave the Republic. Master Heidi needs to select the Jedi Knights who will go on peacekeeping missions throughout the galaxy. It is well-known that the success of any peacekeeping mission depends on the colors of the lightsabers of the Jedi who will go on that mission.
Heidi has n Jedi Knights standing in front of her, each one with a lightsaber of one of m possible colors. She knows that for the mission to be the most effective, she needs to select some contiguous interval of knights such that there are exactly k_1 knights with lightsabers of the first color, k_2 knights with lightsabers of the second color, ..., k_{m} knights with lightsabers of the m-th color.
However, since the last time, she has learned that it is not always possible to select such an interval. Therefore, she decided to ask some Jedi Knights to go on an indefinite unpaid vacation leave near certain pits on Tatooine, if you know what I mean. Help Heidi decide what is the minimum number of Jedi Knights that need to be let go before she is able to select the desired interval from the subsequence of remaining knights.
-----Input-----
The first line of the input contains n (1 ≤ n ≤ 2·10^5) and m (1 ≤ m ≤ n). The second line contains n integers in the range {1, 2, ..., m} representing colors of the lightsabers of the subsequent Jedi Knights. The third line contains m integers k_1, k_2, ..., k_{m} (with $1 \leq \sum_{i = 1}^{m} k_{i} \leq n$) – the desired counts of Jedi Knights with lightsabers of each color from 1 to m.
-----Output-----
Output one number: the minimum number of Jedi Knights that need to be removed from the sequence so that, in what remains, there is an interval with the prescribed counts of lightsaber colors. If this is not possible, output - 1.
-----Example-----
Input
8 3
3 3 1 2 2 1 1 3
3 1 1
Output
1
|
{"inputs": ["1 1\n1\n1\n", "1 1\n1\n1\n", "2 1\n1 1\n1\n", "2 1\n1 1\n2\n", "2 1\n1 1\n2\n", "2 1\n1 1\n1\n", "2 2\n1 2\n1 1\n", "2 2\n2 2\n1 1\n"], "outputs": ["0\n", "0", "0\n", "0\n", "0", "0", "0\n", "-1\n"]}
| 484
| 131
|
coding
|
Solve the programming task below in a Python markdown code block.
# Base reduction
## Input
A positive integer:
```
0 < n < 1000000000
```
## Output
The end result of the base reduction.
If it cannot be fully reduced (reduced down to a single-digit number), return -1.
Assume that if 150 conversions from base 11 take place in a row, the number cannot be fully reduced.
## Description
Base reduction is a process where a number is inputted, repeatedly converted into another base, and then outputted if it cannot be reduced anymore. If it cannot be fully reduced, return -1.
During the base conversions, the number is converted from the lowest base it can be converted from into base 10. For example, 123 would be converted from base 4 to base 10, since base 4 is the lowest base that 123 can be in (123 base 3 is impossible; in base 3, there is no digit 3).
If the lowest possible base the number can be converted into is 10, convert the number from base 11 to base 10. For example, 53109 would be converted from base 11 to base 10, since base 10 is the lowest base it can be in.
In the end, you should get a number that cannot be reduced by this process (a single digit number).
## Example
Starting with 5312:
```
5312 base 6 = 1196 base 10
1196 base 11 = 1557 base 10
1557 base 8 = 879 base 10
879 base 11 = 1054 base 10
1054 base 6 = 250 base 10
250 base 6 = 102 base 10
102 base 3 = 11 base 10
11 base 2 = 3 base 10
```
The output would be 3.
Also feel free to reuse/extend the following starter code:
```python
def basereduct(x):
```
|
{"functional": "_inputs = [[10], [5], [7], [7], [15]]\n_outputs = [[2], [5], [7], [7], [3]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(basereduct(*i), o[0])"}
| 493
| 181
|
coding
|
Solve the programming task below in a Python markdown code block.
The Chef has been kidnapped by aliens ( they want to utilize his excellent cooking skills :P ) and has been transported to the alien planet "ZX532". Interestingly, "ZX532" uses a different time scale which has Y AlienHours on the face of a clock (instead of the 12 hours that we have). They also have 'X*Y' AlienMinutes (instead of the 60 that we have). X is defined as the number of minute divisions between each hour (the earth clock has X=5).
The Chef has been forced to cook a lot of dishes by the aliens. He is short of ingredients and hence needs to go out to the market to get them. However when he returns, he makes an interesting observation. The hands of AlienClock have exactly swapped position from the time he left (the big hand and the little hand have switched)!
Given the times between which The Chef might have left and the times between which The Chef may have returned, you are supposed to find out the actual time when he left. If there is more than one possibility, print the one that maximizes the amount of time that The Chef is out.Details of the Clock
The AlienClock is circular and has exactly 2 hands : the hour hand and the minute hand. The whole circumference of the AlienClock is divided into Y divisions , each of which is further divided into X subdivisions [ X and Y are both positive integers ]. The clock is not discrete but continuous (the hands move continuously instead of moving at certain intervals such as every second, etc.... ).
-----Input-----
First line of input contains t (1≤ t ≤ 100) - the number of test cases. Each test case contains 2 lines each. The first line contains 2 space separated integers , X and Y (same as those specified in the problem statement; X ≤ 109 and Y ≤ 109 ).
The next line contains 8 space separated integers (a,b,c,d,e,f,g,h; 0 ≤ a ≤ c < Y; 0 ≤ e ≤ g < Y; a ≤ e; 0 ≤ b,d,f,h < X*Y ): specifying the times between which The Chef might have left (a:b => a hours and b minutes TO c:d => c hours and d minutes) and the times between which The Chef may have returned (The Chef returns sometime between e:f and g:h).
The interval at which The Chef re-enters the kitchen will never start prior to the interval at which he first leaves the kitchen to purchase the ingredients.
-----Output-----
The output should contain one line for each test case specifying the time when The Chef left the kitchen. This should be in the form (h:m => h hours and m minutes). h will be an integer, and m should be rounded to 2 decimal places. In case, there is no solution possible, output -1 for that test case.
-----Example-----
Input:
3
5 12
1 0 2 0 4 0 5 0
5 12
3 30 4 0 5 0 6 0
5 12
3 0 4 0 5 0 6 0
Output:
1:20.56
-1
3:26.43
Note: Be careful with precision.
|
{"inputs": ["3\n5 12\n1 0 2 0 4 0 5 0\n5 12\n3 30 4 0 5 0 6 0\n5 12\n3 0 4 0 5 0 6 0\n\n"], "outputs": ["1:20.56\n-1\n3:26.43"]}
| 714
| 95
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
A car travels from a starting position to a destination which is target miles east of the starting position.
There are gas stations along the way. The gas stations are represented as an array stations where stations[i] = [positioni, fueli] indicates that the ith gas station is positioni miles east of the starting position and has fueli liters of gas.
The car starts with an infinite tank of gas, which initially has startFuel liters of fuel in it. It uses one liter of gas per one mile that it drives. When the car reaches a gas station, it may stop and refuel, transferring all the gas from the station into the car.
Return the minimum number of refueling stops the car must make in order to reach its destination. If it cannot reach the destination, return -1.
Note that if the car reaches a gas station with 0 fuel left, the car can still refuel there. If the car reaches the destination with 0 fuel left, it is still considered to have arrived.
Please complete the following python code precisely:
```python
class Solution:
def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(target = 1, startFuel = 1, stations = []) == 0\n assert candidate(target = 100, startFuel = 1, stations = [[10,100]]) == -1\n assert candidate(target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]) == 2\n\n\ncheck(Solution().minRefuelStops)"}
| 266
| 121
|
coding
|
Solve the programming task below in a Python markdown code block.
The chef was not happy with the binary number system, so he designed a new machine which is having 6 different states, i.e. in binary there is a total of 2 states as 0 and 1. Now, the chef is confused about how to correlate this machine to get an interaction with Integer numbers, when N(Integer number) is provided to the system, what will be the Nth number that system will return(in Integer form), help the chef to design this system.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, $N$.
-----Output:-----
For each test case, output in a single line answer given by the system.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^5$
-----Sample Input:-----
2
3
5
-----Sample Output:-----
7
37
-----EXPLANATION:-----
Initial numbers for system = [1, 6, 7, 36, 37, 42, 43, 216, …..
For 1) 3rd Number for the system will be 7.
For 2) 5th Number for the system will be 37.
|
{"inputs": ["2\n3\n5"], "outputs": ["7\n37"]}
| 304
| 19
|
coding
|
Solve the programming task below in a Python markdown code block.
To access CRED programs, one needs to have a credit score of 750 or more.
Given that the present credit score is X, determine if one can access CRED programs or not.
If it is possible to access CRED programs, output \texttt{YES}, otherwise output \texttt{NO}.
------ Input Format ------
The first and only line of input contains a single integer X, the credit score.
------ Output Format ------
Print \texttt{YES} if it is possible to access CRED programs. Otherwise, print \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 ------
$0 ≤ X ≤ 1000$
------ subtasks ------
Subtask 1 (100 points): Original constraints.
----- Sample Input 1 ------
823
----- Sample Output 1 ------
YES
----- explanation 1 ------
Since $823 ≥ 750$, it is possible to access CRED programs.
----- Sample Input 2 ------
251
----- Sample Output 2 ------
NO
----- explanation 2 ------
Since $251 < 750$, it is not possible to access CRED programs.
|
{"inputs": ["823", "251"], "outputs": ["YES", "NO"]}
| 313
| 22
|
coding
|
Solve the programming task below in a Python markdown code block.
We have N clocks. The hand of the i-th clock (1≤i≤N) rotates through 360° in exactly T_i seconds.
Initially, the hand of every clock stands still, pointing directly upward.
Now, Dolphin starts all the clocks simultaneously.
In how many seconds will the hand of every clock point directly upward again?
-----Constraints-----
- 1≤N≤100
- 1≤T_i≤10^{18}
- All input values are integers.
- The correct answer is at most 10^{18} seconds.
-----Input-----
Input is given from Standard Input in the following format:
N
T_1
:
T_N
-----Output-----
Print the number of seconds after which the hand of every clock point directly upward again.
-----Sample Input-----
2
2
3
-----Sample Output-----
6
We have two clocks. The time when the hand of each clock points upward is as follows:
- Clock 1: 2, 4, 6, ... seconds after the beginning
- Clock 2: 3, 6, 9, ... seconds after the beginning
Therefore, it takes 6 seconds until the hands of both clocks point directly upward.
|
{"inputs": ["2\n2\n5", "2\n3\n5", "2\n3\n3", "2\n3\n7", "2\n3\n9", "2\n3\n4", "2\n3\n6", "2\n0\n6"], "outputs": ["10\n", "15\n", "3\n", "21\n", "9\n", "12\n", "6\n", "0\n"]}
| 272
| 98
|
coding
|
Solve the programming task below in a Python markdown code block.
Vasya and Petya are playing a simple game. Vasya thought of number x between 1 and n, and Petya tries to guess the number.
Petya can ask questions like: "Is the unknown number divisible by number y?".
The game is played by the following rules: first Petya asks all the questions that interest him (also, he can ask no questions), and then Vasya responds to each question with a 'yes' or a 'no'. After receiving all the answers Petya should determine the number that Vasya thought of.
Unfortunately, Petya is not familiar with the number theory. Help him find the minimum number of questions he should ask to make a guaranteed guess of Vasya's number, and the numbers yi, he should ask the questions about.
Input
A single line contains number n (1 ≤ n ≤ 103).
Output
Print the length of the sequence of questions k (0 ≤ k ≤ n), followed by k numbers — the questions yi (1 ≤ yi ≤ n).
If there are several correct sequences of questions of the minimum length, you are allowed to print any of them.
Examples
Input
4
Output
3
2 4 3
Input
6
Output
4
2 4 3 5
Note
The sequence from the answer to the first sample test is actually correct.
If the unknown number is not divisible by one of the sequence numbers, it is equal to 1.
If the unknown number is divisible by 4, it is 4.
If the unknown number is divisible by 3, then the unknown number is 3.
Otherwise, it is equal to 2. Therefore, the sequence of questions allows you to guess the unknown number. It can be shown that there is no correct sequence of questions of length 2 or shorter.
|
{"inputs": ["1\n", "3\n", "2\n", "8\n", "5\n", "7\n", "9\n", "4\n"], "outputs": ["0\n", "2\n2 3\n", "1\n2\n", "6\n2 4 8 3 5 7\n", "4\n2 4 3 5\n", "5\n2 4 3 5 7\n", "7\n2 4 8 3 9 5 7\n", "3\n2 4 3 "]}
| 400
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
Let's define a `parameter` of number `n` as the least common multiple (LCM) of the sum of its digits and their product.
Calculate the parameter of the given number `n`.
# Input/Output
`[input]` integer `n`
A positive integer. It is guaranteed that no zero appears in `n`.
`[output]` an integer
The parameter of the given number.
# Example
For `n = 22`, the output should be `4`.
Both the sum and the product of digits equal 4, and LCM(4, 4) = 4.
For `n = 1234`, the output should be `120`.
`1+2+3+4=10` and `1*2*3*4=24`, LCM(10,24)=120
Also feel free to reuse/extend the following starter code:
```python
def parameter(n):
```
|
{"functional": "_inputs = [[1234], [1], [2], [22], [11], [239], [999999999], [91], [344], [123456789]]\n_outputs = [[120], [1], [2], [4], [2], [378], [387420489], [90], [528], [362880]]\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(parameter(*i), o[0])"}
| 221
| 253
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an integer N. Build an undirected graph with N vertices with indices 1 to N that satisfies the following two conditions:
* The graph is simple and connected.
* There exists an integer S such that, for every vertex, the sum of the indices of the vertices adjacent to that vertex is S.
It can be proved that at least one such graph exists under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 100
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print the number of edges, M, in the graph you made. In the i-th of the following M lines, print two integers a_i and b_i, representing the endpoints of the i-th edge.
The output will be judged correct if the graph satisfies the conditions.
Example
Input
3
Output
2
1 3
2 3
|
{"inputs": ["0", "4", "1", "2", "2", "0", "1", "4"], "outputs": ["0\n", "4\n1 2\n1 3\n2 4\n3 4\n", "0\n", "0\n", "0\n", "0\n", "0\n", "4\n1 2\n1 3\n2 4\n3 4\n"]}
| 214
| 94
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef loves bitwise operations. So, he creates the following problem but needs your help to solve it.
Chef calls a sequence of integers A_{1}, A_{2}, \ldots, A_{N} tasty if it satisfies the following condition:
parity(A_{i} \& A_{i+1}) \neq parity(A_{i} | A_{i+1}) for 1 ≤ i < N.
Chef gives you a sequence A_{1}, A_{2}, \ldots, A_{N}. You may perform the following operation on the sequence any number of times (possibly 0):
Choose 2 indices i and j (1 ≤ i, j ≤ n ; i \neq j) and change A_{i} to A_{i} \oplus A_{j}.
Chef is asking you to make the sequence tasty using the minimum number of operations, or report that it is impossible.
As a friendly reminder,
parity(x) denotes the remainder of dividing x by 2
\& denotes the [bitwise AND operation]
| denotes the [bitwise OR operation]
\oplus denotes the [bitwise XOR operation].
------ Input Format ------
- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains a single integer N.
- The second line contains N space-separated integers A_{1}, A_{2}, \ldots, A_{N}.
------ Output Format ------
For each test case:
- If it is impossible to convert the given sequence into a tasty sequence using the given operations, print a single line containing the integer -1.
- Otherwise, first, print a line containing a single integer M ― the minimum number of operations you have to perform.
- Then, print M lines describing these operations in the order in which you want to perform them. For each k (1 ≤ k ≤ M), the k-th of these lines should contain two space-separated integers i and j (1 ≤ i, j ≤ n ; i \neq j) ― the indices on which the k-th operation is performed.
If there are multiple solutions, you may find any one of them.
------ Constraints ------
$1 ≤ T ≤ 3 \cdot 10^{3}$
$2 ≤ N ≤ 10^{5}$
$0 ≤ A_{i} < 2^{30}$ for each valid $i$
- The sum of $N$ over all test cases does not exceed $2 \cdot 10^{5}$
------ subtasks ------
Subtask #1 (100 points): Original constraints
----- Sample Input 1 ------
2
2
0 0
3
6 16 69
----- Sample Output 1 ------
-1
1
1 3
----- explanation 1 ------
Test case $1$: It is impossible to make $A$ tasty using the given operations.
Test case $2$: We can choose $i=1$ and $j=3$ and apply the operation which converts $A$ into $[\textcolor{blue}{67},16,\textcolor{blue}{69}]$ which is tasty.
|
{"inputs": ["2\n2\n0 0\n3\n6 16 69"], "outputs": ["-1\n1\n1 3"]}
| 692
| 35
|
coding
|
Solve the programming task below in a Python markdown code block.
A: A-Z Cat / A-Z Cat
story
Aizunyan is a second-year student who belongs to the programming contest club of Wakagamatsu High School, commonly known as the Prokon club. It's so cute. Aizu Nyan was asked by her friend Joy to take care of her cat. It is a rare cat called A-Z cat. Aizunyan named the A-Z cat he had entrusted to him as "Aizunyan No. 2" (without permission), and he was very much loved.
A-Z cats are said to prefer strings that meet certain conditions. Then, when Aizunyan gave a character string as a trial, Aizunyan No. 2 had a satisfying expression after cutting a part of the character string with his nails. Apparently, I'm trying to rewrite it to my favorite character string.
D, who is crazy about Aizu Nyan, who is cute like an angel, found out the character string conditions that A-Z Cat likes for Aizu Nyan. It is a string in which'A'and'Z'are repeated alternately, and a string that starts with'A' and ends with'Z'. The A-Z cat is so smart that it tries to convert it to a string of your choice with minimal erasing. D, who wants to look good, decided to write a program to find out what kind of string the A-Z cat would convert from a given string consisting only of'A'and'Z'.
problem
Given a string S consisting only of uppercase letters. By deleting any number of S characters as much as you like, you can create a string in which'A'and'Z' appear alternately, and start with'A' and end with'Z'. Find the character string obtained when the number of deletions is minimized.
Input format
The string S is given on one line as input. S consists of uppercase letters only and satisfies 1 ≤ | S | ≤ 20.
Output format
Output the string that is obtained by deleting the minimum number of characters for S, in which'A'and'Z' appear alternately, and start with'A' and end with'Z' on one line. If no character string that meets the conditions is obtained by deleting any character, output -1 on one line.
Input example 1
AIZUNYAN PEROPERO
Output example 1
AZ
Input example 2
AZAZ
Output example 2
AZAZ
Input example 3
ZDDYAZAWABDDZAZPIDDA
Output example 3
AZAZAZ
Input example 4
ZZZZAAAAAA
Output example 4
-1
Example
Input
AIZUNYANPEROPERO
Output
AZ
|
{"inputs": ["AOZUNYANPERIPERO", "OREQIRMQEAYNUYOA", "OREPIREPNAYNUZOA", "OREPIRNPEAYNUZOA", "OREQIRNPEAYNUZOA", "OREQIRMPEAYNUZOA", "AOZUNYAEPMRIQERO", "OREQIRMQEAYNUZOA"], "outputs": ["AZ\n", "-1\n", "AZ\n", "AZ\n", "AZ\n", "AZ\n", "AZ\n", "AZ\n"]}
| 585
| 120
|
coding
|
Solve the programming task below in a Python markdown code block.
We have A apples and P pieces of apple.
We can cut an apple into three pieces of apple, and make one apple pie by simmering two pieces of apple in a pan.
Find the maximum number of apple pies we can make with what we have now.
-----Constraints-----
- All values in input are integers.
- 0 \leq A, P \leq 100
-----Input-----
Input is given from Standard Input in the following format:
A P
-----Output-----
Print the maximum number of apple pies we can make with what we have.
-----Sample Input-----
1 3
-----Sample Output-----
3
We can first make one apple pie by simmering two of the three pieces of apple. Then, we can make two more by simmering the remaining piece and three more pieces obtained by cutting the whole apple.
|
{"inputs": ["2 3", "1 1", "2 6", "0 0", "0 6", "2 5", "5 0", "1 3"], "outputs": ["4\n", "2\n", "6\n", "0\n", "3\n", "5\n", "7\n", "3"]}
| 185
| 77
|
coding
|
Solve the programming task below in a Python markdown code block.
# Scenario
**_Several people_** are standing in *a row divided into two teams*.
The **_first person_** goes into **_team 1_**, **_the second_** goes into **_team 2_**, **_the third_** goes into **_team 1_**, and so on.
___
# Task
**_Given_** *an array of positive integers (the weights of the people)*, **_return_** *a new array/tuple of two integers*, **_where_** **_the first_** one is the **_total weight of team 1_**, and **_the second_** one is the **_total weight of team 2_**.
___
# Notes
* **_Array size_** is *at least 1*.
* **_All numbers_** will be **positive**.
___
# Input >> Output Examples
```
rowWeights([13, 27, 49]) ==> return (62, 27)
```
## **_Explanation_**:
**_The first element_** `62` is *the total weight of team 1*, and **_the second element_** `27` is *the total weight of team 2*.
___
```
rowWeights([50, 60, 70, 80]) ==> return (120, 140)
```
## **_Explanation_**:
**_The first element_** `120` is *the total weight of team 1*, and **_the second element_** `140` is *the total weight of team 2*.
___
```
rowWeights([80]) ==> return (80, 0)
```
## **_Explanation_**:
**_The first element_** `80` is *the total weight of team 1*, and **_the second element_** `0` is *the total weight of team 2*.
___
___
___
# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)
# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___
## ALL translations are welcomed
## Enjoy Learning !!
# Zizou
Also feel free to reuse/extend the following starter code:
```python
def row_weights(array):
```
|
{"functional": "_inputs = [[[80]], [[100, 50]], [[50, 60, 70, 80]], [[13, 27, 49]], [[70, 58, 75, 34, 91]], [[29, 83, 67, 53, 19, 28, 96]], [[0]], [[100, 51, 50, 100]], [[39, 84, 74, 18, 59, 72, 35, 61]], [[0, 1, 0]]]\n_outputs = [[[80, 0]], [[100, 50]], [[120, 140]], [[62, 27]], [[236, 92]], [[211, 164]], [[0, 0]], [[150, 151]], [[207, 235]], [[0, 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(row_weights(*i), o[0])"}
| 573
| 384
|
coding
|
Solve the programming task below in a Python markdown code block.
We define the function `f1(n,k)`, as the least multiple of `n` that has all its digits less than `k`.
We define the function `f2(n,k)`, as the least multiple of `n` that has all the digits that are less than `k`.
Each digit may occur more than once in both values of `f1(n,k)` and `f2(n,k)`.
The possible values for `n` and `k` according to these ranges for both functions `f1` and `f2` in this kata:
```
1 <= n <= 1.000.000.000.000
3 <= k <= 9
```
For example, let's see the value of both functions for `n = 71` and `k = 4`:
```
f1(71,4) == 213 # all its digits less than 4
f2(71,4) == 2130 # 0,1,2,3 all of them present
```
The integer `76` is the first integer that has the same values of `f1` and `f2` for `k = 4`.
```
f1(76,4) = f2(76,4) = 10032
```
Let's call these kind of numbers, **forgiving numbers**. (Let's continue with the fashion of attributing personality traits to numbers and, of course, an unknown one)
So, `76` is the smallest forgiving number of order `4`.
In the same way, `485` is the smallest forgiving number of order `5`.
Create a function that given an integer `n` and the order `k`, will output the higher and closest forgiving number to `n` of order `k`.
Let's see some examples:
```
find_f1_eq_f2(500,5) == 547
find_f1_eq_f2(1600,6) == 1799
find_f1_eq_f2(14900,7) == 14996
```
If the number `n` is a forgiving itself for a certain order `k`, the function will never output the same value, remember, closest and **higher** than `n`.
For example, `3456`, is a forgiving one of order `4`,
```
find_f1_eq_f2(3456,4) == 3462
```
**Features of the tests:**
* `n` and `k` will be always valid and positive integers.
* A total of 8 fixed tests.
* A total of 150 random tests in the ranges for `n` and `k` given above.
I'll be waiting your awesome solution. :)
Also feel free to reuse/extend the following starter code:
```python
def find_f1_eq_f2(n,k):
```
|
{"functional": "_inputs = [[542, 5], [1750, 6], [14990, 7], [3456, 4], [30500, 3], [62550, 5], [568525, 7], [9567100, 8]]\n_outputs = [[547], [1799], [14996], [3462], [30501], [62557], [568531], [9567115]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(find_f1_eq_f2(*i), o[0])"}
| 657
| 286
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given the head of a linked list, we repeatedly delete consecutive sequences of nodes that sum to 0 until there are no such sequences.
After doing so, return the head of the final linked list. You may return any such answer.
(Note that in the examples below, all sequences are serializations of ListNode objects.)
Please complete the following python code precisely:
```python
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeZeroSumSublists(self, head: Optional[ListNode]) -> Optional[ListNode]:
```
|
{"functional": "def check(candidate):\n assert is_same_list(candidate(head = list_node([1,2,-3,3,1])), list_node([3,1]))\n assert is_same_list(candidate(head = list_node([1,2,3,-3,4])), list_node([1,2,4]))\n assert is_same_list(candidate(head = list_node([1,2,3,-3,-2])), list_node([1]))\n\n\ncheck(Solution().removeZeroSumSublists)"}
| 158
| 112
|
coding
|
Solve the programming task below in a Python markdown code block.
Given an array of integers, determine the minimum number of elements to delete to leave only elements of equal value.
Example
$arr=[1,2,2,3]$
Delete the $2$ elements $1$ and $3$ leaving $arr=[2,2]$. If both twos plus either the $1$ or the $3$ are deleted, it takes $3$ deletions to leave either $\left[3\right]$ or $\left[1\right]$. The minimum number of deletions is $2$.
Function Description
Complete the equalizeArray function in the editor below.
equalizeArray has the following parameter(s):
int arr[n]: an array of integers
Returns
int: the minimum number of deletions required
Input Format
The first line contains an integer $n$, the number of elements in $\textbf{arr}$.
The next line contains $n$ space-separated integers $arr\left[i\right]$.
Constraints
$1\leq n\leq100$
$1\leq arr[i]\leq100$
Sample Input
STDIN Function
----- --------
5 arr[] size n = 5
3 3 2 1 3 arr = [3, 3, 2, 1, 3]
Sample Output
2
Explanation
Delete $arr[2]=2$ and $arr[3]=1$ to leave $ar r'=[3,3,3]$. This is minimal. The only other options are to delete $4$ elements to get an array of either $\left[1\right]$ or $\left[2\right]$.
|
{"inputs": ["STDIN Function\n----- --------\n5 arr[] size n = 5\n3 3 2 1 3 arr = [3, 3, 2, 1, 3]\n"], "outputs": ["2 \n"]}
| 368
| 62
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a rows x cols matrix grid representing a field of cherries where grid[i][j] represents the number of cherries that you can collect from the (i, j) cell.
You have two robots that can collect cherries for you:
Robot #1 is located at the top-left corner (0, 0), and
Robot #2 is located at the top-right corner (0, cols - 1).
Return the maximum number of cherries collection using both robots by following the rules below:
From a cell (i, j), robots can move to cell (i + 1, j - 1), (i + 1, j), or (i + 1, j + 1).
When any robot passes through a cell, It picks up all cherries, and the cell becomes an empty cell.
When both robots stay in the same cell, only one takes the cherries.
Both robots cannot move outside of the grid at any moment.
Both robots should reach the bottom row in grid.
Please complete the following python code precisely:
```python
class Solution:
def cherryPickup(self, grid: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]) == 24\n assert candidate(grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]) == 28\n assert candidate(grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]) == 22\n assert candidate(grid = [[1,1],[1,1]]) == 4\n\n\ncheck(Solution().cherryPickup)"}
| 260
| 198
|
coding
|
Solve the programming task below in a Python markdown code block.
You and your friend decide to play a game using a stack consisting of N bricks. In this game, you can alternatively remove 1, 2 or 3 bricks from the top, and the numbers etched on the removed bricks are added to your score. You have to play so that you obtain the maximum possible score. It is given that your friend will also play optimally and you make the first move.
As an example, bricks are numbered $arr=[1,2,3,4,5]$. You can remove either $\left[1\right]=1$, $[1,2]=3$ or $[1,2,3]=6$. For your friend, your moves would leave the options of $\mbox{1}$ to $3$ elements from $[2,3,4]=9$ leaving $5$ for you (total score = $\boldsymbol{6}$), $[3,4,5]=12$ or $[4,5]=9$. In this case, it will never be optimal for your friend to take fewer than the maximum available number of elements. Your maximum possible score is $\boldsymbol{6}$, achievable two ways: $\mbox{1}$ first move and $5$ the second, or $[1,2,3]$ in your first move.
Function Description
Complete the bricksGame function in the editor below. It should return an integer that represents your maximum possible score.
bricksGame has the following parameter(s):
arr: an array of integers
Input Format
The first line will contain an integer $\boldsymbol{\boldsymbol{t}}$, the number of test cases.
Each of the next $\boldsymbol{\boldsymbol{t}}$ pairs of lines are in the following format:
The first line contains an integer $n$, the number of bricks in $\textbf{arr}$.
The next line contains $n$ space-separated integers $arr[i].
Constraints
$1\leq t\leq5$
$1\leq n\leq10^5$
$0\leq arr[i]\leq10^9$
Output Format
For each test case, print a single line containing your maximum score.
Sample Input
2
5
999 1 1 1 0
5
0 1 1 1 999
Sample Output
1001
999
Explanation
In first test case, you will pick 999,1,1. If you play in any other way, you will not get a score of 1001.
In second case, best option will be to pick up the first brick (with 0 score) at first. Then your friend will choose the next three blocks, and you will get the last brick.
|
{"inputs": ["2\n5\n999 1 1 1 0\n5\n0 1 1 1 999\n"], "outputs": ["1001\n999\n"]}
| 617
| 49
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a sequence of length N: A_1, A_2, ..., A_N.
For each integer i between 1 and N (inclusive), answer the following question:
- Find the maximum value among the N-1 elements other than A_i in the sequence.
-----Constraints-----
- 2 \leq N \leq 200000
- 1 \leq A_i \leq 200000
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
A_1
:
A_N
-----Output-----
Print N lines. The i-th line (1 \leq i \leq N) should contain the maximum value among the N-1 elements other than A_i in the sequence.
-----Sample Input-----
3
1
4
3
-----Sample Output-----
4
3
4
- The maximum value among the two elements other than A_1, that is, A_2 = 4 and A_3 = 3, is 4.
- The maximum value among the two elements other than A_2, that is, A_1 = 1 and A_3 = 3, is 3.
- The maximum value among the two elements other than A_3, that is, A_1 = 1 and A_2 = 4, is 4.
|
{"inputs": ["2\n5\n4", "2\n3\n4", "2\n4\n4", "2\n4\n0", "2\n5\n3", "2\n5\n8", "2\n3\n5", "2\n8\n4"], "outputs": ["4\n5\n", "4\n3\n", "4\n4\n", "0\n4\n", "3\n5\n", "8\n5\n", "5\n3\n", "4\n8\n"]}
| 310
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array A consisting of N integers.
From array A, we create a new array B containing all pairwise bitwise ANDs of elements from A. That is, B consists of N\cdot(N-1)/2 elements, each of the form A_{i} \mathbin{\&} A_{j} for some 1 ≤ i < j ≤ N.
In array B, we repeat the following process till there is only one element remaining:
Let the current maximum and minimum element of array B be X and Y respectively.
Remove X and Y from array B and insert X \mathbin{|} Y into it.
Determine the last remaining element in array B.
Here, \mathbin{\&} denotes the [Bitwise AND operation] and \mathbin{|} denotes the [Bitwise OR operation].
------ Input Format ------
- The first line of input contains a single integer T, denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains a single integer N, denoting the number of elements in A.
- The second line of each test case contains N space-separated integers A_{1}, A_{2}, \ldots, A_{N}.
------ Output Format ------
For each test case, print a single line containing one integer — the last remaining element in array B.
------ Constraints ------
$1 ≤ T ≤ 10^{4}$
$2 ≤ N ≤ 10^{5}$
$0 ≤ A_{i} ≤ 10^{9}$
- The sum of $N$ over all test cases does not exceed $2\cdot 10^{5}$.
----- Sample Input 1 ------
3
2
1 3
3
2 7 1
4
4 6 7 2
----- Sample Output 1 ------
1
3
6
----- explanation 1 ------
Test Case $1$: Array $B$ will be $[A_{1} \mathbin{\&} A_{2}] = [1 \mathbin{\&} 3] = [1]$. There is only one element in $B$ so the answer is $1$.
Test Case $2$: Array $B$ will be $[A_{1} \mathbin{\&} A_{2}, A_{1} \mathbin{\&} A_{3}, A_{2} \mathbin{\&} A_{3}] = [2 \mathbin{\&} 7, 2 \mathbin{\&} 1, 7 \mathbin{\&} 1] = [2, 0, 1]$.
Then, we do the following operations on $B$:
1. Remove $2$ and $0$ from $B$ and insert $2\mathbin{|} 0 = 2$ into it. Now, $B = [1, 2]$.
2. Remove $2$ and $1$ from $B$ and insert $2\mathbin{|} 1 = 3$ into it. Now, $B = [3]$.
The last remaining element is thus $3$.
|
{"inputs": ["3\n2\n1 3\n3\n2 7 1\n4\n4 6 7 2"], "outputs": ["1\n3\n6\n"]}
| 681
| 41
|
coding
|
Solve the programming task below in a Python markdown code block.
Fox Ciel is playing a card game with her friend Fox Jiro. There are n piles of cards on the table. And there is a positive integer on each card.
The players take turns and Ciel takes the first turn. In Ciel's turn she takes a card from the top of any non-empty pile, and in Jiro's turn he takes a card from the bottom of any non-empty pile. Each player wants to maximize the total sum of the cards he took. The game ends when all piles become empty.
Suppose Ciel and Jiro play optimally, what is the score of the game?
-----Input-----
The first line contain an integer n (1 ≤ n ≤ 100). Each of the next n lines contains a description of the pile: the first integer in the line is s_{i} (1 ≤ s_{i} ≤ 100) — the number of cards in the i-th pile; then follow s_{i} positive integers c_1, c_2, ..., c_{k}, ..., c_{s}_{i} (1 ≤ c_{k} ≤ 1000) — the sequence of the numbers on the cards listed from top of the current pile to bottom of the pile.
-----Output-----
Print two integers: the sum of Ciel's cards and the sum of Jiro's cards if they play optimally.
-----Examples-----
Input
2
1 100
2 1 10
Output
101 10
Input
1
9 2 8 6 5 9 4 7 1 3
Output
30 15
Input
3
3 1 3 2
3 5 4 6
2 8 7
Output
18 18
Input
3
3 1000 1000 1000
6 1000 1000 1000 1000 1000 1000
5 1000 1000 1000 1000 1000
Output
7000 7000
-----Note-----
In the first example, Ciel will take the cards with number 100 and 1, Jiro will take the card with number 10.
In the second example, Ciel will take cards with numbers 2, 8, 6, 5, 9 and Jiro will take cards with numbers 4, 7, 1, 3.
|
{"inputs": ["1\n1 1\n", "1\n1 1\n", "2\n1 000\n2 1 4\n", "2\n1 100\n2 1 4\n", "2\n1 100\n2 1 10\n", "2\n1 100\n2 1 20\n", "2\n1 000\n2 1 20\n", "2\n1 110\n2 1 10\n"], "outputs": ["1 0\n", "1 0\n", "1 4\n", "101 4\n", "101 10\n", "101 20\n", "1 20\n", "111 10\n"]}
| 568
| 182
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
A super ugly number is a positive integer whose prime factors are in the array primes.
Given an integer n and an array of integers primes, return the nth super ugly number.
The nth super ugly number is guaranteed to fit in a 32-bit signed integer.
Please complete the following python code precisely:
```python
class Solution:
def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 12, primes = [2,7,13,19]) == 32 \n assert candidate(n = 1, primes = [2,3,5]) == 1\n\n\ncheck(Solution().nthSuperUglyNumber)"}
| 108
| 71
|
coding
|
Solve the programming task below in a Python markdown code block.
We have two indistinguishable pieces placed on a number line. Both pieces are initially at coordinate 0. (They can occupy the same position.)
We can do the following two kinds of operations:
* Choose a piece and move it to the right (the positive direction) by 1.
* Move the piece with the smaller coordinate to the position of the piece with the greater coordinate. If two pieces already occupy the same position, nothing happens, but it still counts as doing one operation.
We want to do a total of N operations of these kinds in some order so that one of the pieces will be at coordinate A and the other at coordinate B. Find the number of ways to move the pieces to achieve it. The answer can be enormous, so compute the count modulo 998244353.
Two ways to move the pieces are considered different if and only if there exists an integer i (1 \leq i \leq N) such that the set of the coordinates occupied by the pieces after the i-th operation is different in those two ways.
Constraints
* 1 \leq N \leq 10^7
* 0 \leq A \leq B \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
Print the number of ways to move the pieces to achieve our objective, modulo 998244353.
Examples
Input
5 1 3
Output
4
Input
10 0 0
Output
1
Input
10 4 6
Output
197
Input
1000000 100000 200000
Output
758840509
|
{"inputs": ["5 1 1", "4 4 6", "5 2 2", "5 2 3", "7 1 2", "6 2 3", "3 1 2", "4 1 1"], "outputs": ["4\n", "0\n", "8\n", "7\n", "6\n", "12\n", "2\n", "3\n"]}
| 396
| 95
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.