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.
10^{10^{10}} participants, including Takahashi, competed in two programming contests. In each contest, all participants had distinct ranks from first through 10^{10^{10}}-th.
The score of a participant is the product of his/her ranks in the two contests.
Process the following Q queries:
* In the i-th query, you are given two positive integers A_i and B_i. Assuming that Takahashi was ranked A_i-th in the first contest and B_i-th in the second contest, find the maximum possible number of participants whose scores are smaller than Takahashi's.
Constraints
* 1 \leq Q \leq 100
* 1\leq A_i,B_i\leq 10^9(1\leq i\leq Q)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
A_1 B_1
:
A_Q B_Q
Output
For each query, print the maximum possible number of participants whose scores are smaller than Takahashi's.
Example
Input
8
1 4
10 5
3 3
4 11
8 9
22 40
8 36
314159265 358979323
Output
1
12
4
11
14
57
31
671644785
|
{"inputs": ["8\n2 4\n1 5\n3 6\n6 11\n8 9\n9 3\n7 36\n314159265 541984339", "8\n1 4\n10 8\n4 3\n4 8\n8 7\n22 6\n7 36\n314159265 96636036", "8\n2 4\n6 9\n3 1\n5 11\n4 9\n16 1\n6 57\n314159265 75457060", "8\n1 4\n10 5\n3 3\n4 11\n8 9\n1 3\n8 36\n314159265 358979323", "8\n1 4\n10 5\n3 3\n4 11\n8 9\n22 3\n7 36\n314159265 96636036", "8\n2 4\n2 5\n3 6\n5 11\n8 9\n22 3\n7 36\n314159265 541984339", "8\n2 4\n3 9\n3 7\n1 11\n8 9\n16 1\n3 41\n314159265 339704264", "8\n2 4\n7 9\n3 5\n1 11\n8 9\n16 1\n3 41\n314159265 339704264"], "outputs": ["3\n2\n6\n14\n14\n8\n29\n825274259\n", "1\n15\n4\n9\n12\n20\n29\n348477291\n", "3\n12\n1\n12\n9\n5\n34\n307932032\n", "1\n12\n4\n11\n14\n1\n31\n671644785\n", "1\n12\n4\n11\n14\n14\n29\n348477291\n", "3\n4\n6\n12\n14\n14\n29\n825274259\n", "3\n8\n7\n4\n14\n5\n20\n653364343\n", "3\n13\n5\n4\n14\n5\n20\n653364343\n"]}
| 336
| 671
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
A ramp in an integer array nums is a pair (i, j) for which i < j and nums[i] <= nums[j]. The width of such a ramp is j - i.
Given an integer array nums, return the maximum width of a ramp in nums. If there is no ramp in nums, return 0.
Please complete the following python code precisely:
```python
class Solution:
def maxWidthRamp(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate([6,0,8,2,1,5]) == 4\n assert candidate([9,8,1,0,1,9,4,0,4,1]) == 7\n\n\ncheck(Solution().maxWidthRamp)"}
| 116
| 69
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
Chef recently visited ShareChat Cafe and was highly impressed by the food. Being a food enthusiast, he decided to enquire about the ingredients of each dish.
There are $N$ dishes represented by strings $S_{1}, S_{2}, \ldots, S_{N}$. Each ingredient used for making dishes in ShareChat Cafe is represented by a lowercase English letter. For each valid $i$, the ingredients used to make dish $i$ correspond to characters in the string $S_{i}$ (note that ingredients may be used multiple times). A *special ingredient* is an ingredient which is present in each dish at least once.
Chef wants to know the number of special ingredients in ShareChat Cafe. Since Chef is too busy with work, can you help him?
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
$N$ lines follow. For each $i$ ($1 ≤ i ≤ N$), the $i$-th of these lines contains a single string $S_{i}$.
------ Output ------
For each test case, print a single line containing one integer ― the number of special ingredients in the dishes.
------ Constraints ------
$1 ≤ T ≤ 1,000$
$1 ≤ N ≤ 1,000$
$1 ≤ |S_{i}| ≤ 200$ for each valid $i$
$S_{1}, S_{2}, \ldots, S_{N}$ contain only lowercase English letters
The sum of length of strings over all test cases $≤$ 3500000
------ Subtasks ------
Subtask #1 (100 points): original constraints
----- Sample Input 1 ------
2
3
abcaa
bcbd
bgc
3
quick
brown
fox
----- Sample Output 1 ------
2
0
----- explanation 1 ------
Example case 1: Ingredients 'b' and 'c' are present in all three dishes, so there are two special ingredients.
Example case 2: No ingredient is common to all three dishes.
|
{"inputs": ["2\n3\nabcaa\nbcbd\nbgc\n3\nquick\nbrown\nfox"], "outputs": ["2\n0"]}
| 515
| 33
|
coding
|
Solve the programming task below in a Python markdown code block.
It is known that fleas in Berland can jump only vertically and horizontally, and the length of the jump is always equal to s centimeters. A flea has found herself at the center of some cell of the checked board of the size n × m centimeters (each cell is 1 × 1 centimeters). She can jump as she wishes for an arbitrary number of times, she can even visit a cell more than once. The only restriction is that she cannot jump out of the board.
The flea can count the amount of cells that she can reach from the starting position (x, y). Let's denote this amount by dx, y. Your task is to find the number of such starting positions (x, y), which have the maximum possible value of dx, y.
Input
The first line contains three integers n, m, s (1 ≤ n, m, s ≤ 106) — length of the board, width of the board and length of the flea's jump.
Output
Output the only integer — the number of the required starting positions of the flea.
Examples
Input
2 3 1000000
Output
6
Input
3 3 2
Output
4
|
{"inputs": ["1 2 3\n", "9 8 7\n", "4 5 6\n", "1 1 1\n", "1 1 2\n", "8 5 6\n", "1 8 7\n", "8 1 6\n"], "outputs": ["2", "8", "20", "1", "1", "20\n", "2\n", "4\n"]}
| 266
| 99
|
coding
|
Solve the programming task below in a Python markdown code block.
Ayush is a cashier at the shopping center. Recently his department has started a ''click and collect" service which allows users to shop online.
The store contains k items. n customers have already used the above service. Each user paid for m items. Let a_{ij} denote the j-th item in the i-th person's order.
Due to the space limitations all the items are arranged in one single row. When Ayush receives the i-th order he will find one by one all the items a_{ij} (1 ≤ j ≤ m) in the row. Let pos(x) denote the position of the item x in the row at the moment of its collection. Then Ayush takes time equal to pos(a_{i}1) + pos(a_{i}2) + ... + pos(a_{im}) for the i-th customer.
When Ayush accesses the x-th element he keeps a new stock in the front of the row and takes away the x-th element. Thus the values are updating.
Your task is to calculate the total time it takes for Ayush to process all the orders.
You can assume that the market has endless stock.
-----Input-----
The first line contains three integers n, m and k (1 ≤ n, k ≤ 100, 1 ≤ m ≤ k) — the number of users, the number of items each user wants to buy and the total number of items at the market.
The next line contains k distinct integers p_{l} (1 ≤ p_{l} ≤ k) denoting the initial positions of the items in the store. The items are numbered with integers from 1 to k.
Each of the next n lines contains m distinct integers a_{ij} (1 ≤ a_{ij} ≤ k) — the order of the i-th person.
-----Output-----
Print the only integer t — the total time needed for Ayush to process all the orders.
-----Example-----
Input
2 2 5
3 4 1 2 5
1 5
3 1
Output
14
-----Note-----
Customer 1 wants the items 1 and 5.
pos(1) = 3, so the new positions are: [1, 3, 4, 2, 5].
pos(5) = 5, so the new positions are: [5, 1, 3, 4, 2].
Time taken for the first customer is 3 + 5 = 8.
Customer 2 wants the items 3 and 1.
pos(3) = 3, so the new positions are: [3, 5, 1, 4, 2].
pos(1) = 3, so the new positions are: [1, 3, 5, 4, 2].
Time taken for the second customer is 3 + 3 = 6.
Total time is 8 + 6 = 14.
Formally pos(x) is the index of x in the current row.
|
{"inputs": ["1 1 1\n1\n1\n", "1 1 1\n1\n1\n", "2 2 5\n3 4 1 2 5\n1 5\n3 1\n", "3 2 3\n3 1 2\n1 2\n2 1\n2 3\n", "3 2 3\n3 1 2\n1 2\n2 1\n2 3\n", "3 2 3\n3 1 2\n1 2\n3 1\n2 3\n", "2 2 5\n3 4 1 0 5\n1 5\n3 1\n", "2 2 5\n3 4 1 0 5\n1 5\n4 1\n"], "outputs": ["1\n", "1\n", "14\n", "13\n", "13\n", "17\n", "14\n", "15\n"]}
| 644
| 224
|
coding
|
Solve the programming task below in a Python markdown code block.
## Debugging sayHello function
The starship Enterprise has run into some problem when creating a program to greet everyone as they come aboard. It is your job to fix the code and get the program working again!
Example output:
```
Hello, Mr. Spock
```
Also feel free to reuse/extend the following starter code:
```python
def say_hello(name):
```
|
{"functional": "_inputs = [['Mr. Spock'], ['Captain Kirk'], ['Liutenant Uhura'], ['Dr. McCoy'], ['Mr. Scott']]\n_outputs = [['Hello, Mr. Spock'], ['Hello, Captain Kirk'], ['Hello, Liutenant Uhura'], ['Hello, Dr. McCoy'], ['Hello, Mr. Scott']]\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(say_hello(*i), o[0])"}
| 92
| 211
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Alice and Bob have an undirected graph of n nodes and three types of edges:
Type 1: Can be traversed by Alice only.
Type 2: Can be traversed by Bob only.
Type 3: Can be traversed by both Alice and Bob.
Given an array edges where edges[i] = [typei, ui, vi] represents a bidirectional edge of type typei between nodes ui and vi, find the maximum number of edges you can remove so that after removing the edges, the graph can still be fully traversed by both Alice and Bob. The graph is fully traversed by Alice and Bob if starting from any node, they can reach all other nodes.
Return the maximum number of edges you can remove, or return -1 if Alice and Bob cannot fully traverse the graph.
Please complete the following python code precisely:
```python
class Solution:
def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 4, edges = [[3,1,2],[3,2,3],[1,1,3],[1,2,4],[1,1,2],[2,3,4]]) == 2\n assert candidate(n = 4, edges = [[3,1,2],[3,2,3],[1,1,4],[2,1,4]]) == 0\n assert candidate(n = 4, edges = [[3,2,3],[1,1,2],[2,3,4]]) == -1\n\n\ncheck(Solution().maxNumEdgesToRemove)"}
| 219
| 144
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer array nums, return true if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or false otherwise.
Please complete the following python code precisely:
```python
class Solution:
def canPartition(self, nums: List[int]) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,5,11,5]) == True\n assert candidate(nums = [1,2,3,5]) == False\n\n\ncheck(Solution().canPartition)"}
| 81
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
###Lucky number
Write a function to find if a number is lucky or not. If the sum of all digits is 0 or multiple of 9 then the number is lucky.
`1892376 => 1+8+9+2+3+7+6 = 36`. 36 is divisble by 9, hence number is lucky.
Function will return `true` for lucky numbers and `false` for others.
Also feel free to reuse/extend the following starter code:
```python
def is_lucky(n):
```
|
{"functional": "_inputs = [[1892376], [189237], [18922314324324234423437], [189223141324324234423437], [1892231413243242344321432142343423437], [0]]\n_outputs = [[True], [False], [False], [True], [True], [True]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(is_lucky(*i), o[0])"}
| 132
| 277
|
coding
|
Solve the programming task below in a Python markdown code block.
Since I got tired to write long problem statements, I decided to make this problem statement short. For given positive integer L, how many pairs of positive integers a, b (a ≤ b) such that LCM(a, b) = L are there? Here, LCM(a, b) stands for the least common multiple of a and b.
Constraints
* 1 ≤ L ≤ 1012
Input
For each dataset, an integer L is given in a line. Input terminates when L = 0.
Output
For each dataset, output the number of pairs of a and b.
Example
Input
12
9
2
0
Output
8
3
2
|
{"inputs": ["12\n9\n3\n0", "12\n8\n2\n0", "12\n9\n0\n0", "12\n0\n3\n0", "12\n9\n1\n0", "12\n8\n1\n0", "12\n9\n4\n0", "12\n8\n0\n0"], "outputs": ["8\n3\n2\n", "8\n4\n2\n", "8\n3\n", "8\n", "8\n3\n1\n", "8\n4\n1\n", "8\n3\n3\n", "8\n4\n"]}
| 157
| 142
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer array heights representing the heights of buildings, some bricks, and some ladders.
You start your journey from building 0 and move to the next building by possibly using bricks or ladders.
While moving from building i to building i+1 (0-indexed),
If the current building's height is greater than or equal to the next building's height, you do not need a ladder or bricks.
If the current building's height is less than the next building's height, you can either use one ladder or (h[i+1] - h[i]) bricks.
Return the furthest building index (0-indexed) you can reach if you use the given ladders and bricks optimally.
Please complete the following python code precisely:
```python
class Solution:
def furthestBuilding(self, heights: List[int], bricks: int, ladders: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1) == 4\n assert candidate(heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2) == 7\n assert candidate(heights = [14,3,19,3], bricks = 17, ladders = 0) == 3\n\n\ncheck(Solution().furthestBuilding)"}
| 203
| 136
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an integer $N$. Consider set $S=\{0,\:1,\ldots,\:2^N-1\}$. How many subsets $A\subset S$ with $\bigoplus_{x\in A}x=0$ ($\theta$ denotes xor operation) are there?
Print your answer modulo $(10^9+7)$.
Note that the xorsum of an empty set is zero!
Input Format
The first line contains one integer $\mathbf{T}$, the number of testcases.
The next $\mathbf{T}$ lines contain one integer $N$ each.
Output Format
Output $\mathbf{T}$ lines. Each line is one number, answer to the problem modulo $10^9+7$.
Constraints
$1\leq T\leq10000$
$1\leq N\leq10^{18}$
Sample Input
2
1
2
Sample Output
2
4
Explanation
For $N=1$ there are $2$ sets - ∅ and $\{0\}$.
For $N=2$ there are $4$ sets - ∅, $\{0\}$, $\{1,\:2,\:3\}$, $\{0,\:1,\:2,\:3\}$.
|
{"inputs": ["2\n1\n2\n"], "outputs": ["2\n4\n"]}
| 302
| 20
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese and Russian as well.
A version control system(VCS) is a repository of files, often the files for the source code of computer programs, with monitored access. Every change made to the source is tracked, along with who made the change, why they made it, and references to problems fixed, or enhancements introduced, by the change.
Version control systems are essential for any form of distributed, collaborative development. Whether it is the history of a wiki page or large software development project, the ability to track each change as it was made, and to reverse changes when necessary can make all the difference between a well managed and controlled process and an uncontrolled ‘first come, first served’ system. It can also serve as a mechanism for due diligence for software projects.
In this problem we'll consider a simplified model of a development project. Let's suppose, that there are N source files in the project. All the source files are distinct and numbered from 1 to N.
A VCS, that is used for maintaining the project, contains two sequences of source files. The first sequence contains the source files, that are ignored by the VCS. If a source file is not in the first sequence, then it's considered to be unignored. The second sequence contains the source files, that are tracked by the VCS. If a source file is not in the second sequence, then it's considered to be untracked. A source file can either be or not be in any of these two sequences.
Your task is to calculate two values: the number of source files of the project, that are both tracked and ignored, and the number of source files of the project, that are both untracked and unignored.
------ 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 the test case description contains three integers N, M and K denoting the number of source files in the project, the number of ignored source files and the number of tracked source files.
The second line contains M distinct integers denoting the sequence A of ignored source files. The sequence is strictly increasing.
The third line contains K distinct integers denoting the sequence B of tracked source files. The sequence is strictly increasing.
------ Output ------
For each test case, output a single line containing two integers: the number of the source files, that are both tracked and ignored, and the number of the source files, that are both untracked and unignored.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ M, K ≤ N ≤ 100$
$1 ≤ A_{1} < A_{2} < ... < A_{M} ≤ N$
$1 ≤ B_{1} < B_{2} < ... < B_{K} ≤ N$
----- Sample Input 1 ------
2
7 4 6
1 4 6 7
1 2 3 4 6 7
4 2 2
1 4
3 4
----- Sample Output 1 ------
4 1
1 1
----- explanation 1 ------
In the first test case, the source files {1, 4, 6, 7} are both tracked and ignored, the source file {5} is both untracked and unignored.
In the second test case, the source file {4} is both tracked and ignored, the source file {2} is both untracked and unignored.
|
{"inputs": ["2\n7 4 6\n1 4 6 7\n1 2 3 4 6 7\n4 2 2\n1 4\n3 4", "2\n7 4 6\n1 4 6 7\n1 2 3 5 6 7\n4 2 2\n1 4\n3 4", "2\n7 4 6\n1 4 6 7\n1 2 3 4 6 7\n4 2 2\n2 4\n3 4", "2\n7 4 6\n1 4 6 7\n1 2 3 4 6 7\n5 2 2\n2 4\n3 4", "2\n7 4 6\n1 4 6 7\n1 2 3 4 6 7\n4 2 2\n1 4\n1 4", "2\n7 4 6\n1 4 6 7\n1 2 3 5 6 7\n5 2 2\n2 4\n3 4", "2\n8 4 6\n1 4 6 7\n1 2 3 5 6 7\n5 2 2\n2 4\n3 4", "2\n7 4 6\n1 4 6 7\n1 2 3 5 6 7\n7 2 2\n2 4\n3 4"], "outputs": ["4 1\n1 1", "3 0\n1 1\n", "4 1\n1 1\n", "4 1\n1 2\n", "4 1\n2 2\n", "3 0\n1 2\n", "3 1\n1 2\n", "3 0\n1 4\n"]}
| 747
| 429
|
coding
|
Solve the programming task below in a Python markdown code block.
If you finish this kata, you can try [Insane Coloured Triangles](http://www.codewars.com/kata/insane-coloured-triangles) by Bubbler, which is a ***much*** harder version of this one.
A coloured triangle is created from a row of colours, each of which is red, green or blue. Successive rows, each containing one fewer colour than the last, are generated by considering the two touching colours in the previous row. If these colours are identical, the same colour is used in the new row. If they are different, the missing colour is used in the new row. This is continued until the final row, with only a single colour, is generated.
The different possibilities are:
```
Colour here: G G B G R G B R
Becomes colour: G R B G
```
With a bigger example:
```
R R G B R G B B
R B R G B R B
G G B R G G
G R G B G
B B R R
B G R
R B
G
```
You will be given the first row of the triangle as a string and its your job to return the final colour which would appear in the bottom row as a string. In the case of the example above, you would the given `RRGBRGBB` you should return `G`.
* The input string will only contain the uppercase letters `R, G, B` and there will be at least one letter so you do not have to test for invalid input.
* If you are only given one colour as the input, return that colour.
*Adapted from the 2017 British Informatics Olympiad*
Also feel free to reuse/extend the following starter code:
```python
def triangle(row):
```
|
{"functional": "_inputs = [['GB'], ['RRR'], ['RGBG'], ['RBRGBRB'], ['RBRGBRBGGRRRBGBBBGG'], ['B']]\n_outputs = [['R'], ['R'], ['B'], ['G'], ['G'], ['B']]\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(triangle(*i), o[0])"}
| 406
| 198
|
coding
|
Solve the programming task below in a Python markdown code block.
Create a function that checks if a number `n` is divisible by two numbers `x` **AND** `y`. All inputs are positive, non-zero digits.
```JS
Examples:
1) n = 3, x = 1, y = 3 => true because 3 is divisible by 1 and 3
2) n = 12, x = 2, y = 6 => true because 12 is divisible by 2 and 6
3) n = 100, x = 5, y = 3 => false because 100 is not divisible by 3
4) n = 12, x = 7, y = 5 => false because 12 is neither divisible by 7 nor 5
```
Also feel free to reuse/extend the following starter code:
```python
def is_divisible(n,x,y):
```
|
{"functional": "_inputs = [[3, 2, 2], [3, 3, 4], [12, 3, 4], [8, 3, 4], [48, 3, 4], [100, 5, 10], [100, 5, 3], [4, 4, 2], [5, 2, 3], [17, 17, 17], [17, 1, 17]]\n_outputs = [[False], [False], [True], [False], [True], [True], [False], [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(is_divisible(*i), o[0])"}
| 213
| 293
|
coding
|
Solve the programming task below in a Python markdown code block.
The whole world got obsessed with robots,and to keep pace with the progress, great Berland's programmer Draude decided to build his own robot. He was working hard at the robot. He taught it to walk the shortest path from one point to another, to record all its movements, but like in many Draude's programs, there was a bug — the robot didn't always walk the shortest path. Fortunately, the robot recorded its own movements correctly. Now Draude wants to find out when his robot functions wrong. Heh, if Draude only remembered the map of the field, where he tested the robot, he would easily say if the robot walked in the right direction or not. But the field map was lost never to be found, that's why he asks you to find out if there exist at least one map, where the path recorded by the robot is the shortest.
The map is an infinite checkered field, where each square is either empty, or contains an obstruction. It is also known that the robot never tries to run into the obstruction. By the recorded robot's movements find out if there exist at least one such map, that it is possible to choose for the robot a starting square (the starting square should be empty) such that when the robot moves from this square its movements coincide with the recorded ones (the robot doesn't run into anything, moving along empty squares only), and the path from the starting square to the end one is the shortest.
In one movement the robot can move into the square (providing there are no obstrutions in this square) that has common sides with the square the robot is currently in.
Input
The first line of the input file contains the recording of the robot's movements. This recording is a non-empty string, consisting of uppercase Latin letters L, R, U and D, standing for movements left, right, up and down respectively. The length of the string does not exceed 100.
Output
In the first line output the only word OK (if the above described map exists), or BUG (if such a map does not exist).
Examples
Input
LLUUUR
Output
OK
Input
RRUULLDD
Output
BUG
|
{"inputs": ["L\n", "R\n", "RR\n", "DL\n", "LD\n", "UL\n", "DDR\n", "ULD\n"], "outputs": ["OK\n", "OK\n", "OK\n", "OK\n", "OK\n", "OK\n", "OK\n", "BUG\n"]}
| 463
| 70
|
coding
|
Solve the programming task below in a Python markdown code block.
prison
There are an infinite number of prisoners. Initially, the prisoners are numbered 0, 1, 2, ....
Do the following N times:
* Release the 0th prisoner and execute the k, 2k, 3k, ... th prisoners.
* Then renumber the remaining prisoners. At this time, the prisoners with the smallest original numbers are numbered 0, 1, 2, ... in order.
Find the number that was originally assigned to the prisoner released in the Nth operation.
Constraints
* 1 ≤ N ≤ 10 ^ 5
* 2 ≤ k ≤ 10 ^ 5
* The answer is less than 10 ^ {18}.
Input Format
Input is given from standard input in the following format.
N k
Output Format
Print the answer in one line.
Sample Input 1
4 2
Sample Output 1
7
Sample Input 2
13
Sample Output 2
0
Sample Input 3
100000 100000
Sample Output 3
99999
Example
Input
4 2
Output
7
|
{"inputs": ["5 2", "7 2", "2 2", "1 2", "4 3", "8 2", "6 2", "7 4"], "outputs": ["15\n", "63\n", "1\n", "0\n", "4\n", "127\n", "31\n", "10\n"]}
| 263
| 84
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer n. A 0-indexed integer array nums of length n + 1 is generated in the following way:
nums[0] = 0
nums[1] = 1
nums[2 * i] = nums[i] when 2 <= 2 * i <= n
nums[2 * i + 1] = nums[i] + nums[i + 1] when 2 <= 2 * i + 1 <= n
Return the maximum integer in the array nums.
Please complete the following python code precisely:
```python
class Solution:
def getMaximumGenerated(self, n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 7) == 3\n assert candidate(n = 2) == 1\n assert candidate(n = 3) == 2\n\n\ncheck(Solution().getMaximumGenerated)"}
| 158
| 56
|
coding
|
Solve the programming task below in a Python markdown code block.
Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.
Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).
-----Input-----
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar.
The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame.
The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.
-----Output-----
Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.
-----Examples-----
Input
8
1
2
Output
1
Input
5
3
4
Output
6
Input
6
4
2
Output
4
Input
20
5
6
Output
2
-----Note-----
In the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.
In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.
|
{"inputs": ["8\n1\n2\n", "5\n3\n4\n", "6\n4\n2\n", "1\n1\n1\n", "3\n1\n2\n", "3\n2\n1\n", "8\n3\n5\n", "5\n4\n2\n"], "outputs": ["1\n", "6\n", "4\n", "6\n", "3\n", "4\n", "3\n", "5\n"]}
| 351
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a program which reads a rectangle and a circle, and determines whether the circle is arranged inside the rectangle. As shown in the following figures, the upper right coordinate $(W, H)$ of the rectangle and the central coordinate $(x, y)$ and radius $r$ of the circle are given.
Circle inside a rectangle
Constraints
* $ -100 \leq x, y \leq 100$
* $ 0 < W, H, r \leq 100$
Input
Five integers $W$, $H$, $x$, $y$ and $r$ separated by a single space are given in a line.
Output
Print "Yes" if the circle is placed inside the rectangle, otherwise "No" in a line.
Examples
Input
5 4 2 2 1
Output
Yes
Input
5 4 2 4 1
Output
No
|
{"inputs": ["2 4 2 2 1", "2 8 2 0 0", "5 4 2 0 1", "2 4 2 2 2", "5 8 2 0 1", "2 6 2 2 2", "2 8 2 0 1", "3 6 2 2 2"], "outputs": ["No\n", "Yes\n", "No\n", "No\n", "No\n", "No\n", "No\n", "No\n"]}
| 206
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
Alisha has a string of length n. Each character is either 'a', 'b' or 'c'. She has to select two characters s[i] and s[j] such that s[i] != s[j] and i,j are valid indexes. She has to find the maximum value of the absolute difference between i and j i.e abs(i-j) .
Since Alisha is busy with her Semester exams help her find the maximum distance where distance is the maximum value of absolute difference between i and j i.e abs(i-j) .
-----Input:-----
- The first and the only line contains the string s with each character either 'a', 'b', or 'c'.
-----Output:-----
Print a single integer the maximum absolute difference between i and j.
-----Constraints-----
- $1 \leq n \leq 10^5$
- s[i] can either be 'a', 'b' or 'c'.
-----Subtasks-----
- 40 points : $1 \leq n \leq 100$
- 60 points : $1 \leq n \leq 10^5$
-----Sample Input1:-----
aabcaaa
-----Sample Output1:-----
4
-----Sample Input2:-----
aba
-----Sample Output2:-----
1
|
{"inputs": ["aba", "aabcaaa"], "outputs": ["1", "4"]}
| 287
| 20
|
coding
|
Solve the programming task below in a Python markdown code block.
JJ has an array A of length N. He can perform the following operation on A:
Select any L, R (1 ≤ L ≤ R ≤ N) and for each i such that L ≤ i ≤ R, set A_{i} := A_{i} + 1.
JJ wants to make A palindromic. Find the minimum number of moves to do so.
Note: An array is called a palindrome if it reads the same backwards and forwards, for e.g. [1, 3, 3, 1] and [6, 2, 6] are palindromic.
------ Input Format ------
- The first line contains a single integer T — the number of test cases. Then the test cases follow.
- The first line of each test case contains an integer N — the size of the array A.
- The second line of each test case contains N space-separated integers A_{1}, A_{2}, \dots, A_{N} denoting the array A.
------ Output Format ------
For each test case, output the minimum number of moves to make A palindromic.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$1 ≤A_{i} ≤10^{9}$
- Sum of $N$ over all test cases does not exceed $3 \cdot 10^{5}$.
----- Sample Input 1 ------
3
6
2 6 4 3 4 1
2
1 10
3
1 10 1
----- Sample Output 1 ------
2
9
0
----- explanation 1 ------
Test Case 1: We can perform the following operations:
- $[2, 6, \underline{4, 3, 4, 1}] \xrightarrow{L = 3, R = 6} [2, 6, 5, 4, 5, 2]$
- $[2, 6, 5, \underline{4, 5}, 2] \xrightarrow{L = 4, R = 5} [2, 6, 5, 5, 6, 2]$
Test Case 2: We perform the operation on $(L = 1, R = 1)$ $9$ times after which array becomes $[10, 10]$.
Test Case 3: $A$ is already a palindrome.
|
{"inputs": ["3\n6\n2 6 4 3 4 1\n2\n1 10\n3\n1 10 1\n"], "outputs": ["2\n9\n0\n"]}
| 544
| 48
|
coding
|
Solve the programming task below in a Python markdown code block.
Create a function `close_compare` that accepts 3 parameters: `a`, `b`, and an optional `margin`. The function should return whether `a` is lower than, close to, or higher than `b`. `a` is "close to" `b` if `margin` is higher than or equal to the difference between `a` and `b`.
When `a` is lower than `b`, return `-1`.
When `a` is higher than `b`, return `1`.
When `a` is close to `b`, return `0`.
If `margin` is not given, treat it as zero.
Example: if `a = 3`, `b = 5` and the `margin = 3`, since `a` and `b` are no more than 3 apart, `close_compare` should return `0`. Otherwise, if instead `margin = 0`, `a` is lower than `b` and `close_compare` should return `-1`.
Assume: `margin >= 0`
Tip: Some languages have a way to make arguments optional.
Also feel free to reuse/extend the following starter code:
```python
def close_compare(a, b, margin=0):
```
|
{"functional": "_inputs = [[4, 5], [5, 5], [6, 5], [2, 5, 3], [5, 5, 3], [8, 5, 3], [8.1, 5, 3], [1.99, 5, 3]]\n_outputs = [[-1], [0], [1], [0], [0], [0], [1], [-1]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(close_compare(*i), o[0])"}
| 270
| 241
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given a weighted tree consisting of n nodes numbered from 0 to n - 1.
The tree is rooted at node 0 and represented with a 2D array edges of size n where edges[i] = [pari, weighti] indicates that node pari is the parent of node i, and the edge between them has a weight equal to weighti. Since the root does not have a parent, you have edges[0] = [-1, -1].
Choose some edges from the tree such that no two chosen edges are adjacent and the sum of the weights of the chosen edges is maximized.
Return the maximum sum of the chosen edges.
Note:
You are allowed to not choose any edges in the tree, the sum of weights in this case will be 0.
Two edges Edge1 and Edge2 in the tree are adjacent if they have a common node.
In other words, they are adjacent if Edge1 connects nodes a and b and Edge2 connects nodes b and c.
Please complete the following python code precisely:
```python
class Solution:
def maxScore(self, edges: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(edges = [[-1,-1],[0,5],[0,10],[2,6],[2,4]]) == 11\n assert candidate(edges = [[-1,-1],[0,5],[0,-6],[0,7]]) == 7\n\n\ncheck(Solution().maxScore)"}
| 254
| 79
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array A = [A_{1}, A_{2}, \ldots, A_{N}] of length N.
You can right rotate it any number of times (possibly, zero). What is the maximum value of A_{1} + A_{N} you can get?
Note: Right rotating the array [A_{1}, A_{2}, \ldots, A_{N}] once gives the array [A_{N}, A_{1}, A_{2}, \ldots, A_{N-1}]. For example, right rotating [1, 2, 3] once gives [3, 1, 2], and right rotating it again gives [2, 3, 1].
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases. The description of the test cases follows.
- The first line of each test case contains a single integer N, denoting the length of array A.
- The second line of each test case contains N space-separated integers A_{1}, A_{2}, \ldots, A_{N} — denoting the array A.
------ Output Format ------
For each test case, output on a new line the maximum value of A_{1}+A_{N} you can get after several right rotations.
------ Constraints ------
$1 ≤ T ≤ 1000$
$2 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 10^{9}$
- The sum of $N$ across all test cases does not exceed $10^{5}$
----- Sample Input 1 ------
3
2
5 8
3
5 10 15
4
4 4 4 4
----- Sample Output 1 ------
13
25
8
----- explanation 1 ------
Test case $1$: Whether you right rotate the array or not, you will always end up with $A_{1}+A_{N} = 13$.
Test case $2$: It is optimal to right rotate the array once after which the array becomes $[15,5,10]$ with $A_{1} + A_{N} = 25$.
Test case $3$: No matter how much you right rotate the array, you will always obtain $A_{1} + A_{N} = 8$.
|
{"inputs": ["3\n2\n5 8\n3\n5 10 15\n4\n4 4 4 4\n"], "outputs": ["13\n25\n8\n"]}
| 527
| 46
|
coding
|
Solve the programming task below in a Python markdown code block.
Let's start from some definitions.
Strings A and B are called anagrams if it's possible to rearrange the letters of string A using all the original letters exactly once and achieve string B; in other words A and B are permutations of each other. For example, remote and meteor are anagrams, race and race are anagrams as well, while seat and tease aren't anagrams as tease contains an extra 'e'.
String A is called a subsequence of string B if A can be obtained from B by removing some (possibly none) characters. For example, cat is a subsequence of scratch, rage is a subsequence of rage, and tame is not a subsequence of steam.
String A is lexicographically smaller than string B of the same length if at the first position where A and B differ A contains a letter which is earlier in the alphabet than the corresponding letter in B.
Recently, Ann received a set of strings consisting of small Latin letters a..z. 'What can I do with them?' -- she asked herself. 'What if I try to find the longest string which is a subsequence of every string from the set?'. Ann spent a lot of time trying to solve the problem... but all her attempts happened to be unsuccessful. She then decided to allow the sought string to be an anagram of some subsequence of every string from the set. This problem seemed to be easier to Ann, but she was too tired to solve it, so Ann asked for your help.
So your task is, given a set of strings, to find the longest non-empty string which satisfies Ann. Moreover, if there are many such strings, choose the lexicographically smallest one.
------ Input ------
The first line of the input file contains one integer N -- the number of strings in the set (1 ≤ N ≤ 100). Each of the next N lines contains a non-empty string consisting only of small Latin letters a..z representing a string from the set. None of the strings contain more than 100 letters.
------ Output ------
Output the longest non-empty string satisfying Ann. If there are several such strings, output the lexicographically smallest one. If there are no such strings, output 'no such string' (quotes for clarity).
----- Sample Input 1 ------
3
hope
elephant
path
----- Sample Output 1 ------
hp
----- explanation 1 ------
In the first test case the longest string appears to be two characters long. String 'hp' satisfies the requirements as it's an anagram of 'hp' which is a subsequence of 'hope' and an anagram of 'ph' which is a subsequence of both 'elephant' and 'path'. Note that string 'ph' also satisfies the requirements, but 'hp' is lexicographically smaller.
----- Sample Input 2 ------
2
wall
step
----- Sample Output 2 ------
no such string
----- explanation 2 ------
In this test case there is no such string.
|
{"inputs": ["2\nwall\nstep", "2\nllaw\nstep", "2\namlu\nutfq", "2\nwmck\nmhqt", "2\nllwa\nstep", "2\nllwa\nstfp", "2\nmlwa\nstfp", "2\nawlm\nstfp"], "outputs": ["no such string", "no such string\n", "u\n", "m\n", "no such string\n", "no such string\n", "no such string\n", "no such string\n"]}
| 632
| 117
|
coding
|
Solve the programming task below in a Python markdown code block.
You have initially a string of N characters, denoted by A1,A2...AN. You have to print the size of the largest subsequence of string A such that all the characters in that subsequence are distinct ie. no two characters in that subsequence should be same.
A subsequence of string A is a sequence that can be derived from A by deleting some elements and without changing the order of the remaining elements.
-----Input-----
First line contains T, number of testcases. Each testcase consists of a single string in one line. Each character of the string will be a small alphabet(ie. 'a' to 'z').
-----Output-----
For each testcase, print the required answer in one line.
-----Constraints-----
- 1 ≤ T ≤ 10
- Subtask 1 (20 points):1 ≤ N ≤ 10
- Subtask 2 (80 points):1 ≤ N ≤ 105
-----Example-----
Input:
2
abc
aba
Output:
3
2
-----Explanation-----
For first testcase, the whole string is a subsequence which has all distinct characters.
In second testcase, the we can delete last or first 'a' to get the required subsequence.
|
{"inputs": ["2\nabc\naba", "2\nabd\naba", "2\nabc\naaa", "2\ncca\naaa", "2\nccb\naab", "2\nccb\ncba", "2\nbbb\nbaa", "2\nbbb\naaa"], "outputs": ["3\n2", "3\n2\n", "3\n1\n", "2\n1\n", "2\n2\n", "2\n3\n", "1\n2\n", "1\n1\n"]}
| 268
| 111
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given three numbers $a$, $b$, $c$ . Write a program to determine the largest number that is less than or equal to $c$ and leaves a remainder $b$ when divided by $a$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains a single line of input, having three integers $a$, $b$, $c$.
-----Output:-----
- For each testcase, output in a single line the largest number less than or equal to $c$.
-----Constraints:-----
- $1 \leq T \leq 100000$
- $0 \leq b < a < c \leq$ $10$^18
-----Sample Input:-----
1
7 2 10
-----Sample Output:-----
9
|
{"inputs": ["1\n7 2 10"], "outputs": ["9"]}
| 198
| 19
|
coding
|
Solve the programming task below in a Python markdown code block.
problem
There are fine icicles under the eaves of JOI's house in Canada. Because of this, JOI decided to investigate the icicles.
There are N (2 ≤ N ≤ 100000 = 105) icicles under the eaves of JOI's house. These icicles are aligned and i cm (1 ≤ i ≤ N) from the left edge of the eaves. There are i-th icicles at the position of. The length of the i-th icicle is initially ai cm (ai is an integer greater than or equal to 1). These icicles grow according to the following rule:
* The i-th icicles grow by 1 cm per hour only if they are longer than both the i − 1st icicles and the i + 1st icicles (however, consider only one icicle next to one end). That is, the first icicle grows if it is longer than the second icicle, and the Nth icicle grows if it is longer than the N − 1st icicle).
* All icicles break from the root the moment they reach L cm (2 ≤ L ≤ 50000) (the broken icicles are subsequently considered to be 0 cm long icicles).
In the first stage, the lengths of the two adjacent icicles are all different. At this time, if enough time has passed, all N icicles will break to a length of 0 cm. JOI, I wanted to know how long it would take for the icicles to reach this state.
Given the initial length of N icicles and the limit length L of the icicles, write a program that finds the time it takes for all the icicles to break.
output
The output consists of one line containing only one integer that represents the time it takes for all the icicles to break.
Input / output example
Input example 1
4 6
Four
2
3
Five
Output example 1
8
In the case of Example 1, the 1, 2, 3, and 4 icicles break after 2, 8, 4, and 1 hour, respectively. Therefore, it takes 8 hours for all the icicles to break. Output 8.
Input example 2
6 10
3
Four
1
9
Five
1
Output example 2
15
The above question sentences and the data used for the automatic referee are the question sentences created and published by the Japan Committee for Information Olympics and the test data for scoring.
input
On the first line of the input, the integer N, which represents the number of icicles, and the integer L, which represents the limit length of the icicles, are written in this order, separated by blanks. Input i + line 1 (1 ≤ i) In ≤ N), the integer ai (1 ≤ ai <L) representing the first length of the i-th icicle is written.
Of the scoring data, 30% of the points are N ≤ 500 and L ≤ 1000.
Example
Input
4 6
4
2
3
5
Output
8
|
{"inputs": ["4 6\n7\n2\n3\n5", "4 6\n4\n1\n3\n5", "1 6\n4\n2\n3\n1", "4 5\n4\n2\n3\n1", "1 6\n3\n2\n3\n1", "1 6\n2\n2\n3\n1", "4 9\n7\n2\n3\n5", "1 6\n1\n0\n1\n1"], "outputs": ["8\n", "9\n", "2\n", "6\n", "3\n", "4\n", "17\n", "5\n"]}
| 687
| 143
|
coding
|
Solve the programming task below in a Python markdown code block.
The store sells $n$ items, the price of the $i$-th item is $p_i$. The store's management is going to hold a promotion: if a customer purchases at least $x$ items, $y$ cheapest of them are free.
The management has not yet decided on the exact values of $x$ and $y$. Therefore, they ask you to process $q$ queries: for the given values of $x$ and $y$, determine the maximum total value of items received for free, if a customer makes one purchase.
Note that all queries are independent; they don't affect the store's stock.
-----Input-----
The first line contains two integers $n$ and $q$ ($1 \le n, q \le 2 \cdot 10^5$) — the number of items in the store and the number of queries, respectively.
The second line contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le 10^6$), where $p_i$ — the price of the $i$-th item.
The following $q$ lines contain two integers $x_i$ and $y_i$ each ($1 \le y_i \le x_i \le n$) — the values of the parameters $x$ and $y$ in the $i$-th query.
-----Output-----
For each query, print a single integer — the maximum total value of items received for free for one purchase.
-----Examples-----
Input
5 3
5 3 1 5 2
3 2
1 1
5 3
Output
8
5
6
-----Note-----
In the first query, a customer can buy three items worth $5, 3, 5$, the two cheapest of them are $3 + 5 = 8$.
In the second query, a customer can buy two items worth $5$ and $5$, the cheapest of them is $5$.
In the third query, a customer has to buy all the items to receive the three cheapest of them for free; their total price is $1 + 2 + 3 = 6$.
|
{"inputs": ["2 1\n100 200\n1 1\n", "1 1\n1000000\n1 1\n", "3 1\n100 200 100\n2 1\n", "2 2\n100 200\n2 2\n2 1\n", "5 3\n5 3 1 5 2\n3 2\n1 1\n5 3\n", "5 2\n100 200 300 400 500\n1 1\n3 2\n", "5 3\n100 200 300 400 500\n2 1\n1 1\n3 2\n", "5 3\n100 200 300 400 500\n1 1\n3 2\n2 2\n"], "outputs": ["200\n", "1000000\n", "100\n", "300\n100\n", "8\n5\n6\n", "500\n700\n", "400\n500\n700\n", "500\n700\n900\n"]}
| 477
| 302
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef develops his own computer program for playing chess. He is at the very beginning. At first he needs to write the module that will receive moves written by the players and analyze it. The module will receive a string and it should report at first whether this string represents the correct pair of cells on the chess board (we call such strings correct) and then report whether it represents the correct move depending on the situation on the chess board. Chef always has troubles with analyzing knight moves. So at first he needs a test program that can say whether a given string is correct and then whether it represents a correct knight move (irregardless of the situation on the chess board). The cell on the chessboard is represented as a string of two characters: first character is a lowercase Latin letter from a to h and the second character is a digit from 1 to 8. The string represents the correct pair of cells on the chess board if it composed of 5 characters where first two characters represent the cell where chess figure was, 3rd character is the dash "-" and the last two characters represent the destination cell.
-----Input-----
The first line contains a single integer T <= 50000, the number of test cases. T test cases follow. The only line of each test case contains a non-empty string composed the characters with ASCII-codes from 32 to 126. The length of the string is not greater than 10.
-----Output-----
For each test case, output a single line containing the word "Error" if the corresponding string does not represent the correct pair of cells on the chess board. Otherwise output "Yes" if this pair of cells represents the correct knight move and "No" otherwise.
-----Example-----
Input:
4
a1-b3
d2-h8
a3 c4
ErrorError
Output:
Yes
No
Error
Error
|
{"inputs": ["4\na1-b3\nd2-h8\na3 c4\nErrorError"], "outputs": ["Yes\nNo\nError\nError"]}
| 398
| 36
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You may recall that an array arr is a mountain array if and only if:
arr.length >= 3
There exists some index i (0-indexed) with 0 < i < arr.length - 1 such that:
arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
arr[i] > arr[i + 1] > ... > arr[arr.length - 1]
Given an integer array nums, return the minimum number of elements to remove to make nums a mountain array.
Please complete the following python code precisely:
```python
class Solution:
def minimumMountainRemovals(self, nums: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(nums = [1,3,1]) == 0\n assert candidate(nums = [2,1,1,5,6,2,3,1]) == 3\n\n\ncheck(Solution().minimumMountainRemovals)"}
| 165
| 64
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.
Note that after backspacing an empty text, the text will continue empty.
Please complete the following python code precisely:
```python
class Solution:
def backspaceCompare(self, s: str, t: str) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(s = \"ab#c\", t = \"ad#c\") == True\n assert candidate(s = \"ab##\", t = \"c#d#\") == True\n assert candidate(s = \"a#c\", t = \"b\") == False\n\n\ncheck(Solution().backspaceCompare)"}
| 96
| 75
|
coding
|
Solve the programming task below in a Python markdown code block.
Jou and Yae are a good couple. Jou is collecting prizes for capsule toy vending machines (Gachapon), and even when they go out together, when they find Gachapon, they seem to get so hot that they try it several times. Yae was just looking at Jou, who looked happy, but decided to give him a Gachapon prize for his upcoming birthday present. Yae wasn't very interested in Gachapon itself, but hopefully he would like a match with Jou.
For Gachapon that Yae wants to try, one prize will be given in one challenge. You can see how many types of prizes there are, including those that are out of stock, and how many of each prize remains. However, I don't know which prize will be given in one challenge. Therefore, regardless of the order in which the prizes are given, create a program that outputs the minimum number of challenges required for Yae to get two of the same prizes.
input
The input consists of multiple datasets. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
N
k1 k2 ... kN
Each dataset has two lines, and the first line is given the integer N (1 ≤ N ≤ 10000), which indicates how many types of prizes there are. The next line is given the integer ki (0 ≤ ki ≤ 10000), which indicates how many prizes are left.
The number of datasets does not exceed 100.
output
For each dataset, the minimum number of challenges required to get two identical prizes is output. However, if it is not possible, NA is output.
Example
Input
2
3 2
3
0 1 1
1
1000
0
Output
3
NA
2
|
{"inputs": ["2\n3 0\n3\n0 1 1\n1\n1000\n0", "2\n3 2\n3\n0 1 1\n1\n0000\n0", "2\n1 0\n3\n0 1 1\n1\n1000\n0", "2\n2 0\n3\n0 1 1\n0\n1100\n0", "2\n1 0\n3\n0 1 1\n0\n1100\n0", "2\n3 2\n3\n0 0 1\n1\n1000\n0", "2\n6 4\n3\n0 1 2\n1\n0000\n0", "2\n0 4\n3\n0 1 2\n1\n0000\n0"], "outputs": ["2\nNA\n2\n", "3\nNA\nNA\n", "NA\nNA\n2\n", "2\nNA\n", "NA\nNA\n", "3\nNA\n2\n", "3\n3\nNA\n", "2\n3\nNA\n"]}
| 397
| 258
|
coding
|
Solve the programming task below in a Python markdown code block.
Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings a and b of equal length are called equivalent in one of the two cases: They are equal. If we split string a into two halves of the same size a_1 and a_2, and string b into two halves of the same size b_1 and b_2, then one of the following is correct: a_1 is equivalent to b_1, and a_2 is equivalent to b_2 a_1 is equivalent to b_2, and a_2 is equivalent to b_1
As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent.
Gerald has already completed this home task. Now it's your turn!
-----Input-----
The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200 000 and consists of lowercase English letters. The strings have the same length.
-----Output-----
Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise.
-----Examples-----
Input
aaba
abaa
Output
YES
Input
aabb
abab
Output
NO
-----Note-----
In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a".
In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".
|
{"inputs": ["a\na\n", "a\nb\n", "a\na\n", "a\nb\n", "a\nc\n", "a\nd\n", "`\nc\n", "`\nd\n"], "outputs": ["YES\n", "NO\n", "YES\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n"]}
| 409
| 84
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
You are given two strings s and t of the same length, consisting of uppercase English letters. Your task is to find the minimum number of "replacement operations" needed to get some `anagram` of the string t from the string s. A replacement operation is performed by picking exactly one character from the string s and replacing it by some other character.
About `anagram`: А string x is an anagram of a string y if one can get y by rearranging the letters of x. For example, the strings "MITE" and "TIME" are anagrams, so are "BABA" and "AABB", but "ABBAC" and "CAABA" are not.
# Example
For s = "AABAA" and t = "BBAAA", the output should be 1;
For s = "OVGHK" and t = "RPGUC", the output should be 4.
# Input/Output
- `[input]` string `s`
Constraints: `5 ≤ s.length ≤ 35`.
- `[input]` string `t`
Constraints: `t.length = s.length`.
- `[output]` an integer
The minimum number of replacement operations needed to get an anagram of the string t from the string s.
Also feel free to reuse/extend the following starter code:
```python
def create_anagram(s, t):
```
|
{"functional": "_inputs = [['AABAA', 'BBAAA'], ['OVGHK', 'RPGUC'], ['AAAAAAAAAAAAAAAAAAAAAAAAAAAAAB', 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAC']]\n_outputs = [[1], [4], [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(create_anagram(*i), o[0])"}
| 309
| 191
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese and Russian.
Cascading Style Sheets, or CSS is a style sheet language, most popularly known for styling web pages. Each object on a web page (like a picture, a paragraph, a table) can have various properties (like height, width, size, colour), and these properties can be set using CSS. Each of these objects has a unique identifier called id, using which CSS can identify the object and assign value to its property.
Due to hierarchical nature of the web page, often same property of an object gets assigned different values in different CSS statements. To decide what the final value will be, each statement has a priority assigned to it. The statement with the highest priority will be the one that sets the value of the property. If there are more than one statements with same priority, then the one which was executed last amongst those will set the value.
Given multiple CSS statements in the order they were executed, answer a few queries about the final values of certain objects
------ Input ------
First line contains two space-separated integers N and M, the number of CSS statements and the number of queries respectively.
Following N lines will each have 4 values id, attr, val, priority, which mean that a CSS statement tries to assign value val to the attribute named attr of the object id, and that the priority of this statement is equal to priority.
Each of the next M lines will contain two values id and attr, for which you have to print value of the attribute attr of object id. You can assume that there is a statement that assigns value to this attribute attr of object id.
------ Output ------
Print exactly M lines, i^{th} line contains the answer to the i^{th} query as described above.
------ Constraints ------
1 ≤ value, priority ≤ 10^{6}, for all subtasks.
For 20 points : 1 ≤ id, N, M, attr ≤ 10^{3}For 30 points : 1 ≤ N, M ≤ 10^{3}, 1 ≤ id, attr ≤ 10^{6}For 50 points : 1 ≤ N, M ≤ 10^{5}, 1 ≤ id, attr ≤ 10^{6}
----- Sample Input 1 ------
3 1
22 1 200 2
22 1 300 2
22 1 100 1
22 1
----- Sample Output 1 ------
300
|
{"inputs": ["3 1\n22 1 200 2\n22 1 300 2\n22 1 100 1\n22 1"], "outputs": ["300"]}
| 540
| 54
|
coding
|
Solve the programming task below in a Python markdown code block.
Your class recently got a maths assignment with 5 questions. There are N (≤ 20) students in the class and at most 2 people can collaborate. For each student, you know which problems they solved.
Find out if there exists a team of two students who can together solve all problems.
------ Input Format ------
The first line of input will contain a single integer T, denoting the number of test cases. T test cases follow.
- Each of the following test cases contains N + 1 lines, where N is the number of students in the class.
- The first line contains a single integer N.
- Each of the following N lines contains K_{i} + 1 positive integers separated by whitespaces.
- In the i^{th} line, the first positive integer K_{i} is the number of problems the i^{th} student can solve. The next K_{i} integers are x_{1}, x_{2}, \ldots, x_{K_{i}}, the indices of the problems this student can solve.
------ Output Format ------
The output must consist of T lines.
- Each line must contain a single string: The solution to the i^{th} test case as a YES or NO (where YES should be returned if some pairing of students is capable of solving all the problems, and NO otherwise).
You may print each character of the string in uppercase or lowercase (for example, the strings YES, yEs, yes, and yeS will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 1000$
$2 ≤ N ≤ 20$
$0 ≤ K_{i} ≤ 5$
$1 ≤ x_{i} ≤ 5$
----- Sample Input 1 ------
4
3
1 3
1 1
4 1 3 4 5
2
4 2 3 4 5
3 1 2 4
3
1 1
1 2
1 3
2
2 1 5
3 2 3 4
----- Sample Output 1 ------
NO
YES
NO
YES
----- explanation 1 ------
Test case $1:$ There is no student who solved the second question.
Test case $2:$ The second student can solve the first question and the first student can solve all the remaining problems, so they can form a team to solve all the problems together.
Test case $3:$ There is no student who solved fourth and fifth questions.
Test case $4:$ Given $2$ people can collaborate to solve all the problems.
|
{"inputs": ["4\n3\n1 3\n1 1\n4 1 3 4 5\n2\n4 2 3 4 5\n3 1 2 4\n3\n1 1\n1 2\n1 3\n2\n2 1 5\n3 2 3 4\n"], "outputs": ["NO\nYES\nNO\nYES"]}
| 558
| 89
|
coding
|
Solve the programming task below in a Python markdown code block.
Consider an array $a$ of $n$ positive integers.
You may perform the following operation:
select two indices $l$ and $r$ ($1 \leq l \leq r \leq n$), then
decrease all elements $a_l, a_{l + 1}, \dots, a_r$ by $1$.
Let's call $f(a)$ the minimum number of operations needed to change array $a$ into an array of $n$ zeros.
Determine if for all permutations$^\dagger$ $b$ of $a$, $f(a) \leq f(b)$ is true.
$^\dagger$ An array $b$ is a permutation of an array $a$ if $b$ consists of the elements of $a$ in arbitrary order. For example, $[4,2,3,4]$ is a permutation of $[3,2,4,4]$ while $[1,2,2]$ is not a permutation of $[1,2,3]$.
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 10^4$) — the number of test cases.
The first line of each test case contains a single integer $n$ ($1 \leq n \leq 10^5$) — the length of the array $a$.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$) — description of the array $a$.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case, print "YES" (without quotes) if for all permutations $b$ of $a$, $f(a) \leq f(b)$ is true, and "NO" (without quotes) otherwise.
You can output "YES" and "NO" in any case (for example, strings "yEs", "yes" and "Yes" will be recognized as a positive response).
-----Examples-----
Input
3
4
2 3 5 4
3
1 2 3
4
3 1 3 2
Output
YES
YES
NO
-----Note-----
In the first test case, we can change all elements to $0$ in $5$ operations. It can be shown that no permutation of $[2, 3, 5, 4]$ requires less than $5$ operations to change all elements to $0$.
In the third test case, we need $5$ operations to change all elements to $0$, while $[2, 3, 3, 1]$ only needs $3$ operations.
|
{"inputs": ["3\n4\n2 3 5 4\n3\n1 2 3\n4\n3 1 3 2\n", "1\n5\n1000000000 1 1000000000 1 1000000000\n"], "outputs": ["YES\nYES\nNO\n", "NO\n"]}
| 610
| 93
|
coding
|
Solve the programming task below in a Python markdown code block.
Programmer Deepak has created a program which calculates magical number as 2^n * 3^n * 5^n where "n" is an integer.
Now he wants to find the magical number which is just greater than the input. Help him in finding it.
NOTE : a^b denotes a raised to power b.
Input :
456
NOTE : You do not need to create a program for this problem you have to write your answers of small input and large input in given code snippet
To see how to submit solution please check this link
SAMPLE INPUT
28
SAMPLE OUTPUT
30
|
{"inputs": ["456"], "outputs": ["900"]}
| 139
| 16
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Russian], [Mandarin Chinese], [Bengali], and [Vietnamese] as well.
In a season, each player has three statistics: runs, wickets, and catches. Given the season stats of two players A and B, denoted by R, W, and C respectively, the person who is better than the other in the most statistics is regarded as the better overall player. Tell who is better amongst A and B. It is known that in each statistic, the players have different values.
------ Input Format ------
- The first line contains an integer T, the number of test cases. Then the test cases follow.
- Each test case contains two lines of input.
- The first line contains three integers R_{1}, W_{1}, C_{1}, the stats for player A.
- The second line contains three integers R_{2}, W_{2}, C_{2}, the stats for player B.
------ Output Format ------
For each test case, output in a single line "A" (without quotes) if player A is better than player B and "B" (without quotes) otherwise.
------ Constraints ------
$1 ≤ T ≤ 1000$
$0 ≤ R_{1}, R_{2} ≤ 500$
$0 ≤ W_{1}, W_{2} ≤ 20$
$0 ≤ C_{1}, C_{2} ≤ 20$
$R_{1} \neq R_{2}$
$W_{1} \neq W_{2}$
$C_{1} \neq C_{2}$
------ subtasks ------
Subtask 1 (30 points): $1 ≤ R ≤ 10000$
Subtask 2 (70 points): $1 ≤ R ≤ 10^{9}$
----- Sample Input 1 ------
3
0 1 2
2 3 4
10 10 10
8 8 8
10 0 10
0 10 0
----- Sample Output 1 ------
B
A
A
----- explanation 1 ------
Test Case $1$: Player $B$ is better than $A$ in all $3$ fields.
Test Case $2$: Player $A$ is better than $B$ in all $3$ fields.
Test Case $3$: Player $A$ is better than $B$ in runs scored and number of catches.
|
{"inputs": ["3\n0 1 2\n2 3 4\n10 10 10\n8 8 8\n10 0 10\n0 10 0"], "outputs": ["B\nA\nA"]}
| 535
| 58
|
coding
|
Solve the programming task below in a Python markdown code block.
Our master carpenter is designing a condominium called Bange Hills Mansion. The condominium is constructed by stacking up floors of the same height. The height of each floor is designed so that the total height of the stacked floors coincides with the predetermined height of the condominium. The height of each floor can be adjusted freely with a certain range.
The final outcome of the building depends on clever height allotment for each floor. So, he plans to calculate possible combinations of per-floor heights to check how many options he has.
Given the height of the condominium and the adjustable range of each floor’s height, make a program to enumerate the number of choices for a floor.
Input
The input is given in the following format.
$H$ $A$ $B$
The input line provides the height of the condominium $H$ ($1 \leq H \leq 10^5$) and the upper and lower limits $A$ and $B$ of the height adjustable range for one floor ($1 \leq A \leq B \leq H$). All data are given as integers.
Output
Output the number of possible height selections for each floor in a line.
Examples
Input
100 2 4
Output
2
Input
101 3 5
Output
0
|
{"inputs": ["101 2 5", "100 2 5", "111 2 5", "000 2 5", "010 2 8", "000 2 8", "101 2 8", "100 2 8"], "outputs": ["0\n", "3\n", "1\n", "4\n", "2\n", "7\n", "0\n", "3\n"]}
| 283
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given circular array a0, a1, ..., an - 1. There are two types of operations with it:
* inc(lf, rg, v) — this operation increases each element on the segment [lf, rg] (inclusively) by v;
* rmq(lf, rg) — this operation returns minimal value on the segment [lf, rg] (inclusively).
Assume segments to be circular, so if n = 5 and lf = 3, rg = 1, it means the index sequence: 3, 4, 0, 1.
Write program to process given sequence of operations.
Input
The first line contains integer n (1 ≤ n ≤ 200000). The next line contains initial state of the array: a0, a1, ..., an - 1 ( - 106 ≤ ai ≤ 106), ai are integer. The third line contains integer m (0 ≤ m ≤ 200000), m — the number of operartons. Next m lines contain one operation each. If line contains two integer lf, rg (0 ≤ lf, rg ≤ n - 1) it means rmq operation, it contains three integers lf, rg, v (0 ≤ lf, rg ≤ n - 1; - 106 ≤ v ≤ 106) — inc operation.
Output
For each rmq operation write result for it. Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
4
1 2 3 4
4
3 0
3 0 -1
0 1
2 1
Output
1
0
0
|
{"inputs": ["1\n1\n1\n0 0 0\n", "4\n1 2 3 4\n4\n3 0\n3 0 -1\n0 1\n2 1\n", "1\n-1\n10\n0 0 -1\n0 0\n0 0 1\n0 0\n0 0 1\n0 0\n0 0 0\n0 0\n0 0 -1\n0 0 1\n", "2\n-1 -1\n10\n0 0\n0 0\n0 0 1\n0 0\n1 1\n0 0 -1\n0 0 0\n0 0 1\n1 1 0\n0 0 -1\n"], "outputs": ["", "1\n0\n0\n", "-2\n-1\n0\n0\n", "-1\n-1\n0\n-1\n"]}
| 406
| 211
|
coding
|
Solve the programming task below in a Python markdown code block.
A tennis tournament with n participants is running. The participants are playing by an olympic system, so the winners move on and the losers drop out.
The tournament takes place in the following way (below, m is the number of the participants of the current round): let k be the maximal power of the number 2 such that k ≤ m, k participants compete in the current round and a half of them passes to the next round, the other m - k participants pass to the next round directly, when only one participant remains, the tournament finishes.
Each match requires b bottles of water for each participant and one bottle for the judge. Besides p towels are given to each participant for the whole tournament.
Find the number of bottles and towels needed for the tournament.
Note that it's a tennis tournament so in each match two participants compete (one of them will win and the other will lose).
-----Input-----
The only line contains three integers n, b, p (1 ≤ n, b, p ≤ 500) — the number of participants and the parameters described in the problem statement.
-----Output-----
Print two integers x and y — the number of bottles and towels need for the tournament.
-----Examples-----
Input
5 2 3
Output
20 15
Input
8 2 4
Output
35 32
-----Note-----
In the first example will be three rounds: in the first round will be two matches and for each match 5 bottles of water are needed (two for each of the participants and one for the judge), in the second round will be only one match, so we need another 5 bottles of water, in the third round will also be only one match, so we need another 5 bottles of water.
So in total we need 20 bottles of water.
In the second example no participant will move on to some round directly.
|
{"inputs": ["5 2 3\n", "8 2 4\n", "1 2 3\n", "1 3 4\n", "1 1 1\n", "1 2 5\n", "1 3 8\n", "1 3 5\n"], "outputs": ["20 15\n", "35 32\n", "0 3\n", "0 4\n", "0 1\n", "0 5\n", "0 8\n", "0 5\n"]}
| 410
| 122
|
coding
|
Solve the programming task below in a Python markdown code block.
We have a sequence of N integers: x=(x_0,x_1,\cdots,x_{N-1}). Initially, x_i=0 for each i (0 \leq i \leq N-1).
Snuke will perform the following operation exactly M times:
* Choose two distinct indices i, j (0 \leq i,j \leq N-1,\ i \neq j). Then, replace x_i with x_i+2 and x_j with x_j+1.
Find the number of different sequences that can result after M operations. Since it can be enormous, compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq M \leq 5 \times 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of different sequences that can result after M operations, modulo 998244353.
Examples
Input
2 2
Output
3
Input
3 2
Output
19
Input
10 10
Output
211428932
Input
100000 50000
Output
3463133
|
{"inputs": ["0 2", "5 7", "6 7", "3 7", "3 3", "3 6", "2 5", "5 6"], "outputs": ["0\n", "11600\n", "63008\n", "169\n", "37\n", "127\n", "6\n", "6685\n"]}
| 309
| 94
|
coding
|
Solve the programming task below in a Python markdown code block.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
-----Input-----
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers a_{i} (0 ≤ a_{i} ≤ n - 1) — the statue currently placed on the i-th island. If a_{i} = 0, then the island has no statue. It is guaranteed that the a_{i} are distinct.
The third line contains n space-separated integers b_{i} (0 ≤ b_{i} ≤ n - 1) — the desired statues of the ith island. Once again, b_{i} = 0 indicates the island desires no statue. It is guaranteed that the b_{i} are distinct.
-----Output-----
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
-----Examples-----
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
-----Note-----
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
|
{"inputs": ["2\n1 0\n0 1\n", "2\n0 1\n0 1\n", "2\n1 0\n1 0\n", "2\n1 0\n1 0\n", "2\n0 1\n0 1\n", "2\n1 0\n0 1\n", "3\n1 0 2\n2 0 1\n", "3\n0 2 1\n1 2 0\n"], "outputs": ["YES\n", "YES\n", "YES\n", "YES", "YES", "YES", "YES\n", "YES\n"]}
| 539
| 139
|
coding
|
Solve the programming task below in a Python markdown code block.
JJ has an array A of size N. He can perform the following operations on the array at most K times:
Set A_{i} := A_{i + 1} where 1 ≤ i ≤ N - 1
Set A_{i} := A_{i - 1} where 2 ≤ i ≤ N
He wants to maximize the value of the minimum element of the array A. Formally, he wants to maximize the value of \min\limits_{1 ≤ i ≤ N} A_{i}.
Can you help him do so?
------ Input Format ------
- The first line contains a single integer T - the number of test cases. Then the test cases follow.
- The first line of each test case contains two integers N and K - the size of the array A and the maximum number of operations allowed respectively.
- The second line of each test case contains N space-separated integers A_{1}, A_{2}, \dots, A_{N} denoting the array A.
------ Output Format ------
For each test case, output the maximum value of the minimum element of the array A that can be obtained after applying the given operation at most K times.
------ Constraints ------
$1 ≤ T ≤ 100$
$2 ≤ N ≤ 10^{5}$
$0 ≤K ≤10^{5}$
$1 ≤A_{i} ≤10^{9}$
- Sum of $N$ over all test cases does not exceed $2 \cdot 10^{5}$
----- Sample Input 1 ------
4
5 4
5 4 3 2 1
6 1
8 2 3 9 6 10
5 2
4 3 4 3 5
5 1000
4 3 4 3 5
----- Sample Output 1 ------
5
3
4
5
----- explanation 1 ------
Test Case 1: We can perform the following operations (in the following order):
- Set $A_{2} := A_{1}$. Array $A$ becomes $[5, 5, 3, 2, 1]$
- Set $A_{3} := A_{2}$. Array $A$ becomes $[5, 5, 5, 2, 1]$
- Set $A_{4} := A_{3}$. Array $A$ becomes $[5, 5, 5, 5, 1]$
- Set $A_{5} := A_{4}$. Array $A$ becomes $[5, 5, 5, 5, 5]$
Therefore the answer is $5$.
Test Case 2: We can perform the following operations (in the following order):
- Set $A_{2} := A_{3}$. Array $A$ becomes $[8, 3, 3, 9, 6, 10]$
Therefore the answer is $3$.
Test Case 3: We can perform the following operations (in the following order):
- Set $A_{2} := A_{3}$. Array $A$ becomes $[4, 4, 4, 3, 5]$
- Set $A_{4} := A_{3}$. Array $A$ becomes $[4, 4, 4, 4, 5]$
Therefore the answer is $4$.
|
{"inputs": ["4\n5 4\n5 4 3 2 1\n6 1\n8 2 3 9 6 10\n5 2\n4 3 4 3 5\n5 1000\n4 3 4 3 5\n"], "outputs": ["5\n3\n4\n5\n"]}
| 746
| 82
|
coding
|
Solve the programming task below in a Python markdown code block.
Solve the Mystery.
Input :
First line contains T - No. of Test cases.
Each Test case consists of 2 lines.
First line contains K.
Second line contains 3 space separated Integers A1 ,A2 ,A3.
Output :
Print required answers in separate lines.
Constraints :
1 ≤ T ≤ 100
1 ≤ K ≤ 10
0 ≤ Ai ≤10
SAMPLE INPUT
2
2
5 4 3
3
1 2 2
SAMPLE OUTPUT
144
125
|
{"inputs": ["10\n1\n1 1 1\n2\n1 2 3\n3\n2 3 5\n4\n5 4 6\n5\n1 7 6\n1\n4 4 4\n2\n10 10 10\n3\n9 8 7\n4\n1 5 7\n5\n9 7 9", "100\n5\n3 10 3\n8\n0 0 0\n2\n7 0 8\n5\n1 9 0\n10\n10 10 10\n3\n0 4 8\n7\n10 9 10\n9\n0 7 5\n4\n7 6 7\n10\n8 3 4\n6\n1 10 9\n4\n6 10 3\n4\n5 4 7\n1\n8 4 7\n5\n0 4 0\n1\n0 4 3\n6\n8 8 9\n8\n0 0 8\n8\n10 4 2\n6\n1 5 4\n7\n9 9 9\n3\n0 5 0\n2\n7 9 10\n3\n2 2 2\n2\n10 9 3\n1\n9 9 0\n3\n3 2 9\n3\n6 2 9\n6\n9 5 7\n8\n8 7 9\n5\n6 7 1\n4\n9 1 4\n1\n10 8 5\n2\n6 5 3\n5\n5 10 1\n7\n10 8 1\n6\n3 8 6\n7\n3 2 5\n2\n9 4 2\n2\n5 5 2\n6\n2 7 10\n5\n10 0 3\n9\n10 2 1\n5\n10 2 4\n2\n10 8 1\n4\n10 4 9\n5\n8 10 2\n3\n4 4 2\n7\n9 10 10\n10\n10 0 10\n2\n0 0 3\n10\n2 5 9\n7\n2 8 2\n5\n1 10 8\n5\n7 10 5\n4\n1 7 4\n1\n4 1 5\n3\n0 5 8\n7\n3 9 9\n6\n1 6 6\n8\n3 6 5\n3\n3 0 10\n10\n9 3 10\n2\n8 1 6\n6\n1 0 3\n3\n5 10 1\n9\n6 9 2\n5\n4 6 0\n3\n10 3 10\n2\n2 8 0\n1\n0 9 6\n7\n10 1 10\n8\n2 1 1\n10\n0 1 1\n2\n10 1 1\n3\n5 0 8\n2\n3 6 6\n7\n3 6 1\n7\n4 8 9\n7\n9 7 0\n7\n8 0 2\n4\n1 1 10\n6\n3 10 10\n3\n10 5 9\n8\n0 4 4\n1\n9 5 2\n4\n0 10 2\n7\n6 1 6\n7\n1 6 5\n4\n8 4 7\n3\n1 4 2\n1\n9 1 10\n10\n3 3 7\n2\n6 10 0\n8\n9 0 4\n9\n1 8 3\n10\n2 8 0\n5\n10 7 6\n5\n0 8 8\n9\n7 7 3"], "outputs": ["3\n36\n1000\n50625\n537824\n12\n900\n13824\n28561\n9765625", "1048576\n0\n225\n100000\n590490000000000\n1728\n17249876309\n5159780352\n160000\n576650390625\n64000000\n130321\n65536\n19\n1024\n7\n244140625\n16777216\n4294967296\n1000000\n10460353203\n125\n676\n216\n484\n18\n2744\n4913\n85766121\n110075314176\n537824\n38416\n23\n196\n1048576\n893871739\n24137569\n10000000\n225\n144\n47045881\n371293\n10604499373\n1048576\n361\n279841\n3200000\n1000\n17249876309\n10240000000000\n9\n1099511627776\n35831808\n2476099\n5153632\n20736\n10\n2197\n1801088541\n4826809\n1475789056\n2197\n26559922791424\n225\n4096\n4096\n118587876497\n100000\n12167\n100\n15\n1801088541\n65536\n1024\n144\n2197\n225\n10000000\n1801088541\n268435456\n10000000\n20736\n148035889\n13824\n16777216\n16\n20736\n62748517\n35831808\n130321\n343\n20\n137858491849\n256\n815730721\n5159780352\n10000000000\n6436343\n1048576\n118587876497"]}
| 131
| 1,747
|
coding
|
Solve the programming task below in a Python markdown code block.
Now that Kuroni has reached 10 years old, he is a big boy and doesn't like arrays of integers as presents anymore. This year he wants a Bracket sequence as a Birthday present. More specifically, he wants a bracket sequence so complex that no matter how hard he tries, he will not be able to remove a simple subsequence!
We say that a string formed by $n$ characters '(' or ')' is simple if its length $n$ is even and positive, its first $\frac{n}{2}$ characters are '(', and its last $\frac{n}{2}$ characters are ')'. For example, the strings () and (()) are simple, while the strings )( and ()() are not simple.
Kuroni will be given a string formed by characters '(' and ')' (the given string is not necessarily simple). An operation consists of choosing a subsequence of the characters of the string that forms a simple string and removing all the characters of this subsequence from the string. Note that this subsequence doesn't have to be continuous. For example, he can apply the operation to the string ')()(()))', to choose a subsequence of bold characters, as it forms a simple string '(())', delete these bold characters from the string and to get '))()'.
Kuroni has to perform the minimum possible number of operations on the string, in such a way that no more operations can be performed on the remaining string. The resulting string does not have to be empty.
Since the given string is too large, Kuroni is unable to figure out how to minimize the number of operations. Can you help him do it instead?
A sequence of characters $a$ is a subsequence of a string $b$ if $a$ can be obtained from $b$ by deletion of several (possibly, zero or all) characters.
-----Input-----
The only line of input contains a string $s$ ($1 \le |s| \le 1000$) formed by characters '(' and ')', where $|s|$ is the length of $s$.
-----Output-----
In the first line, print an integer $k$ — the minimum number of operations you have to apply. Then, print $2k$ lines describing the operations in the following format:
For each operation, print a line containing an integer $m$ — the number of characters in the subsequence you will remove.
Then, print a line containing $m$ integers $1 \le a_1 < a_2 < \dots < a_m$ — the indices of the characters you will remove. All integers must be less than or equal to the length of the current string, and the corresponding subsequence must form a simple string.
If there are multiple valid sequences of operations with the smallest $k$, you may print any of them.
-----Examples-----
Input
(()((
Output
1
2
1 3
Input
)(
Output
0
Input
(()())
Output
1
4
1 2 5 6
-----Note-----
In the first sample, the string is '(()(('. The operation described corresponds to deleting the bolded subsequence. The resulting string is '(((', and no more operations can be performed on it. Another valid answer is choosing indices $2$ and $3$, which results in the same final string.
In the second sample, it is already impossible to perform any operations.
|
{"inputs": [")(\n", "()\n", "()\n", "((\n", "))\n", ")(\n", "(()((\n", "())((\n"], "outputs": ["0\n", "1\n2\n1 2 \n", "1\n2\n1 2 ", "0\n", "0\n", "0", "1\n2\n1 3 \n", "1\n2\n1 3\n"]}
| 719
| 101
|
coding
|
Solve the programming task below in a Python markdown code block.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a_1, a_2, ..., a_{k} and b_1, b_2, ..., b_{k} satisfying the following requirements:
k ≥ 1 $\forall i(1 \leq i \leq k) 1 \leq a_{i}, b_{i} \leq|s|$ $\forall i(1 \leq i \leq k) b_{i} \geq a_{i}$ $\forall i(2 \leq i \leq k) a_{i} > b_{i - 1}$ $\forall i(1 \leq i \leq k)$ t is a substring of string s_{a}_{i}s_{a}_{i} + 1... s_{b}_{i} (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 10^9 + 7.
-----Input-----
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 10^5). Each string consists of lowercase Latin letters.
-----Output-----
Print the answer in a single line.
-----Examples-----
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
|
{"inputs": ["a\na\n", "a\nb\n", "a\na\n", "a\nb\n", "c\nc\n", "a\nc\n", "b\nc\n", "c\nb\n"], "outputs": ["1\n", "0\n", "1", "0", "1\n", "0\n", "0\n", "0\n"]}
| 407
| 84
|
coding
|
Solve the programming task below in a Python markdown code block.
Caracal is fighting with a monster.
The health of the monster is H.
Caracal can attack by choosing one monster. When a monster is attacked, depending on that monster's health, the following happens:
- If the monster's health is 1, it drops to 0.
- If the monster's health, X, is greater than 1, that monster disappears. Then, two new monsters appear, each with the health of \lfloor X/2 \rfloor.
(\lfloor r \rfloor denotes the greatest integer not exceeding r.)
Caracal wins when the healths of all existing monsters become 0 or below.
Find the minimum number of attacks Caracal needs to make before winning.
-----Constraints-----
- 1 \leq H \leq 10^{12}
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
H
-----Output-----
Find the minimum number of attacks Caracal needs to make before winning.
-----Sample Input-----
2
-----Sample Output-----
3
When Caracal attacks the initial monster, it disappears, and two monsters appear, each with the health of 1.
Then, Caracal can attack each of these new monsters once and win with a total of three attacks.
|
{"inputs": ["8", "3", "7", "1", "5", "6", "9", "4"], "outputs": ["15\n", "3\n", "7\n", "1\n", "7\n", "7\n", "15\n", "7"]}
| 283
| 63
|
coding
|
Solve the programming task below in a Python markdown code block.
Polycarp remembered the $2020$-th year, and he is happy with the arrival of the new $2021$-th year. To remember such a wonderful moment, Polycarp wants to represent the number $n$ as the sum of a certain number of $2020$ and a certain number of $2021$.
For example, if:
$n=4041$, then the number $n$ can be represented as the sum $2020 + 2021$;
$n=4042$, then the number $n$ can be represented as the sum $2021 + 2021$;
$n=8081$, then the number $n$ can be represented as the sum $2020 + 2020 + 2020 + 2021$;
$n=8079$, then the number $n$ cannot be represented as the sum of the numbers $2020$ and $2021$.
Help Polycarp to find out whether the number $n$ can be represented as the sum of a certain number of numbers $2020$ and a certain number of numbers $2021$.
-----Input-----
The first line contains one integer $t$ ($1 \leq t \leq 10^4$) — the number of test cases. Then $t$ test cases follow.
Each test case contains one integer $n$ ($1 \leq n \leq 10^6$) — the number that Polycarp wants to represent as the sum of the numbers $2020$ and $2021$.
-----Output-----
For each test case, output on a separate line:
"YES" if the number $n$ is representable as the sum of a certain number of $2020$ and a certain number of $2021$;
"NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
-----Examples-----
Input
5
1
4041
4042
8081
8079
Output
NO
YES
YES
YES
NO
-----Note-----
None
|
{"inputs": ["1\n7\n", "1\n9\n", "1\n8\n", "1\n2\n", "1\n3\n", "1\n6\n", "1\n4\n", "1\n1\n"], "outputs": ["NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n", "NO\n"]}
| 518
| 86
|
coding
|
Solve the programming task below in a Python markdown code block.
Let a_1, …, a_n be an array of n positive integers. In one operation, you can choose an index i such that a_i = i, and remove a_i from the array (after the removal, the remaining parts are concatenated).
The weight of a is defined as the maximum number of elements you can remove.
You must answer q independent queries (x, y): after replacing the x first elements of a and the y last elements of a by n+1 (making them impossible to remove), what would be the weight of a?
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 3 ⋅ 10^5) — the length of the array and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — elements of the array.
The i-th of the next q lines contains two integers x and y (x, y ≥ 0 and x+y < n).
Output
Print q lines, i-th line should contain a single integer — the answer to the i-th query.
Examples
Input
13 5
2 2 3 9 5 4 6 5 7 8 3 11 13
3 1
0 0
2 4
5 0
0 12
Output
5
11
6
1
0
Input
5 2
1 4 1 2 4
0 0
1 0
Output
2
0
Note
Explanation of the first query:
After making first x = 3 and last y = 1 elements impossible to remove, a becomes [×, ×, ×, 9, 5, 4, 6, 5, 7, 8, 3, 11, ×] (we represent 14 as × for clarity).
Here is a strategy that removes 5 elements (the element removed is colored in red):
* [×, ×, ×, 9, \color{red}{5}, 4, 6, 5, 7, 8, 3, 11, ×]
* [×, ×, ×, 9, 4, 6, 5, 7, 8, 3, \color{red}{11}, ×]
* [×, ×, ×, 9, 4, \color{red}{6}, 5, 7, 8, 3, ×]
* [×, ×, ×, 9, 4, 5, 7, \color{red}{8}, 3, ×]
* [×, ×, ×, 9, 4, 5, \color{red}{7}, 3, ×]
* [×, ×, ×, 9, 4, 5, 3, ×] (final state)
It is impossible to remove more than 5 elements, hence the weight is 5.
|
{"inputs": ["1 1\n1\n0 0\n", "1 1\n0\n0 0\n", "2 1\n1 1\n0 0\n", "2 1\n1 0\n0 0\n", "2 1\n2 0\n0 0\n", "2 1\n0 0\n0 0\n", "2 1\n0 1\n0 0\n", "2 1\n2 1\n0 0\n"], "outputs": ["1\n", "0\n", "2\n", "1\n", "0\n", "0\n", "0\n", "0\n"]}
| 676
| 146
|
coding
|
Solve the programming task below in a Python markdown code block.
The [Chinese zodiac](https://en.wikipedia.org/wiki/Chinese_zodiac) is a repeating cycle of 12 years, with each year being represented by an animal and its reputed attributes. The lunar calendar is divided into cycles of 60 years each, and each year has a combination of an animal and an element. There are 12 animals and 5 elements; the animals change each year, and the elements change every 2 years. The current cycle was initiated in the year of 1984 which was the year of the Wood Rat.
Since the current calendar is Gregorian, I will only be using years from the epoch 1924.
*For simplicity I am counting the year as a whole year and not from January/February to the end of the year.*
##Task
Given a year, return the element and animal that year represents ("Element Animal").
For example I'm born in 1998 so I'm an "Earth Tiger".
```animals``` (or ```$animals``` in Ruby) is a preloaded array containing the animals in order:
```['Rat', 'Ox', 'Tiger', 'Rabbit', 'Dragon', 'Snake', 'Horse', 'Goat', 'Monkey', 'Rooster', 'Dog', 'Pig']```
```elements``` (or ```$elements``` in Ruby) is a preloaded array containing the elements in order:
```['Wood', 'Fire', 'Earth', 'Metal', 'Water']```
Tell me your zodiac sign and element in the comments. Happy coding :)
Also feel free to reuse/extend the following starter code:
```python
def chinese_zodiac(year):
```
|
{"functional": "_inputs = [[1965], [1938], [1998], [2016], [1924], [1968], [2162], [6479], [3050], [6673], [6594], [9911], [2323], [3448], [1972]]\n_outputs = [['Wood Snake'], ['Earth Tiger'], ['Earth Tiger'], ['Fire Monkey'], ['Wood Rat'], ['Earth Monkey'], ['Water Dog'], ['Earth Goat'], ['Metal Dog'], ['Water Rooster'], ['Wood Tiger'], ['Metal Goat'], ['Water Rabbit'], ['Earth Rat'], ['Water Rat']]\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(chinese_zodiac(*i), o[0])"}
| 365
| 301
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given an array A = [A_{1}, A_{2}, \ldots, A_{N}].
Is it possible to partition A into two non-empty [subsequences] S_{1} and S_{2} such that sum(S_{1}) \times sum(S_{2}) is odd?
Here, sum(S_{1}) denotes the sum of elements in S_{1}, and sum(S_{2}) is defined similarly.
Note: S_{1} and S_{2} must *partition* A, that is:
S_{1} and S_{2} must be non-empty
Every element of A must be in either S_{1} or S_{2}
S_{1} and S_{2} must be disjoint (in terms of which indices their subsequences represent)
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases.
- Each test case consists of 2 lines of input.
- The first line of each test case contains a single integer N, the size of the array.
- The next line contains N space-separated integers A_{1}, A_{2}, \ldots, A_{N}: the elements of the array.
------ Output Format ------
For each test case, print on a new line the answer: YES if the array can be partitioned into two subsequences satisfying the condition, and NO otherwise.
Each character of the output may be printed in either uppercase or lowercase, i.e, YES, yes, YEs, and yEs will all be treated as equivalent.
------ Constraints ------
$1 ≤ T ≤ 10^{5}$
$2 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 10^{9}$
- The sum of $N$ across all test cases won't exceed $10^{6}$.
----- Sample Input 1 ------
4
4
1 1 2 2
6
1 2 4 6 8 10
2
3 5
3
1 3 5
----- Sample Output 1 ------
YES
NO
YES
NO
----- explanation 1 ------
Test case $1$: We have $A = [\underline{1}, 1, \underline{2}, 2]$. Let $S_{1}$ be the underlined elements and $S_{2}$ be the other ones. $sum(S_{1}) \times sum(S_{2}) = 3\times 3 = 9$.
Test case $2$: It can be proved that no partition of $A$ into $S_{1}, S_{2}$ satisfies the condition.
Test case $4$: Choose $S_{1} = \{3\}, S_{2} = \{5\}$.
Test case $4$: It can be proved that no partition of $A$ into $S_{1}, S_{2}$ satisfies the condition.
|
{"inputs": ["4\n4\n1 1 2 2\n6\n1 2 4 6 8 10\n2\n3 5\n3\n1 3 5"], "outputs": ["YES\nNO\nYES\nNO"]}
| 635
| 57
|
coding
|
Solve the programming task below in a Python markdown code block.
JavaScript provides a built-in parseInt method.
It can be used like this:
- `parseInt("10")` returns `10`
- `parseInt("10 apples")` also returns `10`
We would like it to return `"NaN"` (as a string) for the second case because the input string is not a valid number.
You are asked to write a `myParseInt` method with the following rules:
- It should make the conversion if the given string only contains a single integer value (and possibly spaces - including tabs, line feeds... - at both ends)
- For all other strings (including the ones representing float values), it should return NaN
- It should assume that all numbers are not signed and written in base 10
Also feel free to reuse/extend the following starter code:
```python
def my_parse_int(string):
```
|
{"functional": "_inputs = [['9'], ['09'], ['009'], [' 9'], [' 9 '], ['\\t9\\n'], ['5 friends'], ['5friends'], ['I <3 u'], ['17.42'], ['0x10'], ['123~~'], ['1 1'], ['1 2 3'], ['1.0']]\n_outputs = [[9], [9], [9], [9], [9], [9], ['NaN'], ['NaN'], ['NaN'], ['NaN'], ['NaN'], ['NaN'], ['NaN'], ['NaN'], ['NaN']]\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(my_parse_int(*i), o[0])"}
| 191
| 275
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given a 2D grid of size m x n and an integer k. You need to shift the grid k times.
In one shift operation:
Element at grid[i][j] moves to grid[i][j + 1].
Element at grid[i][n - 1] moves to grid[i + 1][0].
Element at grid[m - 1][n - 1] moves to grid[0][0].
Return the 2D grid after applying shift operation k times.
Please complete the following python code precisely:
```python
class Solution:
def shiftGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
```
|
{"functional": "def check(candidate):\n assert candidate(grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1) == [[9,1,2],[3,4,5],[6,7,8]]\n assert candidate(grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4) == [[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]\n assert candidate(grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9) == [[1,2,3],[4,5,6],[7,8,9]]\n\n\ncheck(Solution().shiftGrid)"}
| 159
| 212
|
coding
|
Solve the programming task below in a Python markdown code block.
Chef bought a huge (effectively infinite) planar island and built $N$ restaurants (numbered $1$ through $N$) on it. For each valid $i$, the Cartesian coordinates of restaurant $i$ are $(X_i, Y_i)$.
Now, Chef wants to build $N-1$ straight narrow roads (line segments) on the island. The roads may have arbitrary lengths; restaurants do not have to lie on the roads. The slope of each road must be $1$ or $-1$, i.e. for any two points $(x_1, y_1)$ and $(x_2, y_2)$ on the same road, $|x_1-x_2| = |y_1-y_2|$ must hold.
Let's denote the minimum distance Chef has to walk from restaurant $i$ to reach a road by $D_i$. Then, let's denote $a = \mathrm{max}\,(D_1, D_2, \ldots, D_N)$; Chef wants this distance to be minimum possible.
Chef is a busy person, so he decided to give you the job of building the roads. You should find a way to build them that minimises $a$ and compute $a \cdot \sqrt{2}$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains two space-separated integers $X_i$ and $Y_i$.
-----Output-----
For each test case, print a single line containing one real number — the minimum distance $a$ multiplied by $\sqrt{2}$. Your answer will be considered correct if its absolute or relative error does not exceed $10^{-6}$.
-----Constraints-----
- $1 \le T \le 100$
- $2 \le N \le 10^4$
- $|X_i|, |Y_i| \le 10^9$ for each valid $i$
-----Subtasks-----
Subtask #1 (10 points):
- $1 \le T \le 10$
- $2 \le N \le 5$
- $|X_i|, |Y_i| \le 10$ for each valid $i$
- $a \cdot \sqrt{2}$ is an integer
Subtask #2 (90 points): original constraints
-----Example Input-----
2
3
0 0
0 1
0 -1
3
0 1
1 0
-1 0
-----Example Output-----
0.5
0
-----Explanation-----
Example case 1: We should build roads described by equations $y-x+0.5 = 0$ and $y-x-0.5 = 0$.
Example case 2: We should build roads described by equations $y-x-1 = 0$ and $y+x-1 = 0$.
|
{"inputs": ["2\n3\n0 0\n0 1\n0 -1\n3\n0 1\n1 0\n-1 0"], "outputs": ["0.5\n0"]}
| 678
| 45
|
coding
|
Solve the programming task below in a Python markdown code block.
While walking down the street Vanya saw a label "Hide&Seek". Because he is a programmer, he used & as a bitwise AND for these two words represented as a integers in base 64 and got new word. Now Vanya thinks of some string s and wants to know the number of pairs of words of length |s| (length of s), such that their bitwise AND is equal to s. As this number can be large, output it modulo 10^9 + 7.
To represent the string as a number in numeral system with base 64 Vanya uses the following rules: digits from '0' to '9' correspond to integers from 0 to 9; letters from 'A' to 'Z' correspond to integers from 10 to 35; letters from 'a' to 'z' correspond to integers from 36 to 61; letter '-' correspond to integer 62; letter '_' correspond to integer 63.
-----Input-----
The only line of the input contains a single word s (1 ≤ |s| ≤ 100 000), consisting of digits, lowercase and uppercase English letters, characters '-' and '_'.
-----Output-----
Print a single integer — the number of possible pairs of words, such that their bitwise AND is equal to string s modulo 10^9 + 7.
-----Examples-----
Input
z
Output
3
Input
V_V
Output
9
Input
Codeforces
Output
130653412
-----Note-----
For a detailed definition of bitwise AND we recommend to take a look in the corresponding article in Wikipedia.
In the first sample, there are 3 possible solutions: z&_ = 61&63 = 61 = z _&z = 63&61 = 61 = z z&z = 61&61 = 61 = z
|
{"inputs": ["z\n", "_\n", "6\n", "6\n", "_\n", "8\n", "y\n", "7\n"], "outputs": ["3\n", "1\n", "81\n", "81", "1", "243\n", "9\n", "27\n"]}
| 427
| 73
|
coding
|
Solve the programming task below in a Python markdown code block.
Write a function that takes as its parameters *one or more numbers which are the diameters of circles.*
The function should return the *total area of all the circles*, rounded to the nearest integer in a string that says "We have this much circle: xyz".
You don't know how many circles you will be given, but you can assume it will be at least one.
So:
```python
sum_circles(2) == "We have this much circle: 3"
sum_circles(2, 3, 4) == "We have this much circle: 23"
```
Translations and comments (and upvotes!) welcome!
Also feel free to reuse/extend the following starter code:
```python
def sum_circles(*args):
```
|
{"functional": "_inputs = [[48, 7, 8, 9, 10], [1], [1, 1, 1, 2, 3, 4, 5], [894, 5778, 4839, 476], [4.5456, 746.5, 98.34, 344.543], [1, 1, 1], [13.58, 14.9, 56.99, 107.321], [56894.04839, 843975.4839, 4.08437403489], [5, 6, 7, 8, 9, 10, 105083, 48839, 4853, 28, 483]]\n_outputs = [['We have this much circle: 2040'], ['We have this much circle: 1'], ['We have this much circle: 45'], ['We have this much circle: 45417233'], ['We have this much circle: 538519'], ['We have this much circle: 2'], ['We have this much circle: 11916'], ['We have this much circle: 561977165367'], ['We have this much circle: 10564760498']]\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(sum_circles(*i), o[0])"}
| 173
| 502
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an array of CPU tasks, each labeled with a letter from A to Z, and a number n. Each CPU interval can be idle or allow the completion of one task. Tasks can be completed in any order, but there's a constraint: there has to be a gap of at least n intervals between two tasks with the same label.
Return the minimum number of CPU intervals required to complete all tasks.
Please complete the following python code precisely:
```python
class Solution:
def leastInterval(self, tasks: List[str], n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(tasks = [\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n = 2) == 8\n assert candidate(tasks = [\"A\",\"A\",\"A\",\"B\",\"B\",\"B\"], n = 0) == 6\n assert candidate(tasks = [\"A\",\"A\",\"A\",\"A\",\"A\",\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\"], n = 2) == 16\n\n\ncheck(Solution().leastInterval)"}
| 136
| 119
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an integer n, return the nth digit of the infinite integer sequence [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...].
Please complete the following python code precisely:
```python
class Solution:
def findNthDigit(self, n: int) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 3) == 3\n assert candidate(n = 11) == 0\n\n\ncheck(Solution().findNthDigit)"}
| 100
| 46
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Chef and his little brother are playing with sticks. They have total N sticks. Length of i-th stick is A_{i}.
Chef asks his brother to choose any four sticks and to make a rectangle with those sticks its sides. Chef warns his brother to not to break any of the sticks, he has to use sticks as a whole. Also, he wants that the rectangle formed should have the maximum possible area among all the rectangles that Chef's brother can make.
Chef's little brother takes this challenge up and overcomes it. Can you also do so? That is, you have to tell whether it is even possible to create a rectangle? If yes, then you have to tell the maximum possible area of rectangle.
------ Input ------
The first line contains a single integer T denoting the number of test-cases. T test cases follow.
The first line of each test case contains a single integer N denoting the number of sticks.
The second line of each test case contains N space-separated integers A_{1}, A_{2}, ..., A_{N} denoting the lengths of sticks.
------ Output ------
For each test case, output a single line containing an integer representing the maximum possible area for rectangle or -1 if it's impossible to form any rectangle using the available sticks.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ N ≤ 10^{3}$
$1 ≤ sum of N's over all test-cases in a single test file ≤ 10^{3}$
$1 ≤ A_{i} ≤ 10^{3}$
----- Sample Input 1 ------
2
5
1 2 3 1 2
4
1 2 2 3
----- Sample Output 1 ------
2
-1
----- explanation 1 ------
Example case 1. Chef's brother can choose sticks of lengths 1, 2, 1, 2. He can create a rectangle with area 1 * 2 = 2.
Example case 2. It's impossible to choose 4 sticks so that they form a rectangle.
|
{"inputs": ["2\n5\n1 2 3 1 2\n4\n1 2 2 3", "2\n5\n1 2 3 1 1\n4\n1 2 2 3", "2\n5\n1 2 3 1 2\n4\n1 3 2 3", "2\n5\n1 2 3 1 1\n4\n2 2 4 4", "2\n5\n1 3 3 1 1\n4\n0 2 0 3", "2\n5\n1 2 3 1 2\n4\n1 3 1 3", "2\n5\n2 2 3 1 2\n4\n1 3 1 3", "2\n5\n2 2 3 2 2\n1\n2 5 4 3"], "outputs": ["2\n-1", "-1\n-1\n", "2\n-1\n", "-1\n8\n", "3\n-1\n", "2\n3\n", "-1\n3\n", "4\n-1\n"]}
| 466
| 258
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given a string S of length 2N consisting of lowercase English letters.
There are 2^{2N} ways to color each character in S red or blue. Among these ways, how many satisfy the following condition?
* The string obtained by reading the characters painted red from left to right is equal to the string obtained by reading the characters painted blue from right to left.
Constraints
* 1 \leq N \leq 18
* The length of S is 2N.
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of ways to paint the string that satisfy the condition.
Examples
Input
4
cabaacba
Output
4
Input
11
mippiisssisssiipsspiim
Output
504
Input
4
abcdefgh
Output
0
Input
18
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Output
9075135300
|
{"inputs": ["4\ncacaabba", "4\nacbaacab", "4\nhgfedcba", "4\nabbaacac", "4\nhgfbdcea", "4\nacbaacac", "4\nhgfbccea", "4\ncacaabca"], "outputs": ["0\n", "4\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 228
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problem statements in [Hindi], [Bengali], [Mandarin Chinese], [Russian], and [Vietnamese] as well.
There are $N$ cars (numbered $1$ through $N$) on a circular track with length $N$. For each $i$ ($2 ≤ i ≤ N$), the $i$-th of them is at a distance $i-1$ clockwise from car $1$, i.e. car $1$ needs to travel a distance $i-1$ clockwise to reach car $i$.
For each valid $i$, you can fill the $i$-th car's tank with up to $f_{i}$ litres of gasoline, with cost $c_{i}$ coins per litre.
After that, you choose some car, sit in this car and start driving in the clockwise direction. To move one unit of distance in this direction, you need to spend $1$ litre of gasoline. When you pass another car (even if you'd run out of gasoline exactly at that point), you steal all its gasoline. You cannot move if you do not have any gasoline left.
Your goal is to fill the cars in such a way that you are able to choose an optimal car, travel the clockwise distance $N$ and return to the place where you were initially. Under this constraint, you want to pay the least possible number of coins.
Find the smallest number of coins you need to pay. It is guaranteed that there is a way to travel the distance $N$. It can be proved that in such a case, the smallest number of coins is always an integer.
------ Input ------
The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
The first line of each test case contains a single integer $N$.
The second line contains $N$ space-separated integers $f_{1}, f_{2}, \ldots, f_{N}$.
The third line contains $N$ space-separated integers $c_{1}, c_{2}, \ldots, c_{N}$.
------ Output ------
For each test case, print a single line containing one integer ― the smallest possible number of coins you need to pay.
------ Constraints ------
$1 ≤ T ≤ 10$
$1 ≤ N ≤ 200,000$
$0 ≤ f_{i} ≤ 10^{9}$ for each valid $i$
$0 ≤ c_{i} ≤ 10^{9}$ for each valid $i$
------ Subtasks ------
Subtask #1 (10 points): $N ≤ 2,000$
Subtask #2 (90 points): original constraints
----- Sample Input 1 ------
3
3
1 1 1
1 1 1
3
3 0 0
10 0 0
3
3 3 3
3 2 1
----- Sample Output 1 ------
3
30
3
|
{"inputs": ["3\n3\n1 1 1\n1 1 1\n3\n3 0 0\n10 0 0\n3\n3 3 3\n3 2 1"], "outputs": ["3\n30\n3"]}
| 654
| 60
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There are some stones in different positions on the X-axis. You are given an integer array stones, the positions of the stones.
Call a stone an endpoint stone if it has the smallest or largest position. In one move, you pick up an endpoint stone and move it to an unoccupied position so that it is no longer an endpoint stone.
In particular, if the stones are at say, stones = [1,2,5], you cannot move the endpoint stone at position 5, since moving it to any position (such as 0, or 3) will still keep that stone as an endpoint stone.
The game ends when you cannot make any more moves (i.e., the stones are in three consecutive positions).
Return an integer array answer of length 2 where:
answer[0] is the minimum number of moves you can play, and
answer[1] is the maximum number of moves you can play.
Please complete the following python code precisely:
```python
class Solution:
def numMovesStonesII(self, stones: List[int]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate([7,4,9]) == [1,2]\n assert candidate([6,5,4,3,10]) == [2,3]\n assert candidate([100,101,104,102,103]) == [0,0]\n\n\ncheck(Solution().numMovesStonesII)"}
| 240
| 92
|
coding
|
Solve the programming task below in a Python markdown code block.
Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut n trees with heights a_1, a_2, ..., a_{n}. They bought a chain saw from a shop. Each time they use the chain saw on the tree number i, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is i (the tree that have height a_{i} in the beginning), then the cost of charging the chain saw would be b_{i}. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each i < j, a_{i} < a_{j} and b_{i} > b_{j} and also b_{n} = 0 and a_1 = 1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
-----Input-----
The first line of input contains an integer n (1 ≤ n ≤ 10^5). The second line of input contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9). The third line of input contains n integers b_1, b_2, ..., b_{n} (0 ≤ b_{i} ≤ 10^9).
It's guaranteed that a_1 = 1, b_{n} = 0, a_1 < a_2 < ... < a_{n} and b_1 > b_2 > ... > b_{n}.
-----Output-----
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Examples-----
Input
5
1 2 3 4 5
5 4 3 2 0
Output
25
Input
6
1 2 3 10 20 30
6 5 4 3 2 0
Output
138
|
{"inputs": ["5\n1 2 3 4 5\n5 4 3 2 0\n", "5\n1 4 3 4 5\n5 4 3 2 0\n", "5\n1 2 3 4 5\n9 4 3 2 0\n", "5\n1 2 3 4 5\n6 4 3 2 0\n", "5\n1 2 3 4 5\n7 4 3 2 0\n", "5\n0 2 5 4 5\n8 4 3 2 0\n", "5\n1 2 5 4 5\n5 4 3 2 0\n", "5\n0 2 5 4 5\n5 4 3 2 0\n"], "outputs": ["25\n", "25\n", "38\n", "30\n", "34\n", "36\n", "25\n", "25\n"]}
| 569
| 238
|
coding
|
Solve the programming task below in a Python markdown code block.
Dreamoon has a string s and a pattern string p. He first removes exactly x characters from s obtaining string s' as a result. Then he calculates $\operatorname{occ}(s^{\prime}, p)$ that is defined as the maximal number of non-overlapping substrings equal to p that can be found in s'. He wants to make this number as big as possible.
More formally, let's define $\operatorname{ans}(x)$ as maximum value of $\operatorname{occ}(s^{\prime}, p)$ over all s' that can be obtained by removing exactly x characters from s. Dreamoon wants to know $\operatorname{ans}(x)$ for all x from 0 to |s| where |s| denotes the length of string s.
-----Input-----
The first line of the input contains the string s (1 ≤ |s| ≤ 2 000).
The second line of the input contains the string p (1 ≤ |p| ≤ 500).
Both strings will only consist of lower case English letters.
-----Output-----
Print |s| + 1 space-separated integers in a single line representing the $\operatorname{ans}(x)$ for all x from 0 to |s|.
-----Examples-----
Input
aaaaa
aa
Output
2 2 1 1 0 0
Input
axbaxxb
ab
Output
0 1 1 2 1 1 0 0
-----Note-----
For the first sample, the corresponding optimal values of s' after removal 0 through |s| = 5 characters from s are {"aaaaa", "aaaa", "aaa", "aa", "a", ""}.
For the second sample, possible corresponding optimal values of s' are {"axbaxxb", "abaxxb", "axbab", "abab", "aba", "ab", "a", ""}.
|
{"inputs": ["a\na\n", "a\nb\n", "a\na\n", "a\nb\n", "a\naa\n", "a\nab\n", "a\nab\n", "a\naa\n"], "outputs": ["1 0\n", "0 0\n", "1 0 \n", "0 0 \n", "0 0\n", "0 0\n", "0 0 \n", "0 0 \n"]}
| 413
| 106
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an m x n matrix board where each cell is a battleship 'X' or empty '.', return the number of the battleships on board.
Battleships can only be placed horizontally or vertically on board. In other words, they can only be made of the shape 1 x k (1 row, k columns) or k x 1 (k rows, 1 column), where k can be of any size. At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).
Please complete the following python code precisely:
```python
class Solution:
def countBattleships(self, board: List[List[str]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(board = [[\"X\",\".\",\".\",\"X\"],[\".\",\".\",\".\",\"X\"],[\".\",\".\",\".\",\"X\"]]) == 2\n assert candidate(board = [[\".\"]]) == 0\n\n\ncheck(Solution().countBattleships)"}
| 161
| 83
|
coding
|
Solve the programming task below in a Python markdown code block.
Everybody seems to think that the Martians are green, but it turns out they are metallic pink and fat. Ajs has two bags of distinct nonnegative integers. The bags are disjoint, and the union of the sets of numbers in the bags is \{0,1,…,M-1\}, for some positive integer M. Ajs draws a number from the first bag and a number from the second bag, and then sums them modulo M.
What are the residues modulo M that Ajs cannot obtain with this action?
Input
The first line contains two positive integer N (1 ≤ N ≤ 200 000) and M (N+1 ≤ M ≤ 10^{9}), denoting the number of the elements in the first bag and the modulus, respectively.
The second line contains N nonnegative integers a_1,a_2,…,a_N (0 ≤ a_1<a_2< …< a_N<M), the contents of the first bag.
Output
In the first line, output the cardinality K of the set of residues modulo M which Ajs cannot obtain.
In the second line of the output, print K space-separated integers greater or equal than zero and less than M, which represent the residues Ajs cannot obtain. The outputs should be sorted in increasing order of magnitude. If K=0, do not output the second line.
Examples
Input
2 5
3 4
Output
1
2
Input
4 1000000000
5 25 125 625
Output
0
Input
2 4
1 3
Output
2
0 2
Note
In the first sample, the first bag and the second bag contain \{3,4\} and \{0,1,2\}, respectively. Ajs can obtain every residue modulo 5 except the residue 2: 4+1 ≡ 0, 4+2 ≡ 1, 3+0 ≡ 3, 3+1 ≡ 4 modulo 5. One can check that there is no choice of elements from the first and the second bag which sum to 2 modulo 5.
In the second sample, the contents of the first bag are \{5,25,125,625\}, while the second bag contains all other nonnegative integers with at most 9 decimal digits. Every residue modulo 1 000 000 000 can be obtained as a sum of an element in the first bag and an element in the second bag.
|
{"inputs": ["1 2\n1\n", "1 2\n0\n", "2 5\n3 4\n", "2 4\n1 3\n", "4 20\n5 6 7 16\n", "4 20\n5 2 7 16\n", "9 10\n1 2 3 4 5 6 7 8 9\n", "4 1000000000\n5 25 125 625\n"], "outputs": ["1\n0\n", "1\n0\n", "1\n2\n", "2\n0 2\n", "1\n12 \n", "0\n", "1\n0\n", "0\n\n"]}
| 568
| 176
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.
You can either start from the step with index 0, or the step with index 1.
Return the minimum cost to reach the top of the floor.
Please complete the following python code precisely:
```python
class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(cost = [10,15,20]) == 15\n assert candidate(cost = [1,100,1,1,1,100,1,1,100,1]) == 6\n\n\ncheck(Solution().minCostClimbingStairs)"}
| 121
| 80
|
coding
|
Solve the programming task below in a Python markdown code block.
# Task
You are given a regular array `arr`. Let's call a `step` the difference between two adjacent elements.
Your task is to sum the elements which belong to the sequence of consecutive elements of length `at least 3 (but as long as possible)`, such that the steps between the elements in this sequence are the same.
Note that some elements belong to two sequences and have to be counted twice.
# Example
For `arr = [54, 70, 86, 1, -2, -5, 0, 5, 78, 145, 212, 15]`, the output should be `639`.
```
There are 4 sequences of equal steps in the given array:
{54, 70, 86} => step +16
{1, -2, -5} => step -3
{-5, 0, 5} => step +5
{78, 145, 212} => step +67
So the answer is
(54 + 70 + 86) +
(1 - 2 - 5) +
(-5 + 0 + 5) +
(78 + 145 + 212) = 639.
The last element 15 was not be counted.
```
For `arr = [7, 2, 3, 2, -2, 400, 802]`, the output should be `1200`.
```
There is only 1 sequence in arr:
{-2, 400, 802} => step +402
So the answer is: -2 + 400 + 802 = 1200
```
For `arr = [1, 2, 3, 4, 5]`, the output should be `15`.
Note that we should only count {1, 2, 3, 4, 5} as a whole, any other small subset such as {1, 2, 3},{2, 3, 4},{3, 4, 5} are belong to {1, 2, 3, 4, 5}.
# Input/Output
- `[input]` array.integer `arr`
`3 ≤ arr.length ≤ 100`
- `[output]` an integer
The sum of sequences.
Also feel free to reuse/extend the following starter code:
```python
def sum_of_regular_numbers(arr):
```
|
{"functional": "_inputs = [[[54, 70, 86, 1, -2, -5, 0, 5, 78, 145, 212, 15]], [[59, 58, 57, 55, 53, 51]], [[7, 2, -3, 3, 9, 15]], [[-17, -9, 1, 9, 17, 4, -9]], [[7, 2, 3, 2, -2, 400, 802]], [[-1, 7000, 1, -6998, -13997]]]\n_outputs = [[639], [390], [30], [39], [1200], [-13994]]\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(sum_of_regular_numbers(*i), o[0])"}
| 579
| 344
|
coding
|
Solve the programming task below in a Python markdown code block.
The only difference between easy and hard versions is the maximum value of $n$.
You are given a positive integer number $n$. You really love good numbers so you want to find the smallest good number greater than or equal to $n$.
The positive integer is called good if it can be represented as a sum of distinct powers of $3$ (i.e. no duplicates of powers of $3$ are allowed).
For example: $30$ is a good number: $30 = 3^3 + 3^1$, $1$ is a good number: $1 = 3^0$, $12$ is a good number: $12 = 3^2 + 3^1$, but $2$ is not a good number: you can't represent it as a sum of distinct powers of $3$ ($2 = 3^0 + 3^0$), $19$ is not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representations $19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0$ are invalid), $20$ is also not a good number: you can't represent it as a sum of distinct powers of $3$ (for example, the representation $20 = 3^2 + 3^2 + 3^0 + 3^0$ is invalid).
Note, that there exist other representations of $19$ and $20$ as sums of powers of $3$ but none of them consists of distinct powers of $3$.
For the given positive integer $n$ find such smallest $m$ ($n \le m$) that $m$ is a good number.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 500$) — the number of queries. Then $q$ queries follow.
The only line of the query contains one integer $n$ ($1 \le n \le 10^4$).
-----Output-----
For each query, print such smallest integer $m$ (where $n \le m$) that $m$ is a good number.
-----Example-----
Input
7
1
2
6
13
14
3620
10000
Output
1
3
9
13
27
6561
19683
|
{"inputs": ["1\n387420490\n", "1\n506859788\n", "1\n132370398\n", "1\n230139648\n", "1\n152260256\n", "1\n586187597\n", "1\n100214312\n", "1\n218113389\n"], "outputs": ["387420490\n", "516560652\n", "133923132\n", "387420489\n", "172186884\n", "1162261467\n", "129140163\n", "387420489\n"]}
| 578
| 215
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
There is an undirected connected tree with n nodes labeled from 0 to n - 1 and n - 1 edges.
You are given the integer n and the array edges where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree.
Return an array answer of length n where answer[i] is the sum of the distances between the ith node in the tree and all other nodes.
Please complete the following python code precisely:
```python
class Solution:
def sumOfDistancesInTree(self, n: int, edges: List[List[int]]) -> List[int]:
```
|
{"functional": "def check(candidate):\n assert candidate(n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]) == [8,12,6,10,10,10]\n assert candidate(n = 1, edges = []) == [0]\n assert candidate(n = 2, edges = [[1,0]]) == [1,1]\n\n\ncheck(Solution().sumOfDistancesInTree)"}
| 148
| 111
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given n points on a plane. All the points are distinct and no three of them lie on the same line. Find the number of parallelograms with the vertices at the given points.
-----Input-----
The first line of the input contains integer n (1 ≤ n ≤ 2000) — the number of points.
Each of the next n lines contains two integers (x_{i}, y_{i}) (0 ≤ x_{i}, y_{i} ≤ 10^9) — the coordinates of the i-th point.
-----Output-----
Print the only integer c — the number of parallelograms with the vertices at the given points.
-----Example-----
Input
4
0 1
1 0
1 1
2 0
Output
1
|
{"inputs": ["1\n0 0\n", "1\n6 6\n", "1\n0 0\n", "1\n6 6\n", "1\n9 6\n", "1\n-1 0\n", "1\n18 6\n", "1\n0 -1\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n"]}
| 176
| 104
|
coding
|
Solve the programming task below in a Python markdown code block.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
|
{"inputs": ["3 1\n1 1", "5 1\n1 1", "6 1\n1 1", "3 1\n3 2", "5 1\n3 2", "2 1\n1 2", "9 1\n1 2", "8 1\n2 4"], "outputs": ["2\n", "4\n", "5\n", "1\n", "3\n", "0\n", "7\n", "6\n"]}
| 249
| 110
|
coding
|
Solve the programming task below in a Python markdown code block.
# Description
"It's the end of trick-or-treating and we have a list/array representing how much candy each child in our group has made out with. We don't want the kids to start arguing, and using our parental intuition we know trouble is brewing as many of the children in the group have received different amounts of candy from each home.
So we want each child to have the same amount of candies, only we can't exactly take any candy away from the kids, that would be even worse. Instead we decide to give each child extra candy until they all have the same amount.
# Task
Your job is to find out how much candy each child has, and give them each additional candy until they too have as much as the child(ren) with the most candy. You also want to keep a total of how much candy you've handed out because reasons."
Your job is to give all the kids the same amount of candies as the kid with the most candies and then return the total number candies that have been given out. If there are no kids, or only one, return -1.
In the first case (look below) the most candies are given to second kid (i.e second place in list/array), 8. Because of that we will give the first kid 3 so he can have 8 and the third kid 2 and the fourth kid 4, so all kids will have 8 candies.So we end up handing out 3 + 2 + 4 = 9.
```python
candies ([5,8,6,4]) # return 9
candies ([1,2,4,6]) # return 11
candies ([1,6]) # return 5
candies ([]) # return -1
candies ([6]) # return -1 (because only one kid)
```
```cs
CandyProblem.GetMissingCandies(new [] {5, 6, 8, 4}) // return 9
CandyProblem.GetMissingCandies(new [] {1, 2, 4, 6}) // return 11
CandyProblem.GetMissingCandies(new [] { }) // return -1
CandyProblem.GetMissingCandies(new [] {1, 6}) // return 5
```
```haskell
candies [5,8,6,4] -- return 9
candies [1,2,4,6] -- return 11
candies [] -- return -1
candies [1,6] -- return 5
```
Also feel free to reuse/extend the following starter code:
```python
def candies(s):
```
|
{"functional": "_inputs = [[[5, 8, 6, 4]], [[1, 2, 4, 6]], [[1, 2]], [[4, 2]], [[1, 3, 3, 7]], [[7, 7, 7, 7]], [[17, 20, 50, 61, 42, 44]], [[0]], [[]], [[4]], [[None]]]\n_outputs = [[9], [11], [1], [2], [14], [0], [132], [-1], [-1], [-1], [-1]]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(candies(*i), o[0])"}
| 582
| 281
|
coding
|
Solve the programming task below in a Python markdown code block.
Vasiliy spent his vacation in a sanatorium, came back and found that he completely forgot details of his vacation!
Every day there was a breakfast, a dinner and a supper in a dining room of the sanatorium (of course, in this order). The only thing that Vasiliy has now is a card from the dining room contaning notes how many times he had a breakfast, a dinner and a supper (thus, the card contains three integers). Vasiliy could sometimes have missed some meal, for example, he could have had a breakfast and a supper, but a dinner, or, probably, at some days he haven't been at the dining room at all.
Vasiliy doesn't remember what was the time of the day when he arrived to sanatorium (before breakfast, before dinner, before supper or after supper), and the time when he left it (before breakfast, before dinner, before supper or after supper). So he considers any of these options. After Vasiliy arrived to the sanatorium, he was there all the time until he left. Please note, that it's possible that Vasiliy left the sanatorium on the same day he arrived.
According to the notes in the card, help Vasiliy determine the minimum number of meals in the dining room that he could have missed. We shouldn't count as missed meals on the arrival day before Vasiliy's arrival and meals on the departure day after he left.
-----Input-----
The only line contains three integers b, d and s (0 ≤ b, d, s ≤ 10^18, b + d + s ≥ 1) — the number of breakfasts, dinners and suppers which Vasiliy had during his vacation in the sanatorium.
-----Output-----
Print single integer — the minimum possible number of meals which Vasiliy could have missed during his vacation.
-----Examples-----
Input
3 2 1
Output
1
Input
1 0 0
Output
0
Input
1 1 1
Output
0
Input
1000000000000000000 0 1000000000000000000
Output
999999999999999999
-----Note-----
In the first sample, Vasiliy could have missed one supper, for example, in case he have arrived before breakfast, have been in the sanatorium for two days (including the day of arrival) and then have left after breakfast on the third day.
In the second sample, Vasiliy could have arrived before breakfast, have had it, and immediately have left the sanatorium, not missing any meal.
In the third sample, Vasiliy could have been in the sanatorium for one day, not missing any meal.
|
{"inputs": ["3 2 1\n", "1 0 0\n", "1 1 1\n", "0 1 0\n", "0 0 1\n", "1 1 0\n", "0 1 1\n", "4 3 5\n"], "outputs": ["1\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "1\n"]}
| 618
| 102
|
coding
|
Solve the programming task below in a Python markdown code block.
It is the final day of La Liga. Chef has a certain criteria for assessing football matches.
In particular, he only likes a match if:
The match ends in a draw, and,
At least one goal has been scored by either team.
Given the goals scored by both the teams as X and Y respectively, determine whether Chef will like the match or not.
------ Input Format ------
- The first line of input will contain a single integer T, denoting the number of test cases. The description of T test cases follows.
- Each test case consists of a single line of input containing two space-separated integers X and Y — the goals scored by each team.
------ Output Format ------
For each test case, output \texttt{YES} if Chef will like the match, else output \texttt{NO}.
You may print each character of the string in uppercase or lowercase (for example, the strings \texttt{YeS}, \texttt{yEs}, \texttt{yes} and \texttt{YES} will all be treated as identical).
------ Constraints ------
$1 ≤ T ≤ 100$
$0 ≤ X, Y ≤ 9$
----- Sample Input 1 ------
4
1 1
0 1
0 0
2 2
----- Sample Output 1 ------
YES
NO
NO
YES
----- explanation 1 ------
Test case $1$: It is a draw in which both teams have scored a goal, Chef will like this match.
Test case $2$: The game is not a draw. Hence, Chef will not like this match.
Test case $3$: Neither team scored a goal, so Chef will not like this match.
Test case $4$: It is a draw in which both teams scored $2$ goals each. Chef will like this match.
|
{"inputs": ["4\n1 1\n0 1\n0 0\n2 2\n"], "outputs": ["YES\nNO\nNO\nYES"]}
| 395
| 35
|
coding
|
Solve the programming task below in a Python markdown code block.
Square1001 has seen an electric bulletin board displaying the integer 1.
He can perform the following operations A and B to change this value:
- Operation A: The displayed value is doubled.
- Operation B: The displayed value increases by K.
Square1001 needs to perform these operations N times in total.
Find the minimum possible value displayed in the board after N operations.
-----Constraints-----
- 1 \leq N, K \leq 10
- All input values are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
K
-----Output-----
Print the minimum possible value displayed in the board after N operations.
-----Sample Input-----
4
3
-----Sample Output-----
10
The value will be minimized when the operations are performed in the following order: A, A, B, B.
In this case, the value will change as follows: 1 → 2 → 4 → 7 → 10.
|
{"inputs": ["4\n4", "4\n7", "4\n2", "4\n0", "4\n1", "4\n6", "4\n5", "4\n3"], "outputs": ["12\n", "15\n", "8\n", "1\n", "5\n", "14\n", "13\n", "10"]}
| 218
| 82
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
Given an m x n integer matrix heightMap representing the height of each unit cell in a 2D elevation map, return the volume of water it can trap after raining.
Please complete the following python code precisely:
```python
class Solution:
def trapRainWater(self, heightMap: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]) == 4\n assert candidate(heightMap = [[3,3,3,3,3],[3,2,2,2,3],[3,2,1,2,3],[3,2,2,2,3],[3,3,3,3,3]]) == 10\n\n\ncheck(Solution().trapRainWater)"}
| 86
| 129
|
coding
|
Solve the programming task below in a Python markdown code block.
Given a string (`str`) containing a base-10 integer between `0` and `10000`, convert the integer to its binary representation. At that point, obtain a count of the maximum amount of consecutive 0s. From there, return the count in written form with a capital letter.
In the very first example, we have an argument of `"9"` which is being passed to the method. The binary representation of `9` is `1001` which can be read as: one, zero, zero, one. There are, at most, two consecutive 0s, resulting in the integer `2` as the value of the count. The output in the block of code above reflects the final step of taking `2` from standard form to the written form `"Two"` as prompted.
In the very last example, we have an argument of `"550"` which is being passed to the method. The binary representation of `550` is `1000100110` which can be read as: one, zero, zero, zero, one, zero, zero, one, one, zero. There are, at most, three consecutive 0s, resulting in the integer `3` as the value of the count. The output in the block of code above reflects the final step of taking `3` from standard form to the written form of `"Three"` as prompted.
One way, among many, to visualize the end of each step might look like:
```
max_consec_zeros("777")
1: "777"
2: 777
3: 1100001001
4: 4
5: "Four"
max_consec_zeros("777") => "Four"
```
Happy coding!
Also feel free to reuse/extend the following starter code:
```python
def max_consec_zeros(n):
```
|
{"functional": "_inputs = [['7'], ['33'], ['77'], ['100'], ['105'], ['113'], ['160'], ['180'], ['223'], ['256'], ['777'], ['992'], ['1024'], ['1037'], ['1088'], ['2017'], ['2048'], ['3050'], ['4096'], ['6144'], ['6656'], ['7188'], ['8192'], ['9999'], ['10000']]\n_outputs = [['Zero'], ['Four'], ['Two'], ['Two'], ['Two'], ['Three'], ['Five'], ['Two'], ['One'], ['Eight'], ['Four'], ['Five'], ['Ten'], ['Six'], ['Six'], ['Four'], ['Eleven'], ['One'], ['Twelve'], ['Eleven'], ['Nine'], ['Five'], ['Thirteen'], ['Four'], ['Four']]\nimport math\ndef _deep_eq(a, b, tol=1e-5):\n if isinstance(a, float) or isinstance(b, float):\n return math.isclose(a, b, rel_tol=tol, abs_tol=tol)\n if isinstance(a, (list, tuple)):\n if len(a) != len(b): return False\n return all(_deep_eq(x, y, tol) for x, y in zip(a, b))\n return a == b\n\nfor i, o in zip(_inputs, _outputs):\n assert _deep_eq(max_consec_zeros(*i), o[0])"}
| 419
| 364
|
coding
|
Solve the programming task below in a Python markdown code block.
I have started studying electronics recently, and I came up with a circuit made up of 2 LEDs and 3 buttons.
Here 's how it works: 2 buttons (`red` and `blue`) are connected to the LEDs (`red` and `blue` respectively). Buttons pressing pattern will be remembered and represented through the LEDs when the third button is pressed.
- Only one LED can blink at a time.
- The LED will only blink once even if the button is held down.
- The button must be released to be pressed again.
- If a button is pressed while the other button is being held down, it will be ignored.
- If two buttons are pressed simultaneously, the red button will be preferred.
- If a button is released while the other is being held down, the other 's LED will blink.
- `0` is up and `1` is down.
- The two inputs will always have the same length.
Here is an example:
```Python
Red: "10011010"
Blue: "10110111"
#=> "RBRB"
Red: "01001000"
Blue: "01011100"
#=> "RB"
Red: "01101000"
Blue: "00111000"
#=> "RB"
```
PS:
This is my first time making a kata, so there may be some errors.
You may report to me if the description is too confusing.
Sorry for my poor grammar.
Also feel free to reuse/extend the following starter code:
```python
def button_sequences(seqR, seqB):
```
|
{"functional": "_inputs = [['10011010', '10110111'], ['01001000', '01011100'], ['00010100', '01011100'], ['10101010', '01010101'], ['11011011', '11111011']]\n_outputs = [['RBRB'], ['RB'], ['BRB'], ['RBRBRBRB'], ['RBR']]\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(button_sequences(*i), o[0])"}
| 370
| 271
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given two arrays of integers $a_1, a_2, \ldots, a_n$ and $b_1, b_2, \ldots, b_n$.
Let's define a transformation of the array $a$:
Choose any non-negative integer $k$ such that $0 \le k \le n$.
Choose $k$ distinct array indices $1 \le i_1 < i_2 < \ldots < i_k \le n$.
Add $1$ to each of $a_{i_1}, a_{i_2}, \ldots, a_{i_k}$, all other elements of array $a$ remain unchanged.
Permute the elements of array $a$ in any order.
Is it possible to perform some transformation of the array $a$ exactly once, so that the resulting array is equal to $b$?
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of test cases. Descriptions of test cases follow.
The first line of each test case contains a single integer $n$ ($1 \le n \le 100$) — the size of arrays $a$ and $b$.
The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($-100 \le a_i \le 100$).
The third line of each test case contains $n$ integers $b_1, b_2, \ldots, b_n$ ($-100 \le b_i \le 100$).
-----Output-----
For each test case, print "YES" (without quotes) if it is possible to perform a transformation of the array $a$, so that the resulting array is equal to $b$. Print "NO" (without quotes) otherwise.
You can print each letter in any case (upper or lower).
-----Examples-----
Input
3
3
-1 1 0
0 0 2
1
0
2
5
1 2 3 4 5
1 2 3 4 5
Output
YES
NO
YES
-----Note-----
In the first test case, we can make the following transformation:
Choose $k = 2$.
Choose $i_1 = 1$, $i_2 = 2$.
Add $1$ to $a_1$ and $a_2$. The resulting array is $[0, 2, 0]$.
Swap the elements on the second and third positions.
In the second test case there is no suitable transformation.
In the third test case we choose $k = 0$ and do not change the order of elements.
|
{"inputs": ["1\n1\n2\n1\n", "1\n1\n3\n2\n", "1\n1\n1\n2\n", "1\n1\n3\n1\n", "1\n1\n5\n4\n", "1\n1\n4\n3\n", "1\n1\n1\n0\n", "1\n1\n2\n3\n"], "outputs": ["NO\n", "NO\n", "YES\n", "NO\n", "NO\n", "NO\n", "NO\n", "YES\n"]}
| 606
| 118
|
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 representing a field of cherries, each cell is one of three possible integers.
0 means the cell is empty, so you can pass through,
1 means the cell contains a cherry that you can pick up and pass through, or
-1 means the cell contains a thorn that blocks your way.
Return the maximum number of cherries you can collect by following the rules below:
Starting at the position (0, 0) and reaching (n - 1, n - 1) by moving right or down through valid path cells (cells with value 0 or 1).
After reaching (n - 1, n - 1), returning to (0, 0) by moving left or up through valid path cells.
When passing through a path cell containing a cherry, you pick it up, and the cell becomes an empty cell 0.
If there is no valid path between (0, 0) and (n - 1, n - 1), then no cherries can be collected.
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 = [[0,1,-1],[1,0,-1],[1,1,1]]) == 5\n assert candidate(grid = [[1,1,-1],[1,-1,1],[-1,1,1]]) == 0\n\n\ncheck(Solution().cherryPickup)"}
| 266
| 77
|
coding
|
Solve the programming task below in a Python markdown code block.
A palindrome is a string that reads the same backward as forward. For example, the strings ${z}$, ${aaa}$, ${aba}$, and ${abccba}$ are palindromes, but ${codeforces}$ and ${ab}$ are not.
The double of a string $s$ is obtained by writing each character twice. For example, the double of ${seeing}$ is ${sseeeeiinngg}$.
Given a string $s$, rearrange its double to form a palindrome. Output the rearranged string. It can be proven that such a rearrangement always exists.
-----Input-----
The first line of input contains $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The only line of each test case contains a single string $s$ ($1 \leq |s| \leq 100$) consisting only of lowercase English letters.
Note that the sum of $|s|$ over all test cases is not bounded.
-----Output-----
For each test case, output a palindromic string of length $2 \cdot |s|$ that is a rearrangement of the double of $s$.
-----Examples-----
Input
4
a
sururu
errorgorn
anutforajaroftuna
Output
aa
suurruurruus
rgnororerrerorongr
aannuuttffoorraajjaarrooffttuunnaa
-----Note-----
In the first test case, the double of ${a}$ is ${aa}$, which is already a palindrome.
In the second test case, the double of ${sururu}$ is ${ssuurruurruu}$. If we move the first ${s}$ to the end, we get ${suurruurruus}$, which is a palindrome.
In the third test case, the double of ${errorgorn}$ is ${eerrrroorrggoorrnn}$. We can rearrange the characters to form ${rgnororerrerorongr}$, which is a palindrome.
|
{"inputs": ["4\na\nsururu\nerrorgorn\nanutforajaroftuna\n"], "outputs": ["aa\nsururuururus\nerrorgornnrogrorre\nanutforajaroftunaanutforajaroftuna\n"]}
| 447
| 53
|
coding
|
Solve the programming task below in a Python markdown code block.
Given an integer $x$, find two non-negative integers $a$ and $b$ such that $(a \wedge b) + (a \vee b) = x$, where $\wedge$ is the bitwise AND operation and $\vee$ is the bitwise OR operation.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single integer $x$.
-----Output-----
If there is no valid pair $(a, b)$, print a single line containing the integer $-1$. Otherwise, print a single line containing two space-separated integers $a$ and $b$.
If there are multiple solutions, you may print any one of them.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le x \le 10^{18}$
-----Subtasks-----
Subtask #1 (30 points):
- $1 \le T \le 200$
- $1 \le x \le 200$
Subtask #2 (70 points): original constraints
-----Example Input-----
2
1
8
-----Example Output-----
0 1
5 3
|
{"inputs": ["2\n1\n8"], "outputs": ["0 1\n5 3"]}
| 289
| 22
|
coding
|
Solve the programming task below in a Python markdown code block.
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from $1$ to $n$.
-----Input-----
The only input line contains the integer $n$ ($1 \le n \le 2\cdot10^9$).
-----Output-----
Print the maximum product of digits among all integers from $1$ to $n$.
-----Examples-----
Input
390
Output
216
Input
7
Output
7
Input
1000000000
Output
387420489
-----Note-----
In the first example the maximum product is achieved for $389$ (the product of digits is $3\cdot8\cdot9=216$).
In the second example the maximum product is achieved for $7$ (the product of digits is $7$).
In the third example the maximum product is achieved for $999999999$ (the product of digits is $9^9=387420489$).
|
{"inputs": ["7\n", "1\n", "9\n", "2\n", "3\n", "4\n", "1\n", "9\n"], "outputs": ["7\n", "1\n", "9\n", "2\n", "3\n", "4\n", "1", "9"]}
| 267
| 68
|
coding
|
Solve the programming task below in a Python markdown code block.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
One day Petya encountered a tree with n vertexes. Besides, the tree was weighted, i. e. each edge of the tree has weight (a positive integer). An edge is lucky if its weight is a lucky number. Note that a tree with n vertexes is an undirected connected graph that has exactly n - 1 edges.
Petya wondered how many vertex triples (i, j, k) exists that on the way from i to j, as well as on the way from i to k there must be at least one lucky edge (all three vertexes are pairwise distinct). The order of numbers in the triple matters, that is, the triple (1, 2, 3) is not equal to the triple (2, 1, 3) and is not equal to the triple (1, 3, 2).
Find how many such triples of vertexes exist.
Input
The first line contains the single integer n (1 ≤ n ≤ 105) — the number of tree vertexes. Next n - 1 lines contain three integers each: ui vi wi (1 ≤ ui, vi ≤ n, 1 ≤ wi ≤ 109) — the pair of vertexes connected by the edge and the edge's weight.
Output
On the single line print the single number — the answer.
Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is recommended to use the cin, cout streams or the %I64d specificator.
Examples
Input
4
1 2 4
3 1 2
1 4 7
Output
16
Input
4
1 2 4
1 3 47
1 4 7447
Output
24
Note
The 16 triples of vertexes from the first sample are: (1, 2, 4), (1, 4, 2), (2, 1, 3), (2, 1, 4), (2, 3, 1), (2, 3, 4), (2, 4, 1), (2, 4, 3), (3, 2, 4), (3, 4, 2), (4, 1, 2), (4, 1, 3), (4, 2, 1), (4, 2, 3), (4, 3, 1), (4, 3, 2).
In the second sample all the triples should be counted: 4·3·2 = 24.
|
{"inputs": ["2\n1 2 7\n", "2\n1 2 4\n", "2\n1 2 2\n", "2\n1 2 12\n", "2\n2 1 1000000000\n", "2\n2 1 1000010000\n", "2\n2 1 1001010000\n", "4\n1 2 4\n3 1 1\n1 4 7\n"], "outputs": ["0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "0\n", "16\n"]}
| 638
| 159
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given string $\boldsymbol{\mathrm{~s~}}$ and number $\boldsymbol{\mbox{k}}$.
Consider a substring $\boldsymbol{p}$ of string $\boldsymbol{\mathrm{~S~}}$. For each position of string $\boldsymbol{\mathrm{~S~}}$ mark it if there is an occurence of the substring that covers the position. More formally, position $\boldsymbol{i}$ will be marked if there exists such index $j$ that: $j\leq i\leq j+|p|-1$ and $s_js_{j+1}\cdots s_{j+|p|-1}=p$. We will tell $\boldsymbol{p}$ produce $\boldsymbol{x}$ islands if all the marked positions form $\boldsymbol{x}$ groups of contiguous positions.
For example, if we have a string ababaewabaq the substring aba marks the positions 1, 2, 3, 4, 5, 8, 9, 10; that is XXXXXewXXXq (X denotes marked position). We can see 2 groups of contiguous positions, that is 2 islands. Finally, substring aba produces 2 islands in the string ababaewabaq.
Calculate and print the number of different substrings of string $\boldsymbol{\mathrm{~S~}}$ that produce exactly $\boldsymbol{\mbox{k}}$ islands.
Input Format
The first line contains string $\boldsymbol{\mathrm{~S~}}$ $(1\leq|s|\leq10^5)$. The string consists of lowercase letters only. The second line contains an integer $\boldsymbol{\mbox{k}}$ $(1\leq k\leq|s|)$.
Output Format
Output a single integer $\textbf{z}$ the answer to the problem.
Sample Input
abaab
2
Sample Output
3
Explanation
All the suitable substrings are: a, ab, b.
|
{"inputs": ["abaab\n2\n"], "outputs": ["3\n"]}
| 432
| 17
|
coding
|
Solve the programming task below in a Python markdown code block.
You are given three bags. Each bag contains a non-empty multiset of numbers. You can perform a number of operations on these bags. In one operation, you can choose any two non-empty bags, and choose one number from each of the bags. Let's say that you choose number $a$ from the first bag and number $b$ from the second bag. Then, you remove $b$ from the second bag and replace $a$ with $a-b$ in the first bag. Note that if there are multiple occurrences of these numbers, then you shall only remove/replace exactly one occurrence.
You have to perform these operations in such a way that you have exactly one number remaining in exactly one of the bags (the other two bags being empty). It can be shown that you can always apply these operations to receive such a configuration in the end. Among all these configurations, find the one which has the maximum number left in the end.
-----Input-----
The first line of the input contains three space-separated integers $n_1$, $n_2$ and $n_3$ ($1 \le n_1, n_2, n_3 \le 3\cdot10^5$, $1 \le n_1+n_2+n_3 \le 3\cdot10^5$) — the number of numbers in the three bags.
The $i$-th of the next three lines contain $n_i$ space-separated integers $a_{{i,1}}$, $a_{{i,2}}$, ..., $a_{{i,{{n_i}}}}$ ($1 \le a_{{i,j}} \le 10^9$) — the numbers in the $i$-th bag.
-----Output-----
Print a single integer — the maximum number which you can achieve in the end.
-----Examples-----
Input
2 4 1
1 2
6 3 4 5
5
Output
20
Input
3 2 2
7 5 4
2 9
7 1
Output
29
-----Note-----
In the first example input, let us perform the following operations:
$[1, 2], [6, 3, 4, 5], [5]$
$[-5, 2], [3, 4, 5], [5]$ (Applying an operation to $(1, 6)$)
$[-10, 2], [3, 4], [5]$ (Applying an operation to $(-5, 5)$)
$[2], [3, 4], [15]$ (Applying an operation to $(5, -10)$)
$[-1], [4], [15]$ (Applying an operation to $(2, 3)$)
$[-5], [], [15]$ (Applying an operation to $(-1, 4)$)
$[], [], [20]$ (Applying an operation to $(15, -5)$)
You can verify that you cannot achieve a bigger number. Hence, the answer is $20$.
|
{"inputs": ["2 4 1\n1 2\n6 3 4 5\n5\n", "3 2 2\n7 5 4\n2 9\n7 1\n", "3 3 1\n2 3 4\n4 5 6\n5\n", "3 3 1\n2 3 4\n4 5 6\n5\n", "3 3 1\n2 3 4\n4 7 6\n5\n", "3 2 2\n1 5 4\n2 9\n7 1\n", "2 4 1\n1 4\n6 3 4 5\n5\n", "3 3 1\n3 3 4\n4 7 6\n5\n"], "outputs": ["20", "29", "19", "19", "21\n", "25\n", "20\n", "22\n"]}
| 671
| 218
|
coding
|
Solve the programming task below in a Python markdown code block.
There are N points on the 2D plane, i-th of which is located on (x_i, y_i).
There can be multiple points that share the same coordinate.
What is the maximum possible Manhattan distance between two distinct points?
Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.
-----Constraints-----
- 2 \leq N \leq 2 \times 10^5
- 1 \leq x_i,y_i \leq 10^9
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
-----Output-----
Print the answer.
-----Sample Input-----
3
1 1
2 4
3 2
-----Sample Output-----
4
The Manhattan distance between the first point and the second point is |1-2|+|1-4|=4, which is maximum possible.
|
{"inputs": ["2\n0 1\n1 1", "2\n0 0\n1 1", "2\n0 0\n1 2", "2\n1 1\n1 1", "2\n1 1\n1 1\n", "2\n0 -1\n1 2", "2\n9 9\n0 -1", "2\n0 2\n39 0"], "outputs": ["1\n", "2\n", "3\n", "0", "0\n", "4\n", "19\n", "41\n"]}
| 248
| 129
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You are given an m x n grid. Each cell of grid represents a street. The street of grid[i][j] can be:
1 which means a street connecting the left cell and the right cell.
2 which means a street connecting the upper cell and the lower cell.
3 which means a street connecting the left cell and the lower cell.
4 which means a street connecting the right cell and the lower cell.
5 which means a street connecting the left cell and the upper cell.
6 which means a street connecting the right cell and the upper cell.
You will initially start at the street of the upper-left cell (0, 0). A valid path in the grid is a path that starts from the upper left cell (0, 0) and ends at the bottom-right cell (m - 1, n - 1). The path should only follow the streets.
Notice that you are not allowed to change any street.
Return true if there is a valid path in the grid or false otherwise.
Please complete the following python code precisely:
```python
class Solution:
def hasValidPath(self, grid: List[List[int]]) -> bool:
```
|
{"functional": "def check(candidate):\n assert candidate(grid = [[2,4,3],[6,5,2]]) == True\n assert candidate(grid = [[1,2,1],[1,2,1]]) == False\n assert candidate(grid = [[1,1,2]]) == False\n assert candidate(grid = [[1,1,1,1,1,1,3]]) == True\n assert candidate(grid = [[2],[2],[2],[2],[2],[2],[6]]) == True\n\n\ncheck(Solution().hasValidPath)"}
| 254
| 123
|
coding
|
Solve the programming task below in a Python markdown code block.
Sereja showed an interesting game to his friends. The game goes like that. Initially, there is a table with an empty cup and n water mugs on it. Then all players take turns to move. During a move, a player takes a non-empty mug of water and pours all water from it into the cup. If the cup overfills, then we assume that this player lost.
As soon as Sereja's friends heard of the game, they wanted to play it. Sereja, on the other hand, wanted to find out whether his friends can play the game in such a way that there are no losers. You are given the volumes of all mugs and the cup. Also, you know that Sereja has (n - 1) friends. Determine if Sereja's friends can play the game so that nobody loses.
-----Input-----
The first line contains integers n and s (2 ≤ n ≤ 100; 1 ≤ s ≤ 1000) — the number of mugs and the volume of the cup. The next line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10). Number a_{i} means the volume of the i-th mug.
-----Output-----
In a single line, print "YES" (without the quotes) if his friends can play in the described manner, and "NO" (without the quotes) otherwise.
-----Examples-----
Input
3 4
1 1 1
Output
YES
Input
3 4
3 1 3
Output
YES
Input
3 4
4 4 4
Output
NO
|
{"inputs": ["2 4\n4 4\n", "2 1\n1 1\n", "2 1\n2 2\n", "2 1\n1 1\n", "2 4\n4 4\n", "2 1\n2 2\n", "2 1\n3 2\n", "2 1\n3 4\n"], "outputs": ["YES\n", "YES\n", "NO\n", "YES\n", "YES\n", "NO\n", "NO\n", "NO\n"]}
| 366
| 118
|
coding
|
Solve the programming task below in a Python markdown code block.
Takahashi has two integers X and Y.
He computed X + Y and X - Y, and the results were A and B, respectively.
Now he cannot remember what X and Y were. Find X and Y for him.
-----Constraints-----
- -100 \leq A, B \leq 100
- For the given integers A and B, there uniquely exist integers X and Y such that X + Y = A and X - Y = B.
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
A B
-----Output-----
Print X and Y.
-----Sample Input-----
2 -2
-----Sample Output-----
0 2
If X = 0 and Y = 2, they match the situation: 0 + 2 = 2 and 0 - 2 = -2.
|
{"inputs": ["3 1\n", "2 -2\n", "-98 4\n", "64 10\n", "-23 71\n", "62 -28\n", "17 -95\n", "-39 -69\n"], "outputs": ["2 1\n", "0 2\n", "-47 -51\n", "37 27\n", "24 -47\n", "17 45\n", "-39 56\n", "-54 15\n"]}
| 195
| 125
|
coding
|
Solve the programming task below in a Python markdown code block.
Read problems statements in Mandarin Chinese, Russian and Vietnamese as well.
Watson gives an array A of N integers A_{1}, A_{2}, ..., A_{N} to Sherlock. He wants Sherlock to reorganize the array in a way such that no two adjacent numbers differ by more than 1.
Formally, if reorganized array is B_{1}, B_{2}, ..., B_{N}, then the condition that | B_{i} - B_{i + 1} | ≤ 1, for all 1 ≤ i < N(where |x| denotes the absolute value of x) should be met.
Sherlock is not sure that a solution exists, so he asks you.
------ Input ------
First line contains T, number of test cases. Each test case consists of N in one line followed by N integers in next line denoting A_{1}, A_{2}, ..., A_{N}.
------ Output ------
For each test case, output in one line YES or NO denoting if array A can be reorganized in required way or not.
------ Constraints ------
$1 ≤ T ≤ 100$
$1 ≤ N ≤ 10^{5}$
$1 ≤ A_{i} ≤ 10^{9}$
$Sum of N over all test cases ≤ 2*10^{5}$
----- Sample Input 1 ------
2
4
3 2 2 3
2
1 5
----- Sample Output 1 ------
YES
NO
----- explanation 1 ------
Test case 1:
No need to reorganise.
Test case 2:
No possible way.
|
{"inputs": ["2\n4\n3 2 2 3 \n2\n1 5"], "outputs": ["YES\nNO"]}
| 359
| 31
|
coding
|
Solve the programming task below in a Python markdown code block.
Statistics claims that students sleep no more than three hours a day. But even in the world of their dreams, while they are snoring peacefully, the sense of impending doom is still upon them.
A poor student is dreaming that he is sitting the mathematical analysis exam. And he is examined by the most formidable professor of all times, a three times Soviet Union Hero, a Noble Prize laureate in student expulsion, venerable Petr Palych.
The poor student couldn't answer a single question. Thus, instead of a large spacious office he is going to apply for a job to thorium mines. But wait a minute! Petr Palych decided to give the student the last chance! Yes, that is possible only in dreams.
So the professor began: "Once a Venusian girl and a Marsian boy met on the Earth and decided to take a walk holding hands. But the problem is the girl has al fingers on her left hand and ar fingers on the right one. The boy correspondingly has bl and br fingers. They can only feel comfortable when holding hands, when no pair of the girl's fingers will touch each other. That is, they are comfortable when between any two girl's fingers there is a boy's finger. And in addition, no three fingers of the boy should touch each other. Determine if they can hold hands so that the both were comfortable."
The boy any the girl don't care who goes to the left and who goes to the right. The difference is only that if the boy goes to the left of the girl, he will take her left hand with his right one, and if he goes to the right of the girl, then it is vice versa.
Input
The first line contains two positive integers not exceeding 100. They are the number of fingers on the Venusian girl's left and right hand correspondingly. The second line contains two integers not exceeding 100. They are the number of fingers on the Marsian boy's left and right hands correspondingly.
Output
Print YES or NO, that is, the answer to Petr Palych's question.
Examples
Input
5 1
10 5
Output
YES
Input
4 5
3 3
Output
YES
Input
1 2
11 6
Output
NO
Note
The boy and the girl don't really care who goes to the left.
|
{"inputs": ["2 2\n1 1\n", "1 1\n1 1\n", "2 4\n6 6\n", "3 3\n1 1\n", "4 4\n1 1\n", "2 2\n1 2\n", "0 1\n1 1\n", "2 4\n6 8\n"], "outputs": ["YES\n", "YES\n", "YES\n", "NO\n", "NO\n", "YES\n", "YES\n", "YES\n"]}
| 502
| 118
|
coding
|
Please solve the programming task below using a self-contained code snippet in a markdown code block.
You have n packages that you are trying to place in boxes, one package in each box. There are m suppliers that each produce boxes of different sizes (with infinite supply). A package can be placed in a box if the size of the package is less than or equal to the size of the box.
The package sizes are given as an integer array packages, where packages[i] is the size of the ith package. The suppliers are given as a 2D integer array boxes, where boxes[j] is an array of box sizes that the jth supplier produces.
You want to choose a single supplier and use boxes from them such that the total wasted space is minimized. For each package in a box, we define the space wasted to be size of the box - size of the package. The total wasted space is the sum of the space wasted in all the boxes.
For example, if you have to fit packages with sizes [2,3,5] and the supplier offers boxes of sizes [4,8], you can fit the packages of size-2 and size-3 into two boxes of size-4 and the package with size-5 into a box of size-8. This would result in a waste of (4-2) + (4-3) + (8-5) = 6.
Return the minimum total wasted space by choosing the box supplier optimally, or -1 if it is impossible to fit all the packages inside boxes. Since the answer may be large, return it modulo 109 + 7.
Please complete the following python code precisely:
```python
class Solution:
def minWastedSpace(self, packages: List[int], boxes: List[List[int]]) -> int:
```
|
{"functional": "def check(candidate):\n assert candidate(packages = [2,3,5], boxes = [[4,8],[2,8]]) == 6\n assert candidate(packages = [2,3,5], boxes = [[1,4],[2,3],[3,4]]) == -1\n assert candidate(packages = [3,5,8,10,11,12], boxes = [[12],[11,9],[10,5,14]]) == 9\n\n\ncheck(Solution().minWastedSpace)"}
| 371
| 126
|
coding
|
Solve the programming task below in a Python markdown code block.
Sevenkplus has a regular polygon. Each vertex of the polygon has a color, either white or black. Sevenkplus wants to count the number of isosceles triangles whose vertices are vertices of the regular polygon and have the same color.
Input Format
The first line contains an integer T. T testcases follow.
For each test case, there is only one line, which consists of a 01-string with length >= 3. Number of vertices n of the regular polygon equals length of the string. The string represents color of vertices in clockwise order. 0 represents white and 1 represents black.
Output Format
For each test case, output one line in the format Case #t: ans, where t is the case number (starting from 1), and ans is the answer.
Constraints
Sum of all n in the input <= 10^6.
Sample Input
5
001
0001
10001
111010
1101010
Sample Output
Case 1: 0
Case 2: 1
Case 3: 1
Case 4: 2
Case 5: 3
Explanation
In case 5, indices of vertices of the three monochromatic isosceles triangles are (0,3,5), (1,3,5) and (2,4,6) (assuming indices start from 0).
Timelimits
Timelimits for this challenge is given here
|
{"inputs": ["5\n001\n0001\n10001\n111010\n1101010\n"], "outputs": ["Case 1: 0\nCase 2: 1\nCase 3: 1\nCase 4: 2\nCase 5: 3\n"]}
| 336
| 77
|
coding
|
Solve the programming task below in a Python markdown code block.
Gift Exchange Party
A gift exchange party will be held at a school in TKB City.
For every pair of students who are close friends, one gift must be given from one to the other at this party, but not the other way around. It is decided in advance the gift directions, that is, which student of each pair receives a gift. No other gift exchanges are made.
If each pair randomly decided the gift direction, some might receive countless gifts, while some might receive only few or even none.
You'd like to decide the gift directions for all the friend pairs that minimize the difference between the smallest and the largest numbers of gifts received by a student. Find the smallest and the largest numbers of gifts received when the difference between them is minimized. When there is more than one way to realize that, find the way that maximizes the smallest number of received gifts.
Input
The input consists of at most 10 datasets, each in the following format.
n m
u1 v1
...
um vm
n is the number of students, and m is the number of friendship relations (2 ≤ n ≤ 100, 1 ≤ m ≤ n (n-1)/2). Students are denoted by integers between 1 and n, inclusive. The following m lines describe the friendship relations: for each i, student ui and vi are close friends (ui < vi). The same friendship relations do not appear more than once.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output a single line containing two integers l and h separated by a single space. Here, l and h are the smallest and the largest numbers, respectively, of gifts received by a student.
Sample Input
3 3
1 2
2 3
1 3
4 3
1 2
1 3
1 4
4 6
1 2
1 3
1 4
2 3
3 4
2 4
0 0
Output for the Sample Input
1 1
0 1
1 2
Example
Input
3 3
1 2
2 3
1 3
4 3
1 2
1 3
1 4
4 6
1 2
1 3
1 4
2 3
3 4
2 4
0 0
Output
1 1
0 1
1 2
|
{"inputs": ["3 3\n1 2\n2 3\n1 3\n4 3\n1 2\n1 3\n1 4\n4 6\n1 2\n1 3\n1 2\n2 3\n3 4\n2 4\n0 0", "3 3\n2 2\n2 3\n2 3\n4 3\n1 2\n1 3\n1 4\n4 6\n1 4\n1 3\n1 4\n2 3\n3 4\n2 4\n0 0", "3 3\n2 2\n2 3\n2 3\n4 3\n1 2\n1 3\n1 4\n6 6\n1 4\n1 3\n1 4\n2 3\n3 4\n2 4\n0 0", "4 3\n1 2\n2 3\n2 3\n4 3\n1 2\n1 3\n1 4\n4 6\n1 4\n1 3\n1 4\n2 3\n3 4\n3 4\n0 0", "3 3\n1 2\n2 3\n1 3\n4 3\n1 2\n1 3\n1 4\n7 6\n2 2\n1 3\n1 2\n2 3\n3 4\n1 4\n0 0", "4 3\n1 2\n2 3\n1 3\n4 3\n1 2\n1 3\n1 4\n8 6\n1 4\n1 3\n1 4\n2 3\n3 4\n3 4\n0 0", "3 3\n1 2\n2 3\n1 3\n7 3\n1 1\n1 4\n1 4\n4 6\n2 2\n1 3\n1 2\n2 3\n3 4\n2 4\n0 0", "3 3\n1 2\n2 3\n1 3\n4 3\n1 2\n1 3\n1 4\n4 6\n1 4\n1 3\n1 4\n2 3\n3 4\n2 4\n0 0"], "outputs": ["1 1\n0 1\n1 2\n", "0 2\n0 1\n1 2\n", "0 2\n0 1\n0 2\n", "0 1\n0 1\n1 2\n", "1 1\n0 1\n0 2\n", "0 1\n0 1\n0 2\n", "1 1\n0 2\n1 2\n", "1 1\n0 1\n1 2\n"]}
| 532
| 638
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.