Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. You have N items and a bag of strength W. The i-th item has a weight of w_i and a value of v_i. You will select some of the items and put them in the bag. Here, the total weight of the selected items needs to be at most W. Your objective is to maximize the total value of the selected items. Constraints * 1 ≤ N ≤ 100 * 1 ≤ W ≤ 10^9 * 1 ≤ w_i ≤ 10^9 * For each i = 2,3,...,N, w_1 ≤ w_i ≤ w_1 + 3. * 1 ≤ v_i ≤ 10^7 * W, each w_i and v_i are integers. Input Input is given from Standard Input in the following format: N W w_1 v_1 w_2 v_2 : w_N v_N Output Print the maximum possible total value of the selected items. Examples Input 4 6 2 1 3 4 4 10 3 4 Output 11 Input 4 6 2 1 3 7 4 10 3 6 Output 13 Input 4 10 1 100 1 100 1 100 1 100 Output 400 Input 4 1 10 100 10 100 10 100 10 100 Output 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by $2$, $4$ or $8$, and division is only allowed if the number is divisible by the chosen divisor. Formally, if the register contains a positive integer $x$, in one operation it can be replaced by one of the following: $x \cdot 2$ $x \cdot 4$ $x \cdot 8$ $x / 2$, if $x$ is divisible by $2$ $x / 4$, if $x$ is divisible by $4$ $x / 8$, if $x$ is divisible by $8$ For example, if $x = 6$, in one operation it can be replaced by $12$, $24$, $48$ or $3$. Value $6$ isn't divisible by $4$ or $8$, so there're only four variants of replacement. Now Johnny wonders how many operations he needs to perform if he puts $a$ in the register and wants to get $b$ at the end. -----Input----- The input consists of multiple test cases. The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases. The following $t$ lines contain a description of test cases. The first and only line in each test case contains integers $a$ and $b$ ($1 \leq a, b \leq 10^{18}$) — the initial and target value of the variable, respectively. -----Output----- Output $t$ lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get $b$ at the end, then write $-1$. -----Example----- Input 10 10 5 11 44 17 21 1 1 96 3 2 128 1001 1100611139403776 1000000000000000000 1000000000000000000 7 1 10 8 Output 1 1 -1 0 2 2 14 0 -1 -1 -----Note----- In the first test case, Johnny can reach $5$ from $10$ by using the shift to the right by one (i.e. divide by $2$). In the second test case, Johnny can reach $44$ from $11$ by using the shift to the left by two (i.e. multiply by $4$). In the third test case, it is impossible for Johnny to reach $21$ from $17$. In the fourth test case, initial and target values are equal, so Johnny has to do $0$ operations. In the fifth test case, Johnny can reach $3$ from $96$ by using two shifts to the right: one by $2$, and another by $3$ (i.e. divide by $4$ and by $8$). Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Kirito is stuck on a level of the MMORPG he is playing now. To move on in the game, he's got to defeat all n dragons that live on this level. Kirito and the dragons have strength, which is represented by an integer. In the duel between two opponents the duel's outcome is determined by their strength. Initially, Kirito's strength equals s. If Kirito starts duelling with the i-th (1 ≤ i ≤ n) dragon and Kirito's strength is not greater than the dragon's strength xi, then Kirito loses the duel and dies. But if Kirito's strength is greater than the dragon's strength, then he defeats the dragon and gets a bonus strength increase by yi. Kirito can fight the dragons in any order. Determine whether he can move on to the next level of the game, that is, defeat all dragons without a single loss. Input The first line contains two space-separated integers s and n (1 ≤ s ≤ 104, 1 ≤ n ≤ 103). Then n lines follow: the i-th line contains space-separated integers xi and yi (1 ≤ xi ≤ 104, 0 ≤ yi ≤ 104) — the i-th dragon's strength and the bonus for defeating it. Output On a single line print "YES" (without the quotes), if Kirito can move on to the next level and print "NO" (without the quotes), if he can't. Examples Input 2 2 1 99 100 0 Output YES Input 10 1 100 100 Output NO Note In the first sample Kirito's strength initially equals 2. As the first dragon's strength is less than 2, Kirito can fight it and defeat it. After that he gets the bonus and his strength increases to 2 + 99 = 101. Now he can defeat the second dragon and move on to the next level. In the second sample Kirito's strength is too small to defeat the only dragon and win. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array $a_1, a_2, \dots, a_n$ consisting of $n$ distinct integers. Count the number of pairs of indices $(i, j)$ such that $i < j$ and $a_i \cdot a_j = i + j$. -----Input----- The first line contains one integer $t$ ($1 \leq t \leq 10^4$) — the number of test cases. Then $t$ cases follow. The first line of each test case contains one integer $n$ ($2 \leq n \leq 10^5$) — the length of array $a$. The second line of each test case contains $n$ space separated integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 2 \cdot n$) — the array $a$. It is guaranteed that all elements are distinct. It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$. -----Output----- For each test case, output the number of pairs of indices $(i, j)$ such that $i < j$ and $a_i \cdot a_j = i + j$. -----Examples----- Input 3 2 3 1 3 6 1 5 5 3 1 5 9 2 Output 1 1 3 -----Note----- For the first test case, the only pair that satisfies the constraints is $(1, 2)$, as $a_1 \cdot a_2 = 1 + 2 = 3$ For the second test case, the only pair that satisfies the constraints is $(2, 3)$. For the third test case, the pairs that satisfy the constraints are $(1, 2)$, $(1, 5)$, and $(2, 3)$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Our bear's forest has a checkered field. The checkered field is an n × n table, the rows are numbered from 1 to n from top to bottom, the columns are numbered from 1 to n from left to right. Let's denote a cell of the field on the intersection of row x and column y by record (x, y). Each cell of the field contains growing raspberry, at that, the cell (x, y) of the field contains x + y raspberry bushes. The bear came out to walk across the field. At the beginning of the walk his speed is (dx, dy). Then the bear spends exactly t seconds on the field. Each second the following takes place: Let's suppose that at the current moment the bear is in cell (x, y). First the bear eats the raspberry from all the bushes he has in the current cell. After the bear eats the raspberry from k bushes, he increases each component of his speed by k. In other words, if before eating the k bushes of raspberry his speed was (dx, dy), then after eating the berry his speed equals (dx + k, dy + k). Let's denote the current speed of the bear (dx, dy) (it was increased after the previous step). Then the bear moves from cell (x, y) to cell (((x + dx - 1) mod n) + 1, ((y + dy - 1) mod n) + 1). Then one additional raspberry bush grows in each cell of the field. You task is to predict the bear's actions. Find the cell he ends up in if he starts from cell (sx, sy). Assume that each bush has infinitely much raspberry and the bear will never eat all of it. -----Input----- The first line of the input contains six space-separated integers: n, sx, sy, dx, dy, t (1 ≤ n ≤ 10^9; 1 ≤ sx, sy ≤ n; - 100 ≤ dx, dy ≤ 100; 0 ≤ t ≤ 10^18). -----Output----- Print two integers — the coordinates of the cell the bear will end up in after t seconds. -----Examples----- Input 5 1 2 0 1 2 Output 3 1 Input 1 1 1 -1 -1 2 Output 1 1 -----Note----- Operation a mod b means taking the remainder after dividing a by b. Note that the result of the operation is always non-negative. For example, ( - 1) mod 3 = 2. In the first sample before the first move the speed vector will equal (3,4) and the bear will get to cell (4,1). Before the second move the speed vector will equal (9,10) and he bear will get to cell (3,1). Don't forget that at the second move, the number of berry bushes increased by 1. In the second sample before the first move the speed vector will equal (1,1) and the bear will get to cell (1,1). Before the second move, the speed vector will equal (4,4) and the bear will get to cell (1,1). Don't forget that at the second move, the number of berry bushes increased by 1. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Little Dormi received a histogram with $n$ bars of height $a_1, a_2, \ldots, a_n$ for Christmas. However, the more he played with his new histogram, the more he realized its imperfections, so today he wanted to modify it to his liking. To modify the histogram, Little Dormi is able to perform the following operation an arbitrary number of times: Select an index $i$ ($1 \le i \le n$) where $a_i>0$, and assign $a_i := a_i-1$. Little Dormi defines the ugliness score of his histogram (after performing some number of operations) as the sum of the vertical length of its outline and the number of operations he performed on it. And to make the histogram as perfect as possible, he would like to minimize the ugliness score after modifying it with some number of operations. However, as his histogram is very large, Little Dormi is having trouble minimizing the ugliness score, so as Little Dormi's older brother, help him find the minimal ugliness. Consider the following example where the histogram has $4$ columns of heights $4,8,9,6$: The blue region represents the histogram, and the red lines represent the vertical portion of the outline. Currently, the vertical length of the outline is $4+4+1+3+6 = 18$, so if Little Dormi does not modify the histogram at all, the ugliness would be $18$. However, Little Dormi can apply the operation once on column $2$ and twice on column $3$, resulting in a histogram with heights $4,7,7,6$: Now, as the total vertical length of the outline (red lines) is $4+3+1+6=14$, the ugliness is $14+3=17$ dollars. It can be proven that this is optimal. -----Input----- Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). Description of the test cases follows. The first line of each test case contains a single integer $n$ ($1 \le n \le 4 \cdot 10^5$). The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^9$). It is guaranteed that the sum of $n$ over all test cases does not exceed $4 \cdot 10^5$. -----Output----- For each test case output one integer, the minimal ugliness Little Dormi can achieve with the histogram in that test case. -----Examples----- Input 2 4 4 8 9 6 6 2 1 7 4 0 0 Output 17 12 -----Note----- Example $1$ is the example described in the statement. The initial histogram for example $2$ is given below: The ugliness is currently $2+1+6+3+4=16$. By applying the operation once on column $1$, six times on column $3$, and three times on column $4$, we can end up with a histogram with heights $1,1,1,1,0,0$: The vertical length of the outline is now $1+1=2$ and Little Dormi made $1+6+3=10$ operations, so the final ugliness is $2+10=12$, which can be proven to be optimal. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A way to make a new task is to make it nondeterministic or probabilistic. For example, the hard task of Topcoder SRM 595, Constellation, is the probabilistic version of a convex hull. Let's try to make a new task. Firstly we will use the following task. There are n people, sort them by their name. It is just an ordinary sorting problem, but we can make it more interesting by adding nondeterministic element. There are n people, each person will use either his/her first name or last name as a handle. Can the lexicographical order of the handles be exactly equal to the given permutation p? More formally, if we denote the handle of the i-th person as h_{i}, then the following condition must hold: $\forall i, j(i < j) : h_{p_{i}} < h_{p_{j}}$. -----Input----- The first line contains an integer n (1 ≤ n ≤ 10^5) — the number of people. The next n lines each contains two strings. The i-th line contains strings f_{i} and s_{i} (1 ≤ \|f_{i}\|, \|s_{i}\| ≤ 50) — the first name and last name of the i-th person. Each string consists only of lowercase English letters. All of the given 2n strings will be distinct. The next line contains n distinct integers: p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n). -----Output----- If it is possible, output "YES", otherwise output "NO". -----Examples----- Input 3 gennady korotkevich petr mitrichev gaoyuan chen 1 2 3 Output NO Input 3 gennady korotkevich petr mitrichev gaoyuan chen 3 1 2 Output YES Input 2 galileo galilei nicolaus copernicus 2 1 Output YES Input 10 rean schwarzer fei claussell alisa reinford eliot craig laura arseid jusis albarea machias regnitz sara valestin emma millstein gaius worzel 1 2 3 4 5 6 7 8 9 10 Output NO Input 10 rean schwarzer fei claussell alisa reinford eliot craig laura arseid jusis albarea machias regnitz sara valestin emma millstein gaius worzel 2 4 9 6 5 7 1 3 8 10 Output YES -----Note----- In example 1 and 2, we have 3 people: tourist, Petr and me (cgy4ever). You can see that whatever handle is chosen, I must be the first, then tourist and Petr must be the last. In example 3, if Copernicus uses "copernicus" as his handle, everything will be alright. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied: * The bitwise AND of the chosen numbers is S. * The bitwise OR of the chosen numbers is T. Constraints * 1 \leq N \leq 50 * 1 \leq K \leq N * 0 \leq A_i < 2^{18} * 0 \leq S < 2^{18} * 0 \leq T < 2^{18} * A_i \neq A_j (1 \leq i < j \leq N) Input Input is given from Standard Input in the following format: N K S T A_1 A_2 ... A_N Output Print the answer. Examples Input 3 3 0 3 1 2 3 Output 2 Input 5 3 1 7 3 4 9 1 5 Output 2 Input 5 4 0 15 3 4 9 1 5 Output 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Kenkoooo found a simple connected graph. The vertices are numbered 1 through n. The i-th edge connects Vertex u_i and v_i, and has a fixed integer s_i. Kenkoooo is trying to write a positive integer in each vertex so that the following condition is satisfied: * For every edge i, the sum of the positive integers written in Vertex u_i and v_i is equal to s_i. Find the number of such ways to write positive integers in the vertices. Constraints * 2 \leq n \leq 10^5 * 1 \leq m \leq 10^5 * 1 \leq u_i < v_i \leq n * 2 \leq s_i \leq 10^9 * If i\neq j, then u_i \neq u_j or v_i \neq v_j. * The graph is connected. * All values in input are integers. Input Input is given from Standard Input in the following format: n m u_1 v_1 s_1 : u_m v_m s_m Output Print the number of ways to write positive integers in the vertices so that the condition is satisfied. Examples Input 3 3 1 2 3 2 3 5 1 3 4 Output 1 Input 4 3 1 2 6 2 3 7 3 4 5 Output 3 Input 8 7 1 2 1000000000 2 3 2 3 4 1000000000 4 5 2 5 6 1000000000 6 7 2 7 8 1000000000 Output 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Problem I chose creature observation as the theme of my free study during the summer vacation and purchased a creature observation kit. This creature prefers to live in a three-dimensional grid-like space. Only one animal can be placed in each cell. It repeats birth and death every day according to the surrounding environment. The conditions of birth and death depend on the number of creatures adjacent to the cell. Here, when a living thing is adjacent to a certain cell, it means that one cell and another cell inhabiting the living thing share a face, an edge, or a point. The rules of birth and death are as follows. * In a cell where no creatures live, if there is an i such that the number of adjacent creatures is ai (1 ≤ i ≤ M1), a creature is born in that cell. * In a cell inhabited by a creature, if there is no j such that the number of adjacent creatures is bj (1 ≤ j ≤ M2), the creature in that cell will die. The breeding box I bought this time is a cubic breeding box with 5 * 5 * 5 cells. How does this creature behave in this breeding box ...? I'm really looking forward to it. ~A few days later~ For the time being, I tried breeding it ... It takes time to observe it every day, and I'm annoyed and unmotivated. Yes, let's simulate using a computer and a program. Constraints The input satisfies the following conditions. * 1 ≤ N ≤ 100 * 0 ≤ M1, M2 ≤ 27 * 0 ≤ ai, bj ≤ 26 (1 ≤ i ≤ M1, 1 ≤ j ≤ M2) * For any i, j (1 ≤ i <j ≤ M1), ai ≠ aj * For any i, j (1 ≤ i <j ≤ M2), bi ≠ bj Input The input consists of multiple datasets. Each dataset is given in the following format. N (State of breeding box with z = 0) (Blank line) (State of breeding box with z = 1) (Blank line) (State of breeding box with z = 2) (Blank line) (State of breeding box with z = 3) (Blank line) (State of breeding box with z = 4) (Blank line) M1 a1 a2… aM1 M2 b1 b2… bM2 Given the number of days N to simulate first. Next, information on the initial state of the breeding box is given. This is given by 5 5 * 5 2D grids. Each 2D grid consists of 0s and 1s, where 1 indicates that there are living things and 0 indicates that there is nothing. For example, if the value in the 4th row and 2nd column of the 2D grid in the cell state of z = 0 is 1, it means that there is a creature at the position of the coordinates (1, 3, 0) of the breeding box. Then the integer M1 is given, followed by the M1 number ai. Then the integer M2 is given, followed by the M2 number bj. The end of the input is represented by N = 0. Output For each dataset, output the state after N days. The output follows the following format. Case (test case number): (State of breeding box with z = 0) (Blank line) (State of breeding box with z = 1) (Blank line) (State of breeding box with z = 2) (Blank line) (State of breeding box with z = 3) (Blank line) (State of breeding box with z = 4) Output the test case number on the first line, and output 5 5 * 5 2D grids as the state after N days have passed from the next line. Print a blank line between the outputs of each test case. Example Input 5 00000 01010 00000 00100 00000 00000 01010 00000 01010 00000 00000 00100 00000 01010 00000 00000 01010 00000 00100 00000 00000 00000 00100 00000 00000 1 2 2 3 4 4 01110 00100 00100 00100 01110 01110 10001 10000 10001 01110 11111 10001 11111 10000 10000 01110 10001 10000 10001 01110 00000 00000 00000 00000 00000 2 3 4 1 2 100 00100 01010 01110 10001 10001 01110 00100 00100 00100 01110 00000 00000 00000 00000 00000 11111 00010 00100 01000 11111 10001 10001 10001 10001 01110 5 1 3 5 7 9 5 0 2 4 6 8 0 Output Case 1: 00000 00000 01010 01110 10101 00000 10001 00000 00000 00000 00000 00000 11111 10001 00000 00000 00000 00000 00000 01010 00000 00000 01110 00100 11111 Case 2: 00010 10110 00000 11000 10000 00001 00000 10101 00010 00100 10001 00000 00000 00000 00010 01110 10001 00000 00001 10000 00000 00000 00111 01001 01000 Case 3: 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 00000 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. wHAT DO WE NEED cAPS LOCK FOR? Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage. Let's consider that a word has been typed with the Caps lock key accidentally switched on, if: * either it only contains uppercase letters; * or all letters except for the first one are uppercase. In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed. Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged. Input The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive. Output Print the result of the given word's processing. Examples Input cAPS Output Caps Input Lock Output Lock Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are two small spaceship, surrounded by two groups of enemy larger spaceships. The space is a two-dimensional plane, and one group of the enemy spaceships is positioned in such a way that they all have integer $y$-coordinates, and their $x$-coordinate is equal to $-100$, while the second group is positioned in such a way that they all have integer $y$-coordinates, and their $x$-coordinate is equal to $100$. Each spaceship in both groups will simultaneously shoot two laser shots (infinite ray that destroys any spaceship it touches), one towards each of the small spaceships, all at the same time. The small spaceships will be able to avoid all the laser shots, and now want to position themselves at some locations with $x=0$ (with not necessarily integer $y$-coordinates), such that the rays shot at them would destroy as many of the enemy spaceships as possible. Find the largest numbers of spaceships that can be destroyed this way, assuming that the enemy spaceships can't avoid laser shots. -----Input----- The first line contains two integers $n$ and $m$ ($1 \le n, m \le 60$), the number of enemy spaceships with $x = -100$ and the number of enemy spaceships with $x = 100$, respectively. The second line contains $n$ integers $y_{1,1}, y_{1,2}, \ldots, y_{1,n}$ ($\|y_{1,i}\| \le 10\,000$) — the $y$-coordinates of the spaceships in the first group. The third line contains $m$ integers $y_{2,1}, y_{2,2}, \ldots, y_{2,m}$ ($\|y_{2,i}\| \le 10\,000$) — the $y$-coordinates of the spaceships in the second group. The $y$ coordinates are not guaranteed to be unique, even within a group. -----Output----- Print a single integer – the largest number of enemy spaceships that can be destroyed. -----Examples----- Input 3 9 1 2 3 1 2 3 7 8 9 11 12 13 Output 9 Input 5 5 1 2 3 4 5 1 2 3 4 5 Output 10 -----Note----- In the first example the first spaceship can be positioned at $(0, 2)$, and the second – at $(0, 7)$. This way all the enemy spaceships in the first group and $6$ out of $9$ spaceships in the second group will be destroyed. In the second example the first spaceship can be positioned at $(0, 3)$, and the second can be positioned anywhere, it will be sufficient to destroy all the enemy spaceships. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi and Aoki will have a battle using their monsters. The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively. The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins. If Takahashi will win, print Yes; if he will lose, print No. -----Constraints----- - 1 \leq A,B,C,D \leq 100 - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: A B C D -----Output----- If Takahashi will win, print Yes; if he will lose, print No. -----Sample Input----- 10 9 10 10 -----Sample Output----- No First, Takahashi's monster attacks Aoki's monster, whose health is now 10-9=1. Next, Aoki's monster attacks Takahashi's monster, whose health is now 10-10=0. Takahashi's monster is the first to have 0 or less health, so Takahashi loses. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A stowaway and a controller play the following game. The train is represented by n wagons which are numbered with positive integers from 1 to n from the head to the tail. The stowaway and the controller are initially in some two different wagons. Every minute the train can be in one of two conditions — moving or idle. Every minute the players move. The controller's move is as follows. The controller has the movement direction — to the train's head or to its tail. During a move the controller moves to the neighbouring wagon correspondingly to its movement direction. If at the end of his move the controller enters the 1-st or the n-th wagon, that he changes the direction of his movement into the other one. In other words, the controller cyclically goes from the train's head to its tail and back again during all the time of a game, shifting during each move by one wagon. Note, that the controller always have exactly one possible move. The stowaway's move depends from the state of the train. If the train is moving, then the stowaway can shift to one of neighbouring wagons or he can stay where he is without moving. If the train is at a station and is idle, then the stowaway leaves the train (i.e. he is now not present in any train wagon) and then, if it is not the terminal train station, he enters the train again into any of n wagons (not necessarily into the one he's just left and not necessarily into the neighbouring one). If the train is idle for several minutes then each such minute the stowaway leaves the train and enters it back. Let's determine the order of the players' moves. If at the given minute the train is moving, then first the stowaway moves and then the controller does. If at this minute the train is idle, then first the stowaway leaves the train, then the controller moves and then the stowaway enters the train. If at some point in time the stowaway and the controller happen to be in one wagon, then the controller wins: he makes the stowaway pay fine. If after a while the stowaway reaches the terminal train station, then the stowaway wins: he simply leaves the station during his move and never returns there again. At any moment of time the players know each other's positions. The players play in the optimal way. Specifically, if the controller wins, then the stowaway plays so as to lose as late as possible. As all the possible moves for the controller are determined uniquely, then he is considered to play optimally always. Determine the winner. Input The first line contains three integers n, m and k. They represent the number of wagons in the train, the stowaway's and the controller's initial positions correspondingly (2 ≤ n ≤ 50, 1 ≤ m, k ≤ n, m ≠ k). The second line contains the direction in which a controller moves. "to head" means that the controller moves to the train's head and "to tail" means that the controller moves to its tail. It is guaranteed that in the direction in which the controller is moving, there is at least one wagon. Wagon 1 is the head, and wagon n is the tail. The third line has the length from 1 to 200 and consists of symbols "0" and "1". The i-th symbol contains information about the train's state at the i-th minute of time. "0" means that in this very minute the train moves and "1" means that the train in this very minute stands idle. The last symbol of the third line is always "1" — that's the terminal train station. Output If the stowaway wins, print "Stowaway" without quotes. Otherwise, print "Controller" again without quotes, then, separated by a space, print the number of a minute, at which the stowaway will be caught. Examples Input 5 3 2 to head 0001001 Output Stowaway Input 3 2 1 to tail 0001 Output Controller 2 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Volodya likes listening to heavy metal and (occasionally) reading. No wonder Volodya is especially interested in texts concerning his favourite music style. Volodya calls a string powerful if it starts with "heavy" and ends with "metal". Finding all powerful substrings (by substring Volodya means a subsequence of consecutive characters in a string) in a given text makes our hero especially joyful. Recently he felt an enormous fit of energy while reading a certain text. So Volodya decided to count all powerful substrings in this text and brag about it all day long. Help him in this difficult task. Two substrings are considered different if they appear at the different positions in the text. For simplicity, let us assume that Volodya's text can be represented as a single string. -----Input----- Input contains a single non-empty string consisting of the lowercase Latin alphabet letters. Length of this string will not be greater than 10^6 characters. -----Output----- Print exactly one number — the number of powerful substrings of the given string. Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. -----Examples----- Input heavymetalisheavymetal Output 3 Input heavymetalismetal Output 2 Input trueheavymetalissotruewellitisalsosoheavythatyoucanalmostfeeltheweightofmetalonyou Output 3 -----Note----- In the first sample the string "heavymetalisheavymetal" contains powerful substring "heavymetal" twice, also the whole string "heavymetalisheavymetal" is certainly powerful. In the second sample the string "heavymetalismetal" contains two powerful substrings: "heavymetal" and "heavymetalismetal". Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. In recent years John has very successfully settled at his new job at the office. But John doesn't like to idly sit around while his code is compiling, so he immediately found himself an interesting distraction. The point of his distraction was to maintain a water level in the water cooler used by other zebras. Originally the cooler contained exactly $k$ liters of water. John decided that the amount of water must always be at least $l$ liters of water but no more than $r$ liters. John will stay at the office for exactly $t$ days. He knows that each day exactly $x$ liters of water will be used by his colleagues. At the beginning of each day he can add exactly $y$ liters of water to the cooler, but at any point in time the amount of water in the cooler must be in the range $[l, r]$. Now John wants to find out whether he will be able to maintain the water level at the necessary level for $t$ days. Help him answer this question! -----Input----- The first line of the input contains six integers $k$, $l$, $r$, $t$, $x$ and $y$ ($1 \le l \le k \le r \le 10^{18}; 1 \le t \le 10^{18}; 1 \le x \le 10^6; 1 \le y \le 10^{18}$) — initial water level, the required range, the number of days, daily water usage and the exact amount of water that can be added, respectively. -----Output----- Print "Yes" if John can maintain the water level for $t$ days and "No" otherwise. -----Examples----- Input 8 1 10 2 6 4 Output No Input 8 1 10 2 6 5 Output Yes Input 9 1 10 9 2 9 Output No Input 20 15 25 3 5 7 Output Yes -----Note----- In the first example, John can't increase the amount of water at the beginning of the first day, since it would exceed the limit $r$. That is why after the first day the cooler will contain $2$ liters of water. The next day John adds $4$ liters to the cooler but loses $6$ liters, leaving John with $0$ liters, which is outside the range $[1, 10]$. In the second example, after the first day John is left with $2$ liters of water. At the beginning of the next day he adds $5$ liters, then $6$ liters get used, leaving John with $1$ liter of water which is in range $[1, 10]$. In the third example, after the first day John is left with $7$ liters, after the second day — $5$ liters, after the fourth — $1$ liter. At the beginning of the fifth day John will add $9$ liters and lose $2$ liters. Meaning, after the fifth day he will have $8$ liters left. Then each day the water level will decrease by $2$ liters and after the eighth day John will have $2$ liters and after the ninth day — $0$ liters. $0$ is outside range $[1, 10]$, so the answer is "No". In the fourth example, after the first day John is left with $15$ liters of water. At the beginning of the second day he adds $7$ liters and loses $5$, so after the second day he is left with $17$ liters. At the beginning of the third day he adds $7$ more liters of water and loses $5$, so after the third day he is left with $19$ liters. $19$ is in range $[15, 25]$ so the answer is "Yes". Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before. As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree. A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node $v$ is the last different from $v$ vertex on the path from the root to the vertex $v$. Children of vertex $v$ are all nodes for which $v$ is the parent. A vertex is a leaf if it has no children. The rooted tree Serval owns has $n$ nodes, node $1$ is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation $\max$ or $\min$ written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively. Assume that there are $k$ leaves in the tree. Serval wants to put integers $1, 2, \ldots, k$ to the $k$ leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him? -----Input----- The first line contains an integer $n$ ($2 \leq n \leq 3\cdot 10^5$), the size of the tree. The second line contains $n$ integers, the $i$-th of them represents the operation in the node $i$. $0$ represents $\min$ and $1$ represents $\max$. If the node is a leaf, there is still a number of $0$ or $1$, but you can ignore it. The third line contains $n-1$ integers $f_2, f_3, \ldots, f_n$ ($1 \leq f_i \leq i-1$), where $f_i$ represents the parent of the node $i$. -----Output----- Output one integer — the maximum possible number in the root of the tree. -----Examples----- Input 6 1 0 1 1 0 1 1 2 2 2 2 Output 1 Input 5 1 0 1 0 1 1 1 1 1 Output 4 Input 8 1 0 0 1 0 1 1 0 1 1 2 2 3 3 3 Output 4 Input 9 1 1 0 0 1 0 1 0 1 1 1 2 2 3 3 4 4 Output 5 -----Note----- Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes. In the first example, no matter how you arrange the numbers, the answer is $1$. [Image] In the second example, no matter how you arrange the numbers, the answer is $4$. [Image] In the third example, one of the best solution to achieve $4$ is to arrange $4$ and $5$ to nodes $4$ and $5$. [Image] In the fourth example, the best solution is to arrange $5$ to node $5$. [Image] Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi is about to assemble a character figure, consisting of N parts called Part 1, Part 2, ..., Part N and N-1 connecting components. Parts are distinguishable, but connecting components are not. Part i has d_i holes, called Hole 1, Hole 2, ..., Hole d_i, into which a connecting component can be inserted. These holes in the parts are distinguishable. Each connecting component will be inserted into two holes in different parts, connecting these two parts. It is impossible to insert multiple connecting components into a hole. The character figure is said to be complete when it has the following properties: - All of the N-1 components are used to connect parts. - Consider a graph with N vertices corresponding to the parts and N-1 undirected edges corresponding to the pairs of vertices connected by a connecting component. Then, this graph is connected. Two ways A and B to make the figure complete are considered the same when the following is satisfied: for every pair of holes, A uses a connecting component to connect these holes if and only if B uses one to connect them. Find the number of ways to make the figure complete. Since the answer can be enormous, find the count modulo 998244353. -----Constraints----- - All values in input are integers. - 2 \leq N \leq 2 \times 10^5 - 1 \leq d_i < 998244353 -----Input----- Input is given from Standard Input in the following format: N d_1 d_2 \cdots d_N -----Output----- Print the answer. -----Sample Input----- 3 1 1 3 -----Sample Output----- 6 One way to make the figure complete is to connect Hole 1 in Part 1 and Hole 3 in Part 3 and then connect Hole 1 in Part 2 and Hole 1 in Part 3. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Find \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}. Here \gcd(a,b,c) denotes the greatest common divisor of a, b, and c. -----Constraints----- - 1 \leq K \leq 200 - K is an integer. -----Input----- Input is given from Standard Input in the following format: K -----Output----- Print the value of \displaystyle{\sum_{a=1}^{K}\sum_{b=1}^{K}\sum_{c=1}^{K} \gcd(a,b,c)}. -----Sample Input----- 2 -----Sample Output----- 9 \gcd(1,1,1)+\gcd(1,1,2)+\gcd(1,2,1)+\gcd(1,2,2)+\gcd(2,1,1)+\gcd(2,1,2)+\gcd(2,2,1)+\gcd(2,2,2)=1+1+1+1+1+1+1+2=9 Thus, the answer is 9. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. In a small restaurant there are a tables for one person and b tables for two persons. It it known that n groups of people come today, each consisting of one or two people. If a group consist of one person, it is seated at a vacant one-seater table. If there are none of them, it is seated at a vacant two-seater table. If there are none of them, it is seated at a two-seater table occupied by single person. If there are still none of them, the restaurant denies service to this group. If a group consist of two people, it is seated at a vacant two-seater table. If there are none of them, the restaurant denies service to this group. You are given a chronological order of groups coming. You are to determine the total number of people the restaurant denies service to. -----Input----- The first line contains three integers n, a and b (1 ≤ n ≤ 2·10^5, 1 ≤ a, b ≤ 2·10^5) — the number of groups coming to the restaurant, the number of one-seater and the number of two-seater tables. The second line contains a sequence of integers t_1, t_2, ..., t_{n} (1 ≤ t_{i} ≤ 2) — the description of clients in chronological order. If t_{i} is equal to one, then the i-th group consists of one person, otherwise the i-th group consists of two people. -----Output----- Print the total number of people the restaurant denies service to. -----Examples----- Input 4 1 2 1 2 1 1 Output 0 Input 4 1 1 1 1 2 1 Output 2 -----Note----- In the first example the first group consists of one person, it is seated at a vacant one-seater table. The next group occupies a whole two-seater table. The third group consists of one person, it occupies one place at the remaining two-seater table. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, all clients are served. In the second example the first group consists of one person, it is seated at the vacant one-seater table. The next group consists of one person, it occupies one place at the two-seater table. It's impossible to seat the next group of two people, so the restaurant denies service to them. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, the restaurant denies service to 2 clients. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Given an array (or list) of scores, return the array of _ranks_ for each value in the array. The largest value has rank 1, the second largest value has rank 2, and so on. Ties should be handled by assigning the same rank to all tied values. For example: ranks([9,3,6,10]) = [2,4,3,1] and ranks([3,3,3,3,3,5,1]) = [2,2,2,2,2,1,7] because there is one 1st place value, a five-way tie for 2nd place, and one in 7th place. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions? Input There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105. Output Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings. Examples Input ab bc cd Output 4 Input abacaba abaaba x Output 11 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya has found a piece of paper with a coordinate system written on it. There are n distinct squares drawn in this coordinate system. Let's number the squares with integers from 1 to n. It turned out that points with coordinates (0, 0) and (ai, ai) are the opposite corners of the i-th square. Vasya wants to find such integer point (with integer coordinates) of the plane, that belongs to exactly k drawn squares. We'll say that a point belongs to a square, if the point is located either inside the square, or on its boundary. Help Vasya find a point that would meet the described limits. Input The first line contains two space-separated integers n, k (1 ≤ n, k ≤ 50). The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109). It is guaranteed that all given squares are distinct. Output In a single line print two space-separated integers x and y (0 ≤ x, y ≤ 109) — the coordinates of the point that belongs to exactly k squares. If there are multiple answers, you are allowed to print any of them. If there is no answer, print "-1" (without the quotes). Examples Input 4 3 5 1 3 4 Output 2 1 Input 3 1 2 4 1 Output 4 0 Input 4 50 5 1 10 2 Output -1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Nauuo is a girl who loves playing cards. One day she was playing cards but found that the cards were mixed with some empty ones. There are $n$ cards numbered from $1$ to $n$, and they were mixed with another $n$ empty cards. She piled up the $2n$ cards and drew $n$ of them. The $n$ cards in Nauuo's hands are given. The remaining $n$ cards in the pile are also given in the order from top to bottom. In one operation she can choose a card in her hands and play it — put it at the bottom of the pile, then draw the top card from the pile. Nauuo wants to make the $n$ numbered cards piled up in increasing order (the $i$-th card in the pile from top to bottom is the card $i$) as quickly as possible. Can you tell her the minimum number of operations? -----Input----- The first line contains a single integer $n$ ($1\le n\le 2\cdot 10^5$) — the number of numbered cards. The second line contains $n$ integers $a_1,a_2,\ldots,a_n$ ($0\le a_i\le n$) — the initial cards in Nauuo's hands. $0$ represents an empty card. The third line contains $n$ integers $b_1,b_2,\ldots,b_n$ ($0\le b_i\le n$) — the initial cards in the pile, given in order from top to bottom. $0$ represents an empty card. It is guaranteed that each number from $1$ to $n$ appears exactly once, either in $a_{1..n}$ or $b_{1..n}$. -----Output----- The output contains a single integer — the minimum number of operations to make the $n$ numbered cards piled up in increasing order. -----Examples----- Input 3 0 2 0 3 0 1 Output 2 Input 3 0 2 0 1 0 3 Output 4 Input 11 0 0 0 5 0 0 0 4 0 0 11 9 2 6 0 8 1 7 0 3 0 10 Output 18 -----Note----- Example 1 We can play the card $2$ and draw the card $3$ in the first operation. After that, we have $[0,3,0]$ in hands and the cards in the pile are $[0,1,2]$ from top to bottom. Then, we play the card $3$ in the second operation. The cards in the pile are $[1,2,3]$, in which the cards are piled up in increasing order. Example 2 Play an empty card and draw the card $1$, then play $1$, $2$, $3$ in order. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Write a function that accepts two arguments: an array/list of integers and another integer (`n`). Determine the number of times where two integers in the array have a difference of `n`. For example: ``` [1, 1, 5, 6, 9, 16, 27], n=4 --> 3 # (1,5), (1,5), (5,9) [1, 1, 3, 3], n=2 --> 4 # (1,3), (1,3), (1,3), (1,3) ``` Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. At the start of each season, every player in a football team is assigned their own unique squad number. Due to superstition or their history certain numbers are more desirable than others. Write a function generateNumber() that takes two arguments, an array of the current squad numbers (squad) and the new player's desired number (n). If the new player's desired number is not already taken, return n, else if the desired number can be formed by adding two digits between 1 and 9, return the number formed by joining these two digits together. E.g. If 2 is taken, return 11 because 1 + 1 = 2. Otherwise return null. Note: Often there will be several different ways to form a replacement number. In these cases the number with lowest first digit should be given priority. E.g. If n = 15, but squad already contains 15, return 69, not 78. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ancient Egyptians are known to have understood difficult concepts in mathematics. The ancient Egyptian mathematician Ahmes liked to write a kind of arithmetic expressions on papyrus paper which he called as Ahmes arithmetic expression. An Ahmes arithmetic expression can be defined as: "d" is an Ahmes arithmetic expression, where d is a one-digit positive integer; "(E_1 op E_2)" is an Ahmes arithmetic expression, where E_1 and E_2 are valid Ahmes arithmetic expressions (without spaces) and op is either plus ( + ) or minus ( - ). For example 5, (1-1) and ((1+(2-3))-5) are valid Ahmes arithmetic expressions. On his trip to Egypt, Fafa found a piece of papyrus paper having one of these Ahmes arithmetic expressions written on it. Being very ancient, the papyrus piece was very worn out. As a result, all the operators were erased, keeping only the numbers and the brackets. Since Fafa loves mathematics, he decided to challenge himself with the following task: Given the number of plus and minus operators in the original expression, find out the maximum possible value for the expression on the papyrus paper after putting the plus and minus operators in the place of the original erased operators. -----Input----- The first line contains a string E (1 ≤ \|E\| ≤ 10^4) — a valid Ahmes arithmetic expression. All operators are erased and replaced with '?'. The second line contains two space-separated integers P and M (0 ≤ min(P, M) ≤ 100) — the number of plus and minus operators, respectively. It is guaranteed that P + M = the number of erased operators. -----Output----- Print one line containing the answer to the problem. -----Examples----- Input (1?1) 1 0 Output 2 Input (2?(1?2)) 1 1 Output 1 Input ((1?(5?7))?((6?2)?7)) 3 2 Output 18 Input ((1?(5?7))?((6?2)?7)) 2 3 Output 16 -----Note----- The first sample will be (1 + 1) = 2. The second sample will be (2 + (1 - 2)) = 1. The third sample will be ((1 - (5 - 7)) + ((6 + 2) + 7)) = 18. The fourth sample will be ((1 + (5 + 7)) - ((6 - 2) - 7)) = 16. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target. One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament. In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits. For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance. This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits. For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times. Input Multiple datasets are given as input. The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time. When n is 0, it indicates the end of input. Do not output to this input. Output For each dataset, print the total middle number on one line. Example Input 20 4 3 2 1 3 8 2 0 0 Output 13 2 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given n × m table. Each cell of the table is colored white or black. Find the number of non-empty sets of cells such that: All cells in a set have the same color. Every two cells in a set share row or column. -----Input----- The first line of input contains integers n and m (1 ≤ n, m ≤ 50) — the number of rows and the number of columns correspondingly. The next n lines of input contain descriptions of rows. There are m integers, separated by spaces, in each line. The number equals 0 if the corresponding cell is colored white and equals 1 if the corresponding cell is colored black. -----Output----- Output single integer — the number of non-empty sets from the problem description. -----Examples----- Input 1 1 0 Output 1 Input 2 3 1 0 1 0 1 0 Output 8 -----Note----- In the second example, there are six one-element sets. Additionally, there are two two-element sets, the first one consists of the first and the third cells of the first row, the second one consists of the first and the third cells of the second row. To sum up, there are 8 sets. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. We have a cord whose length is a positive integer. We will perform the following condition until the length of the cord becomes at most 2: * Operation: Cut the rope at two positions to obtain three cords, each with a length of a positive integer. Among these, discard one with the longest length and one with the shortest length, and keep the remaining one. Let f(N) be the maximum possible number of times to perform this operation, starting with a cord with the length N. You are given a positive integer X. Find the maximum integer N such that f(N)=X. Constraints * 1 \leq X \leq 40 Input The input is given from Standard Input in the following format: X Output Print the value of the maximum integer N such that f(N)=X. Example Input 2 Output 14 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. One day in the IT lesson Anna and Maria learned about the lexicographic order. String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(\|x\|, \|y\|)), that xi < yi, and for any j (1 ≤ j < i) xj = yj. Here \|a\| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages. The teacher gave Anna and Maria homework. She gave them a string of length n. They should write out all substrings of the given string, including the whole initial string, and the equal substrings (for example, one should write out the following substrings from the string "aab": "a", "a", "aa", "ab", "aab", "b"). The resulting strings should be sorted in the lexicographical order. The cunning teacher doesn't want to check all these strings. That's why she said to find only the k-th string from the list. Help Anna and Maria do the homework. Input The first line contains a non-empty string that only consists of small Latin letters ("a"-"z"), whose length does not exceed 105. The second line contains the only integer k (1 ≤ k ≤ 105). Output Print the string Anna and Maria need — the k-th (in the lexicographical order) substring of the given string. If the total number of substrings is less than k, print a string saying "No such line." (without the quotes). Examples Input aa 2 Output a Input abc 5 Output bc Input abab 7 Output b Note In the second sample before string "bc" follow strings "a", "ab", "abc", "b". Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The only difference between easy and hard versions is the length of the string. You are given a string $s$ and a string $t$, both consisting only of lowercase Latin letters. It is guaranteed that $t$ can be obtained from $s$ by removing some (possibly, zero) number of characters (not necessary contiguous) from $s$ without changing order of remaining characters (in other words, it is guaranteed that $t$ is a subsequence of $s$). For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test". You want to remove some substring (contiguous subsequence) from $s$ of maximum possible length such that after removing this substring $t$ will remain a subsequence of $s$. If you want to remove the substring $s[l;r]$ then the string $s$ will be transformed to $s_1 s_2 \dots s_{l-1} s_{r+1} s_{r+2} \dots s_{\|s\|-1} s_{\|s\|}$ (where $\|s\|$ is the length of $s$). Your task is to find the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$. -----Input----- The first line of the input contains one string $s$ consisting of at least $1$ and at most $200$ lowercase Latin letters. The second line of the input contains one string $t$ consisting of at least $1$ and at most $200$ lowercase Latin letters. It is guaranteed that $t$ is a subsequence of $s$. -----Output----- Print one integer — the maximum possible length of the substring you can remove so that $t$ is still a subsequence of $s$. -----Examples----- Input bbaba bb Output 3 Input baaba ab Output 2 Input abcde abcde Output 0 Input asdfasdf fasd Output 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A girl named Xenia has a cupboard that looks like an arc from ahead. The arc is made of a semicircle with radius r (the cupboard's top) and two walls of height h (the cupboard's sides). The cupboard's depth is r, that is, it looks like a rectangle with base r and height h + r from the sides. The figure below shows what the cupboard looks like (the front view is on the left, the side view is on the right). [Image] Xenia got lots of balloons for her birthday. The girl hates the mess, so she wants to store the balloons in the cupboard. Luckily, each balloon is a sphere with radius $\frac{r}{2}$. Help Xenia calculate the maximum number of balloons she can put in her cupboard. You can say that a balloon is in the cupboard if you can't see any part of the balloon on the left or right view. The balloons in the cupboard can touch each other. It is not allowed to squeeze the balloons or deform them in any way. You can assume that the cupboard's walls are negligibly thin. -----Input----- The single line contains two integers r, h (1 ≤ r, h ≤ 10^7). -----Output----- Print a single integer — the maximum number of balloons Xenia can put in the cupboard. -----Examples----- Input 1 1 Output 3 Input 1 2 Output 5 Input 2 1 Output 2 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Nathan O. Davis is challenging a kind of shooter game. In this game, enemies emit laser beams from outside of the screen. A laser beam is a straight line with a certain thickness. Nathan moves a circular-shaped machine within the screen, in such a way it does not overlap a laser beam. As in many shooters, the machine is destroyed when the overlap happens. Nathan is facing an uphill stage. Many enemies attack simultaneously in this stage, so eventually laser beams fill out almost all of the screen. Surprisingly, it is even possible he has no "safe area" on the screen. In other words, the machine cannot survive wherever it is located in some cases. The world is as kind as it is cruel! There is a special item that helps the machine to survive any dangerous situation, even if it is exposed in a shower of laser beams, for some seconds. In addition, another straight line (called "a warning line") is drawn on the screen for a few seconds before a laser beam is emit along that line. The only problem is that Nathan has a little slow reflexes. He often messes up the timing to use the special item. But he knows a good person who can write a program to make up his slow reflexes - it's you! So he asked you for help. Your task is to write a program to make judgement whether he should use the item or not, for given warning lines and the radius of the machine. Input The input is a sequence of datasets. Each dataset corresponds to one situation with warning lines in the following format: W H N R x1,1 y1,1 x1,2 y1,2 t1 x2,1 y2,1 x2,2 y2,2 t2 ... xN,1 yN,1 xN,2 yN,2 tN The first line of a dataset contains four integers W, H, N and R (2 < W ≤ 640, 2 < H ≤ 480, 0 ≤ N ≤ 100 and 0 < R < min{W, H}/2). The first two integers W and H indicate the width and height of the screen, respectively. The next integer N represents the number of laser beams. The last integer R indicates the radius of the machine. It is guaranteed that the output would remain unchanged if the radius of the machine would become larger by 10-5 than R. The following N lines describe the N warning lines. The (i+1)-th line of the dataset corresponds to the i-th warning line, which is represented as a straight line which passes through two given different coordinates (xi,1, yi,1 ) and (xi,2 , yi,2 ). The last integer ti indicates the thickness of the laser beam corresponding to the i-th warning line. All given coordinates (x, y) on the screen are a pair of integers (0 ≤ x ≤ W, 0 ≤ y ≤ H). Note that, however, the machine is allowed to be located at non-integer coordinates during the play. The input is terminated by a line with four zeros. This line should not be processed. Output For each case, print "Yes" in a line if there is a safe area, or print "No" otherwise. Example Input 100 100 1 1 50 0 50 100 50 640 480 1 1 0 0 640 480 100 0 0 0 0 Output No Yes Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Today on Informatics class Nastya learned about GCD and LCM (see links below). Nastya is very intelligent, so she solved all the tasks momentarily and now suggests you to solve one of them as well. We define a pair of integers (a, b) good, if GCD(a, b) = x and LCM(a, b) = y, where GCD(a, b) denotes the greatest common divisor of a and b, and LCM(a, b) denotes the least common multiple of a and b. You are given two integers x and y. You are to find the number of good pairs of integers (a, b) such that l ≤ a, b ≤ r. Note that pairs (a, b) and (b, a) are considered different if a ≠ b. -----Input----- The only line contains four integers l, r, x, y (1 ≤ l ≤ r ≤ 10^9, 1 ≤ x ≤ y ≤ 10^9). -----Output----- In the only line print the only integer — the answer for the problem. -----Examples----- Input 1 2 1 2 Output 2 Input 1 12 1 12 Output 4 Input 50 100 3 30 Output 0 -----Note----- In the first example there are two suitable good pairs of integers (a, b): (1, 2) and (2, 1). In the second example there are four suitable good pairs of integers (a, b): (1, 12), (12, 1), (3, 4) and (4, 3). In the third example there are good pairs of integers, for example, (3, 30), but none of them fits the condition l ≤ a, b ≤ r. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm: Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). Digits are written one by one in order corresponding to number and separated by single '0' character. Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number. -----Input----- The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s. The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 10^9. The string always starts with '1'. -----Output----- Print the decoded number. -----Examples----- Input 3 111 Output 3 Input 9 110011101 Output 2031 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n stones arranged on an axis. Initially the i-th stone is located at the coordinate s_i. There may be more than one stone in a single place. You can perform zero or more operations of the following type: * take two stones with indices i and j so that s_i ≤ s_j, choose an integer d (0 ≤ 2 ⋅ d ≤ s_j - s_i), and replace the coordinate s_i with (s_i + d) and replace coordinate s_j with (s_j - d). In other words, draw stones closer to each other. You want to move the stones so that they are located at positions t_1, t_2, …, t_n. The order of the stones is not important — you just want for the multiset of the stones resulting positions to be the same as the multiset of t_1, t_2, …, t_n. Detect whether it is possible to move the stones this way, and if yes, construct a way to do so. You don't need to minimize the number of moves. Input The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) – the number of stones. The second line contains integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^9) — the initial positions of the stones. The second line contains integers t_1, t_2, …, t_n (1 ≤ t_i ≤ 10^9) — the target positions of the stones. Output If it is impossible to move the stones this way, print "NO". Otherwise, on the first line print "YES", on the second line print the number of operations m (0 ≤ m ≤ 5 ⋅ n) required. You don't have to minimize the number of operations. Then print m lines, each containing integers i, j, d (1 ≤ i, j ≤ n, s_i ≤ s_j, 0 ≤ 2 ⋅ d ≤ s_j - s_i), defining the operations. One can show that if an answer exists, there is an answer requiring no more than 5 ⋅ n operations. Examples Input 5 2 2 7 4 9 5 4 5 5 5 Output YES 4 4 3 1 2 3 1 2 5 2 1 5 2 Input 3 1 5 10 3 5 7 Output NO Note Consider the first example. * After the first move the locations of stones is [2, 2, 6, 5, 9]. * After the second move the locations of stones is [2, 3, 5, 5, 9]. * After the third move the locations of stones is [2, 5, 5, 5, 7]. * After the last move the locations of stones is [4, 5, 5, 5, 5]. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You and your best friend Stripes have just landed your first high school jobs! You'll be delivering newspapers to your neighbourhood on weekends. For your services you'll be charging a set price depending on the quantity of the newspaper bundles. The cost of deliveries is: - $3.85 for 40 newspapers - $1.93 for 20 - $0.97 for 10 - $0.49 for 5 - $0.10 for 1 Stripes is taking care of the footwork doing door-to-door drops and your job is to take care of the finances. What you'll be doing is providing the cheapest possible quotes for your services. Write a function that's passed an integer representing the amount of newspapers and returns the cheapest price. The returned number must be rounded to two decimal places. ![Paperboy](http://mametesters.org/file_download.php?file_id=1016&type=bug) Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Let's call the set of positive integers $S$ correct if the following two conditions are met: $S \subseteq \{1, 2, \dots, n\}$; if $a \in S$ and $b \in S$, then $\|a-b\| \neq x$ and $\|a-b\| \neq y$. For the given values $n$, $x$, and $y$, you have to find the maximum size of the correct set. -----Input----- A single line contains three integers $n$, $x$ and $y$ ($1 \le n \le 10^9$; $1 \le x, y \le 22$). -----Output----- Print one integer — the maximum size of the correct set. -----Examples----- Input 10 2 5 Output 5 Input 21 4 6 Output 9 Input 1337 7 7 Output 672 Input 455678451 22 17 Output 221997195 -----Note----- None Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya trains to compose crossword puzzles. He can only compose crosswords of a very simplе type so far. All of them consist of exactly six words; the words can be read only from top to bottom vertically and from the left to the right horizontally. The words are arranged in the form of a rectangular "eight" or infinity sign, not necessarily symmetrical. The top-left corner of the crossword coincides with the top-left corner of the rectangle. The same thing is correct for the right-bottom corners. The crossword can't degrade, i.e. it always has exactly four blank areas, two of which are surrounded by letters. Look into the output for the samples for clarification. Help Vasya — compose a crossword of the described type using the given six words. It is allowed to use the words in any order. Input Six lines contain the given words. Every word consists of no more than 30 and no less than 3 uppercase Latin letters. Output If it is impossible to solve the problem, print Impossible. Otherwise, print the sought crossword. All the empty squares should be marked as dots. If there can be several solutions to that problem, print the lexicographically minimum one. I.e. the solution where the first line is less than the first line of other solutions should be printed. If the two lines are equal, compare the second lines and so on. The lexicographical comparison of lines is realized by the < operator in the modern programming languages. Examples Input NOD BAA YARD AIRWAY NEWTON BURN Output BAA... U.I... R.R... NEWTON ..A..O ..YARD Input AAA AAA AAAAA AAA AAA AAAAA Output AAA.. A.A.. AAAAA ..A.A ..AAA Input PTC JYNYFDSGI ZGPPC IXEJNDOP JJFS SSXXQOFGJUZ Output JJFS.... Y..S.... N..X.... Y..X.... F..Q.... D..O.... S..F.... G..G.... IXEJNDOP ...U...T ...ZGPPC Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is unrest in the Galactic Senate. Several thousand solar systems have declared their intentions to leave the Republic. Master Heidi needs to select the Jedi Knights who will go on peacekeeping missions throughout the galaxy. It is well-known that the success of any peacekeeping mission depends on the colors of the lightsabers of the Jedi who will go on that mission. Heidi has n Jedi Knights standing in front of her, each one with a lightsaber of one of m possible colors. She knows that for the mission to be the most effective, she needs to select some contiguous interval of knights such that there are exactly k_1 knights with lightsabers of the first color, k_2 knights with lightsabers of the second color, ..., k_{m} knights with lightsabers of the m-th color. Help her find out if this is possible. -----Input----- The first line of the input contains n (1 ≤ n ≤ 100) and m (1 ≤ m ≤ n). The second line contains n integers in the range {1, 2, ..., m} representing colors of the lightsabers of the subsequent Jedi Knights. The third line contains m integers k_1, k_2, ..., k_{m} (with $1 \leq \sum_{i = 1}^{m} k_{i} \leq n$) – the desired counts of lightsabers of each color from 1 to m. -----Output----- Output YES if an interval with prescribed color counts exists, or output NO if there is none. -----Example----- Input 5 2 1 1 2 2 1 1 2 Output YES Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Everybody knows what an arithmetic progression is. Let us remind you just in case that an arithmetic progression is such sequence of numbers a_1, a_2, ..., a_{n} of length n, that the following condition fulfills: a_2 - a_1 = a_3 - a_2 = a_4 - a_3 = ... = a_{i} + 1 - a_{i} = ... = a_{n} - a_{n} - 1. For example, sequences [1, 5], [10], [5, 4, 3] are arithmetic progressions and sequences [1, 3, 2], [1, 2, 4] are not. Alexander has n cards containing integers. Arthur wants to give Alexander exactly one more card with a number so that he could use the resulting n + 1 cards to make an arithmetic progression (Alexander has to use all of his cards). Arthur has already bought a card but he hasn't written a number on it. Help him, print all integers that you can write on a card so that the described condition fulfilled. -----Input----- The first line contains integer n (1 ≤ n ≤ 10^5) — the number of cards. The next line contains the sequence of integers — the numbers on Alexander's cards. The numbers are positive integers, each of them doesn't exceed 10^8. -----Output----- If Arthur can write infinitely many distinct integers on the card, print on a single line -1. Otherwise, print on the first line the number of integers that suit you. In the second line, print the numbers in the increasing order. Note that the numbers in the answer can exceed 10^8 or even be negative (see test samples). -----Examples----- Input 3 4 1 7 Output 2 -2 10 Input 1 10 Output -1 Input 4 1 3 5 9 Output 1 7 Input 4 4 3 4 5 Output 0 Input 2 2 4 Output 3 0 3 6 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are n walruses standing in a queue in an airport. They are numbered starting from the queue's tail: the 1-st walrus stands at the end of the queue and the n-th walrus stands at the beginning of the queue. The i-th walrus has the age equal to ai. The i-th walrus becomes displeased if there's a younger walrus standing in front of him, that is, if exists such j (i < j), that ai > aj. The displeasure of the i-th walrus is equal to the number of walruses between him and the furthest walrus ahead of him, which is younger than the i-th one. That is, the further that young walrus stands from him, the stronger the displeasure is. The airport manager asked you to count for each of n walruses in the queue his displeasure. Input The first line contains an integer n (2 ≤ n ≤ 105) — the number of walruses in the queue. The second line contains integers ai (1 ≤ ai ≤ 109). Note that some walruses can have the same age but for the displeasure to emerge the walrus that is closer to the head of the queue needs to be strictly younger than the other one. Output Print n numbers: if the i-th walrus is pleased with everything, print "-1" (without the quotes). Otherwise, print the i-th walrus's displeasure: the number of other walruses that stand between him and the furthest from him younger walrus. Examples Input 6 10 8 5 3 50 45 Output 2 1 0 -1 0 -1 Input 7 10 4 6 3 2 8 15 Output 4 2 1 0 -1 -1 -1 Input 5 10 3 1 10 11 Output 1 0 -1 -1 -1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well. Today's training is to perform a very large number of calculations to improve the calculation power and raise awareness. Exponentiation is an operation that easily produces large numbers. There are N non-negative integers A1, A2, ..., AN. We would like to find the sorts B1, B2, ..., BN that maximize B1B2 ... BN -1BN. Of course, it is common sense for rabbits, but this calculation is performed in order from the upper right. We also promise that 00 = 1. There may be multiple types of B1, B2, ..., and BN that satisfy the maximum conditions. In such a case, let's choose the smallest column in the dictionary order. Input N A1 ... AN Satisfy 1 ≤ N ≤ 100, 0 ≤ Ai ≤ 1,000,000,000. Output The output consists of N lines. Output Bi on line i. Examples Input 4 7 5 10 6 Output 5 6 7 10 Input 3 0 0 1000000000 Output 1000000000 0 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Two tortoises named *A* and *B* must run a race. *A* starts with an average speed of ```720 feet per hour```. Young *B* knows she runs faster than *A, and furthermore has not finished her cabbage. When she starts, at last, she can see that A* has a `70 feet lead` but *B's speed is `850 feet per hour`. How long will it take B* to catch *A? More generally: given two speeds `v1` (A's speed, integer > 0) and `v2` (B's speed, integer > 0) and a lead `g` (integer > 0) how long will it take B* to catch *A? The result will be an array ```[hour, min, sec]``` which is the time needed in hours, minutes and seconds (round down to the nearest second) or a string in some languages. If `v1 >= v2` then return `nil`, `nothing`, `null`, `None` or `{-1, -1, -1}` for C++, C, Go, Nim, `[]` for Kotlin or "-1 -1 -1". ## Examples: (form of the result depends on the language) ``` race(720, 850, 70) => [0, 32, 18] or "0 32 18" race(80, 91, 37) => [3, 21, 49] or "3 21 49" ``` * Note: - See other examples in "Your test cases". - In Fortran - as in any other language - the returned string is not permitted to contain any redundant trailing whitespace: you can use dynamically allocated character strings. ** Hints for people who don't know how to convert to hours, minutes, seconds: - Tortoises don't care about fractions of seconds - Think of calculation by hand using only integers (in your code use or simulate integer division) - or Google: "convert decimal time to hours minutes seconds" Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Given are integer sequences A and B of length 3N. Each of these two sequences contains three copies of each of 1, 2, \dots, N. In other words, A and B are both arrangements of (1, 1, 1, 2, 2, 2, \dots, N, N, N). Tak can perform the following operation to the sequence A arbitrarily many times: * Pick a value from 1, 2, \dots, N and call it x. A contains exactly three copies of x. Remove the middle element of these three. After that, append x to the beginning or the end of A. Check if he can turn A into B. If he can, print the minimum required number of operations to achieve that. Constraints * 1 \leq N \leq 33 * A and B are both arrangements of (1, 1, 1, 2, 2, 2, \dots, N, N, N). * All values in input are integers. Input Input is given from Standard Input in the following format: N A_1 A_2 ... A_{3N} B_1 B_2 ... B_{3N} Output If Tak can turn A into B, print the minimum required number of operations to achieve that. Otherwise, print -1. Examples Input 3 2 3 1 1 3 2 2 1 3 1 2 2 3 1 2 3 1 3 Output 4 Input 3 1 1 1 2 2 2 3 3 3 1 1 1 2 2 2 3 3 3 Output 0 Input 3 2 3 3 1 1 1 2 2 3 3 2 2 1 1 1 3 3 2 Output -1 Input 8 3 6 7 5 4 8 4 1 1 3 8 7 3 8 2 4 7 5 2 2 6 5 6 1 7 5 8 1 3 6 7 5 4 8 1 3 3 8 2 4 2 6 5 6 1 4 7 2 Output 7 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are $n$ districts in the town, the $i$-th district belongs to the $a_i$-th bandit gang. Initially, no districts are connected to each other. You are the mayor of the city and want to build $n-1$ two-way roads to connect all districts (two districts can be connected directly or through other connected districts). If two districts belonging to the same gang are connected directly with a road, this gang will revolt. You don't want this so your task is to build $n-1$ two-way roads in such a way that all districts are reachable from each other (possibly, using intermediate districts) and each pair of directly connected districts belong to different gangs, or determine that it is impossible to build $n-1$ roads to satisfy all the conditions. You have to answer $t$ independent test cases. -----Input----- The first line of the input contains one integer $t$ ($1 \le t \le 500$) — the number of test cases. Then $t$ test cases follow. The first line of the test case contains one integer $n$ ($2 \le n \le 5000$) — the number of districts. The second line of the test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the gang the $i$-th district belongs to. It is guaranteed that the sum of $n$ does not exceed $5000$ ($\sum n \le 5000$). -----Output----- For each test case, print: NO on the only line if it is impossible to connect all districts satisfying the conditions from the problem statement. YES on the first line and $n-1$ roads on the next $n-1$ lines. Each road should be presented as a pair of integers $x_i$ and $y_i$ ($1 \le x_i, y_i \le n; x_i \ne y_i$), where $x_i$ and $y_i$ are two districts the $i$-th road connects. For each road $i$, the condition $a[x_i] \ne a[y_i]$ should be satisfied. Also, all districts should be reachable from each other (possibly, using intermediate districts). -----Example----- Input 4 5 1 2 2 1 3 3 1 1 1 4 1 1000 101 1000 4 1 2 3 4 Output YES 1 3 3 5 5 4 1 2 NO YES 1 2 2 3 3 4 YES 1 2 1 3 1 4 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. For a non-negative integer N, define S(N) as the sum of the odd digits of N plus twice the sum of the even digits of N. For example, S(5)=5, S(456)=24+5+26=25, and S(314159)=3+1+2*4+1+5+9=27. Define D(N) as the last digit of S(N). So D(5)=5, D(456)=5, and D(314159)=7. Given 2 non-negative integers A and B, compute the sum of D(N) over all N between A and B, inclusive. ------ Input ------ Input will begin with an integer T, the number of test cases. T lines follow, each containing 2 integers A and B. ------ Output ------ For each test case, output a single integer indicating the corresponding sum. ------ Constraints ------ $T ≤ 1000$ $0 ≤ A ≤ B ≤ 400,000,000$ ----- Sample Input 1 ------ 3 1 8 28 138 314159 314159 ----- Sample Output 1 ------ 36 495 7 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. It is a holiday season, and Koala is decorating his house with cool lights! He owns $n$ lights, all of which flash periodically. After taking a quick glance at them, Koala realizes that each of his lights can be described with two parameters $a_i$ and $b_i$. Light with parameters $a_i$ and $b_i$ will toggle (on to off, or off to on) every $a_i$ seconds starting from the $b_i$-th second. In other words, it will toggle at the moments $b_i$, $b_i + a_i$, $b_i + 2 \cdot a_i$ and so on. You know for each light whether it's initially on or off and its corresponding parameters $a_i$ and $b_i$. Koala is wondering what is the maximum number of lights that will ever be on at the same time. So you need to find that out. [Image] Here is a graphic for the first example. -----Input----- The first line contains a single integer $n$ ($1 \le n \le 100$), the number of lights. The next line contains a string $s$ of $n$ characters. The $i$-th character is "1", if the $i$-th lamp is initially on. Otherwise, $i$-th character is "0". The $i$-th of the following $n$ lines contains two integers $a_i$ and $b_i$ ($1 \le a_i, b_i \le 5$) — the parameters of the $i$-th light. -----Output----- Print a single integer — the maximum number of lights that will ever be on at the same time. -----Examples----- Input 3 101 3 3 3 2 3 1 Output 2 Input 4 1111 3 4 5 2 3 1 3 2 Output 4 Input 6 011100 5 3 5 5 2 4 3 5 4 2 1 5 Output 6 -----Note----- For first example, the lamps' states are shown in the picture above. The largest number of simultaneously on lamps is $2$ (e.g. at the moment $2$). In the second example, all lights are initially on. So the answer is $4$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi has many red balls and blue balls. Now, he will place them in a row. Initially, there is no ball placed. Takahashi, who is very patient, will do the following operation 10^{100} times: - Place A blue balls at the end of the row of balls already placed. Then, place B red balls at the end of the row. How many blue balls will be there among the first N balls in the row of balls made this way? -----Constraints----- - 1 \leq N \leq 10^{18} - A, B \geq 0 - 0 < A + B \leq 10^{18} - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: N A B -----Output----- Print the number of blue balls that will be there among the first N balls in the row of balls. -----Sample Input----- 8 3 4 -----Sample Output----- 4 Let b denote a blue ball, and r denote a red ball. The first eight balls in the row will be bbbrrrrb, among which there are four blue balls. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A ski base is planned to be built in Walrusland. Recently, however, the project is still in the constructing phase. A large land lot was chosen for the construction. It contains n ski junctions, numbered from 1 to n. Initially the junctions aren't connected in any way. In the constructing process m bidirectional ski roads will be built. The roads are built one after another: first the road number 1 will be built, then the road number 2, and so on. The i-th road connects the junctions with numbers ai and bi. Track is the route with the following properties: * The route is closed, that is, it begins and ends in one and the same junction. * The route contains at least one road. * The route doesn't go on one road more than once, however it can visit any junction any number of times. Let's consider the ski base as a non-empty set of roads that can be divided into one or more tracks so that exactly one track went along each road of the chosen set. Besides, each track can consist only of roads from the chosen set. Ski base doesn't have to be connected. Two ski bases are considered different if they consist of different road sets. After building each new road the Walrusland government wants to know the number of variants of choosing a ski base based on some subset of the already built roads. The government asks you to help them solve the given problem. Input The first line contains two integers n and m (2 ≤ n ≤ 105, 1 ≤ m ≤ 105). They represent the number of junctions and the number of roads correspondingly. Then on m lines follows the description of the roads in the order in which they were built. Each road is described by a pair of integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) — the numbers of the connected junctions. There could be more than one road between a pair of junctions. Output Print m lines: the i-th line should represent the number of ways to build a ski base after the end of construction of the road number i. The numbers should be printed modulo 1000000009 (109 + 9). Examples Input 3 4 1 3 2 3 1 2 1 2 Output 0 0 1 3 Note Let us have 3 junctions and 4 roads between the junctions have already been built (as after building all the roads in the sample): 1 and 3, 2 and 3, 2 roads between junctions 1 and 2. The land lot for the construction will look like this: <image> The land lot for the construction will look in the following way: <image> We can choose a subset of roads in three ways: <image> In the first and the second ways you can choose one path, for example, 1 - 2 - 3 - 1. In the first case you can choose one path 1 - 2 - 1. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Ibis is fighting with a monster. The health of the monster is H. Ibis can cast N kinds of spells. Casting the i-th spell decreases the monster's health by A_i, at the cost of B_i Magic Points. The same spell can be cast multiple times. There is no way other than spells to decrease the monster's health. Ibis wins when the health of the monster becomes 0 or below. Find the minimum total Magic Points that have to be consumed before winning. -----Constraints----- - 1 \leq H \leq 10^4 - 1 \leq N \leq 10^3 - 1 \leq A_i \leq 10^4 - 1 \leq B_i \leq 10^4 - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: H N A_1 B_1 : A_N B_N -----Output----- Print the minimum total Magic Points that have to be consumed before winning. -----Sample Input----- 9 3 8 3 4 2 2 1 -----Sample Output----- 4 First, let us cast the first spell to decrease the monster's health by 8, at the cost of 3 Magic Points. The monster's health is now 1. Then, cast the third spell to decrease the monster's health by 2, at the cost of 1 Magic Point. The monster's health is now -1. In this way, we can win at the total cost of 4 Magic Points. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Making Change Complete the method that will determine the minimum number of coins needed to make change for a given amount in American currency. Coins used will be half-dollars, quarters, dimes, nickels, and pennies, worth 50¢, 25¢, 10¢, 5¢ and 1¢, respectively. They'll be represented by the symbols `H`, `Q`, `D`, `N` and `P` (symbols in Ruby, strings in in other languages) The argument passed in will be an integer representing the value in cents. The return value should be a hash/dictionary/object with the symbols as keys, and the numbers of coins as values. Coins that are not used should not be included in the hash. If the argument passed in is 0, then the method should return an empty hash. ## Examples ```python make_change(0) #--> {} make_change(1) #--> {"P":1} make_change(43) #--> {"Q":1, "D":1, "N":1, "P":3} make_change(91) #--> {"H":1, "Q":1, "D":1, "N":1, "P":1} ``` #### If you liked this kata, check out [Part 2](https://www.codewars.com/kata/making-change-part-2/ruby). Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Write a program which reverses a given string str. Input str (the size of str ≤ 20) is given in a line. Output Print the reversed str in a line. Example Input w32nimda Output admin23w Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Joe has been hurt on the Internet. Now he is storming around the house, destroying everything in his path. Joe's house has n floors, each floor is a segment of m cells. Each cell either contains nothing (it is an empty cell), or has a brick or a concrete wall (always something one of three). It is believed that each floor is surrounded by a concrete wall on the left and on the right. Now Joe is on the n-th floor and in the first cell, counting from left to right. At each moment of time, Joe has the direction of his gaze, to the right or to the left (always one direction of the two). Initially, Joe looks to the right. Joe moves by a particular algorithm. Every second he makes one of the following actions: If the cell directly under Joe is empty, then Joe falls down. That is, he moves to this cell, the gaze direction is preserved. Otherwise consider the next cell in the current direction of the gaze. If the cell is empty, then Joe moves into it, the gaze direction is preserved. If this cell has bricks, then Joe breaks them with his forehead (the cell becomes empty), and changes the direction of his gaze to the opposite. If this cell has a concrete wall, then Joe just changes the direction of his gaze to the opposite (concrete can withstand any number of forehead hits). Joe calms down as soon as he reaches any cell of the first floor. The figure below shows an example Joe's movements around the house. [Image] Determine how many seconds Joe will need to calm down. -----Input----- The first line contains two integers n and m (2 ≤ n ≤ 100, 1 ≤ m ≤ 10^4). Next n lines contain the description of Joe's house. The i-th of these lines contains the description of the (n - i + 1)-th floor of the house — a line that consists of m characters: "." means an empty cell, "+" means bricks and "#" means a concrete wall. It is guaranteed that the first cell of the n-th floor is empty. -----Output----- Print a single number — the number of seconds Joe needs to reach the first floor; or else, print word "Never" (without the quotes), if it can never happen. Please, do not use 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 3 5 ..+.# #+..+ +.#+. Output 14 Input 4 10 ...+.##+.+ +#++..+++# ++.#++++.. .+##.++#.+ Output 42 Input 2 2 .. ++ Output Never Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are $n + 2$ towns located on a coordinate line, numbered from $0$ to $n + 1$. The $i$-th town is located at the point $i$. You build a radio tower in each of the towns $1, 2, \dots, n$ with probability $\frac{1}{2}$ (these events are independent). After that, you want to set the signal power on each tower to some integer from $1$ to $n$ (signal powers are not necessarily the same, but also not necessarily different). The signal from a tower located in a town $i$ with signal power $p$ reaches every city $c$ such that $\|c - i\| < p$. After building the towers, you want to choose signal powers in such a way that: towns $0$ and $n + 1$ don't get any signal from the radio towers; towns $1, 2, \dots, n$ get signal from exactly one radio tower each. For example, if $n = 5$, and you have built the towers in towns $2$, $4$ and $5$, you may set the signal power of the tower in town $2$ to $2$, and the signal power of the towers in towns $4$ and $5$ to $1$. That way, towns $0$ and $n + 1$ don't get the signal from any tower, towns $1$, $2$ and $3$ get the signal from the tower in town $2$, town $4$ gets the signal from the tower in town $4$, and town $5$ gets the signal from the tower in town $5$. Calculate the probability that, after building the towers, you will have a way to set signal powers to meet all constraints. -----Input----- The first (and only) line of the input contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$). -----Output----- Print one integer — the probability that there will be a way to set signal powers so that all constraints are met, taken modulo $998244353$. Formally, the probability can be expressed as an irreducible fraction $\frac{x}{y}$. You have to print the value of $x \cdot y^{-1} mod 998244353$, where $y^{-1}$ is an integer such that $y \cdot y^{-1} mod 998244353 = 1$. -----Examples----- Input 2 Output 748683265 Input 3 Output 748683265 Input 5 Output 842268673 Input 200000 Output 202370013 -----Note----- The real answer for the first example is $\frac{1}{4}$: with probability $\frac{1}{4}$, the towers are built in both towns $1$ and $2$, so we can set their signal powers to $1$. The real answer for the second example is $\frac{1}{4}$: with probability $\frac{1}{8}$, the towers are built in towns $1$, $2$ and $3$, so we can set their signal powers to $1$; with probability $\frac{1}{8}$, only one tower in town $2$ is built, and we can set its signal power to $2$. The real answer for the third example is $\frac{5}{32}$. Note that even though the previous explanations used equal signal powers for all towers, it is not necessarily so. For example, if $n = 5$ and the towers are built in towns $2$, $4$ and $5$, you may set the signal power of the tower in town $2$ to $2$, and the signal power of the towers in towns $4$ and $5$ to $1$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Introduction It's been more than 20 minutes since the negligent waiter has taken your order for the house special prime tofu steak with a side of chili fries. Out of boredom, you start fiddling around with the condiments tray. To be efficient, you want to be familiar with the choice of sauces and spices before your order is finally served. You also examine the toothpick holder and try to analyze its inner workings when - yikes - the holder's lid falls off and all 23 picks lay scattered on the table. Being a good and hygiene oriented citizen, you decide not to just put them back in the holder. Instead of letting all the good wood go to waste, you start playing around with the picks. In the first "round", you lay down one toothpick vertically. You've used a total of one toothpick. In the second "round", at each end of the first toothpick, you add a perpendicular toothpick at its center point. You added two additional toothpicks for a total of three toothpicks. In the next rounds, you continue to add perpendicular toothpicks to each free end of toothpicks already on the table. With your 23 toothpicks, you can complete a total of six rounds: You wonder if you'd be able to implement this sequence in your favorite programming language. Because your food still hasn't arrived, you decide to take out your laptop and start implementing... Challenge Implement a script that returns the amount of toothpicks needed to complete n amount of rounds of the toothpick sequence. ``` 0 <= n <= 5000 ``` Hint You can attempt this brute force or get some inspiration from the math department. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A sequence a=\{a_1,a_2,a_3,......\} is determined as follows: - The first term s is given as input. - Let f(n) be the following function: f(n) = n/2 if n is even, and f(n) = 3n+1 if n is odd. - a_i = s when i = 1, and a_i = f(a_{i-1}) when i > 1. Find the minimum integer m that satisfies the following condition: - There exists an integer n such that a_m = a_n (m > n). -----Constraints----- - 1 \leq s \leq 100 - All values in input are integers. - It is guaranteed that all elements in a and the minimum m that satisfies the condition are at most 1000000. -----Input----- Input is given from Standard Input in the following format: s -----Output----- Print the minimum integer m that satisfies the condition. -----Sample Input----- 8 -----Sample Output----- 5 a=\{8,4,2,1,4,2,1,4,2,1,......\}. As a_5=a_2, the answer is 5. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. At the beginning of the new semester there is new schedule in the Berland State University. According to this schedule, n groups have lessons at the room 31. For each group the starting time of the lesson and the finishing time of the lesson are known. It has turned out that it is impossible to hold all lessons, because for some groups periods of their lessons intersect. If at some moment of time one groups finishes it's lesson, and the other group starts the lesson, their lessons don't intersect. The dean wants to cancel the lesson in one group so that no two time periods of lessons of the remaining groups intersect. You are to find all ways to do that. Input The first line contains integer n (1 ≤ n ≤ 5000) — amount of groups, which have lessons in the room 31. Then n lines follow, each of them contains two integers li ri (1 ≤ li < ri ≤ 106) — starting and finishing times of lesson of the i-th group. It is possible that initially no two lessons intersect (see sample 1). Output Output integer k — amount of ways to cancel the lesson in exactly one group so that no two time periods of lessons of the remaining groups intersect. In the second line output k numbers — indexes of groups, where it is possible to cancel the lesson. Groups are numbered starting from 1 in the order that they were given in the input. Output the numbers in increasing order. Examples Input 3 3 10 20 30 1 3 Output 3 1 2 3 Input 4 3 10 20 30 1 3 1 39 Output 1 4 Input 3 1 5 2 6 3 7 Output 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given two strings x and y, both consist only of lowercase Latin letters. Let \|s\| be the length of string s. Let's call a sequence a a merging sequence if it consists of exactly \|x\| zeros and exactly \|y\| ones in some order. A merge z is produced from a sequence a by the following rules: * if a_i=0, then remove a letter from the beginning of x and append it to the end of z; * if a_i=1, then remove a letter from the beginning of y and append it to the end of z. Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i. Let's call a string z chaotic if for all i from 2 to \|z\| z_{i-1} ≠ z_i. Let s[l,r] for some 1 ≤ l ≤ r ≤ \|s\| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive. Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered. Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ \|x\| \\\ 1 ≤ l_2 ≤ r_2 ≤ \|y\|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353. Input The first line contains a string x (1 ≤ \|x\| ≤ 1000). The second line contains a string y (1 ≤ \|y\| ≤ 1000). Both strings consist only of lowercase Latin letters. Output Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ \|x\| and 1 ≤ l_2 ≤ r_2 ≤ \|y\| modulo 998 244 353. Examples Input aaa bb Output 24 Input code forces Output 1574 Input aaaaa aaa Output 0 Input justamassivetesttocheck howwellyouhandlemodulooperations Output 667387032 Note In the first example there are: * 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10"; * 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101"; * 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010"; * 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010"; * 2 pairs of substrings "aaa" and "b", each with no valid merging sequences; * 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010"; Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The educational program (AHK Education) of the Aiz Broadcasting Association broadcasts a handicraft program for children, "Play with Tsukuro". This time I will make a box with sticks, but I would like to see if I can make a rectangular parallelepiped using the 12 sticks I prepared. However, the stick must not be cut or broken. Given the lengths of the twelve bars, write a program to determine if you can create a rectangular parallelepiped with all of them as sides. Input The input is given in the following format. e1 e2 ... e12 The input consists of one line and is given the integer ei (1 ≤ ei ≤ 100) representing the length of each bar. Output If a rectangular parallelepiped can be created, "yes" is output, and if it cannot be created, "no" is output. However, since a cube is a kind of rectangular parallelepiped, "yes" is output even if it is a cube. Examples Input 1 1 3 4 8 9 7 3 4 5 5 5 Output no Input 1 1 2 2 3 1 2 3 3 3 1 2 Output yes Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Definition A number is a _Special Number_ if it’s digits only consist 0, 1, 2, 3, 4 or 5 _Given_ a number determine if it special number or not . # Warm-up (Highly recommended) # [Playing With Numbers Series](https://www.codewars.com/collections/playing-with-numbers) ___ # Notes * _The number_ passed will be _positive_ (N > 0) . * All single-digit numbers with in the interval _[0:5]_ are considered as _special number_. ___ # Input >> Output Examples ``` specialNumber(2) ==> return "Special!!" ``` ## Explanation: It's _a single-digit number_ within the interval _[0:5]_ . ``` specialNumber(9) ==> return "NOT!!" ``` ## Explanation: Although, it's a single-digit number but _Outside the interval [0:5]_ . ``` specialNumber(23) ==> return "Special!!" ``` ## Explanation: All _the number's digits_ formed from the interval _[0:5]_ digits . ``` specialNumber(39) ==> return "NOT!!" ``` ## Explanation: Although, there is a digit (3) Within the interval _But_ _the second digit is not (Must be ALL The Number's Digits )_ . ``` specialNumber(59) ==> return "NOT!!" ``` ## Explanation: Although, there is a digit (5) Within the interval _But_ _the second digit is not (Must be ALL The Number's Digits )_ . ``` specialNumber(513) ==> return "Special!!" ``` ___ ``` specialNumber(709) ==> return "NOT!!" ``` ___ # [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored) ### ALL translation are welcomed ## Enjoy Learning !! # Zizou Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a n × n grid D where each cell contains either 1 or 0. Your task is to create a program that takes the gird data as input and computes the greatest number of consecutive 1s in either vertical, horizontal, or diagonal direction. For example, the consecutive 1s with greatest number in the figure below is circled by the dashed-line. <image> The size of the grid n is an integer where 2 ≤ n ≤ 255. Input The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows: n D11 D12 ... D1n D21 D22 ... D2n . . Dn1 Dn2 ... Dnn Output For each dataset, print the greatest number of consecutive 1s. Example Input 5 00011 00101 01000 10101 00010 8 11000001 10110111 01100111 01111010 11111111 01011010 10100010 10000001 2 01 00 3 000 000 000 0 Output 4 8 1 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array $a$ consisting of $n$ positive integers. Initially, you have an integer $x = 0$. During one move, you can do one of the following two operations: Choose exactly one $i$ from $1$ to $n$ and increase $a_i$ by $x$ ($a_i := a_i + x$), then increase $x$ by $1$ ($x := x + 1$). Just increase $x$ by $1$ ($x := x + 1$). The first operation can be applied no more than once to each $i$ from $1$ to $n$. Your task is to find the minimum number of moves required to obtain such an array that each its element is divisible by $k$ (the value $k$ is given). You have to answer $t$ independent test cases. -----Input----- The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow. The first line of the test case contains two integers $n$ and $k$ ($1 \le n \le 2 \cdot 10^5; 1 \le k \le 10^9$) — the length of $a$ and the required divisior. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the $i$-th element of $a$. It is guaranteed that the sum of $n$ does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$). -----Output----- For each test case, print the answer — the minimum number of moves required to obtain such an array that each its element is divisible by $k$. -----Example----- Input 5 4 3 1 2 1 3 10 6 8 7 1 8 3 7 5 10 8 9 5 10 20 100 50 20 100500 10 25 24 24 24 24 24 24 24 24 24 24 8 8 1 2 3 4 5 6 7 8 Output 6 18 0 227 8 -----Note----- Consider the first test case of the example: $x=0$, $a = [1, 2, 1, 3]$. Just increase $x$; $x=1$, $a = [1, 2, 1, 3]$. Add $x$ to the second element and increase $x$; $x=2$, $a = [1, 3, 1, 3]$. Add $x$ to the third element and increase $x$; $x=3$, $a = [1, 3, 3, 3]$. Add $x$ to the fourth element and increase $x$; $x=4$, $a = [1, 3, 3, 6]$. Just increase $x$; $x=5$, $a = [1, 3, 3, 6]$. Add $x$ to the first element and increase $x$; $x=6$, $a = [6, 3, 3, 6]$. We obtained the required array. Note that you can't add $x$ to the same element more than once. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A queen is the strongest chess piece. In modern chess the queen can move any number of squares in any horizontal, vertical or diagonal direction (considering that there're no other pieces on its way). The queen combines the options given to the rook and the bishop. There are m queens on a square n × n chessboard. You know each queen's positions, the i-th queen is positioned in the square (ri, ci), where ri is the board row number (numbered from the top to the bottom from 1 to n), and ci is the board's column number (numbered from the left to the right from 1 to n). No two queens share the same position. For each queen one can count w — the number of other queens that the given queen threatens (attacks). For a fixed attack direction only the first queen in this direction is under attack if there are many queens are on the ray of the attack. Obviously, for any queen w is between 0 and 8, inclusive. Print the sequence t0, t1, ..., t8, where ti is the number of queens that threaten exactly i other queens, i.e. the number of queens that their w equals i. Input The first line of the input contains a pair of integers n, m (1 ≤ n, m ≤ 105), where n is the size of the board and m is the number of queens on the board. Then m following lines contain positions of the queens, one per line. Each line contains a pair of integers ri, ci (1 ≤ ri, ci ≤ n) — the queen's position. No two queens stand on the same square. Output Print the required sequence t0, t1, ..., t8, separating the numbers with spaces. Examples Input 8 4 4 3 4 8 6 5 1 6 Output 0 3 0 1 0 0 0 0 0 Input 10 3 1 1 1 2 1 3 Output 0 2 1 0 0 0 0 0 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. When new students come to the Specialized Educational and Scientific Centre (SESC) they need to start many things from the beginning. Sometimes the teachers say (not always unfairly) that we cannot even count. So our teachers decided to teach us arithmetics from the start. And what is the best way to teach students add and subtract? — That's right, using counting sticks! An here's our new task: An expression of counting sticks is an expression of type:[ A sticks][sign +][B sticks][sign =][C sticks] (1 ≤ A, B, C). Sign + consists of two crossed sticks: one vertical and one horizontal. Sign = consists of two horizontal sticks. The expression is arithmetically correct if A + B = C. We've got an expression that looks like A + B = C given by counting sticks. Our task is to shift at most one stick (or we can shift nothing) so that the expression became arithmetically correct. Note that we cannot remove the sticks from the expression, also we cannot shift the sticks from the signs + and =. We really aren't fabulous at arithmetics. Can you help us? -----Input----- The single line contains the initial expression. It is guaranteed that the expression looks like A + B = C, where 1 ≤ A, B, C ≤ 100. -----Output----- If there isn't a way to shift the stick so the expression becomes correct, print on a single line "Impossible" (without the quotes). If there is a way, print the resulting expression. Follow the format of the output from the test samples. Don't print extra space characters. If there are multiple correct answers, print any of them. For clarifications, you are recommended to see the test samples. -----Examples----- Input \|\|+\|=\|\|\|\|\| Output \|\|\|+\|=\|\|\|\| Input \|\|\|\|\|+\|\|=\|\| Output Impossible Input \|+\|=\|\|\|\|\|\| Output Impossible Input \|\|\|\|+\|\|=\|\|\|\|\|\| Output \|\|\|\|+\|\|=\|\|\|\|\|\| -----Note----- In the first sample we can shift stick from the third group of sticks to the first one. In the second sample we cannot shift vertical stick from + sign to the second group of sticks. So we cannot make a - sign. There is no answer in the third sample because we cannot remove sticks from the expression. In the forth sample the initial expression is already arithmetically correct and that is why we don't have to shift sticks. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Print all the integers that satisfies the following in ascending order: - Among the integers between A and B (inclusive), it is either within the K smallest integers or within the K largest integers. -----Constraints----- - 1 \leq A \leq B \leq 10^9 - 1 \leq K \leq 100 - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: A B K -----Output----- Print all the integers that satisfies the condition above in ascending order. -----Sample Input----- 3 8 2 -----Sample Output----- 3 4 7 8 - 3 is the first smallest integer among the integers between 3 and 8. - 4 is the second smallest integer among the integers between 3 and 8. - 7 is the second largest integer among the integers between 3 and 8. - 8 is the first largest integer among the integers between 3 and 8. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array a of length n. We define f_{a} the following way: Initially f_{a} = 0, M = 1; for every 2 ≤ i ≤ n if a_{M} < a_{i} then we set f_{a} = f_{a} + a_{M} and then set M = i. Calculate the sum of f_{a} over all n! permutations of the array a modulo 10^9 + 7. Note: two elements are considered different if their indices differ, so for every array a there are exactly n! permutations. -----Input----- The first line contains integer n (1 ≤ n ≤ 1 000 000) — the size of array a. Second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9). -----Output----- Print the only integer, the sum of f_{a} over all n! permutations of the array a modulo 10^9 + 7. -----Examples----- Input 2 1 3 Output 1 Input 3 1 1 2 Output 4 -----Note----- For the second example all the permutations are: p = [1, 2, 3] : f_{a} is equal to 1; p = [1, 3, 2] : f_{a} is equal to 1; p = [2, 1, 3] : f_{a} is equal to 1; p = [2, 3, 1] : f_{a} is equal to 1; p = [3, 1, 2] : f_{a} is equal to 0; p = [3, 2, 1] : f_{a} is equal to 0. Where p is the array of the indices of initial array a. The sum of f_{a} is equal to 4. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A line on the plane is described by an equation Ax + By + C = 0. You are to find any point on this line, whose coordinates are integer numbers from - 5·1018 to 5·1018 inclusive, or to find out that such points do not exist. Input The first line contains three integers A, B and C ( - 2·109 ≤ A, B, C ≤ 2·109) — corresponding coefficients of the line equation. It is guaranteed that A2 + B2 > 0. Output If the required point exists, output its coordinates, otherwise output -1. Examples Input 2 5 3 Output 6 -3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given three integers k, p_{a} and p_{b}. You will construct a sequence with the following algorithm: Initially, start with the empty sequence. Each second, you do the following. With probability p_{a} / (p_{a} + p_{b}), add 'a' to the end of the sequence. Otherwise (with probability p_{b} / (p_{a} + p_{b})), add 'b' to the end of the sequence. You stop once there are at least k subsequences that form 'ab'. Determine the expected number of times 'ab' is a subsequence in the resulting sequence. It can be shown that this can be represented by P / Q, where P and Q are coprime integers, and $Q \neq 0 \operatorname{mod}(10^{9} + 7)$. Print the value of $P \cdot Q^{-1} \operatorname{mod}(10^{9} + 7)$. -----Input----- The first line will contain three integers integer k, p_{a}, p_{b} (1 ≤ k ≤ 1 000, 1 ≤ p_{a}, p_{b} ≤ 1 000 000). -----Output----- Print a single integer, the answer to the problem. -----Examples----- Input 1 1 1 Output 2 Input 3 1 4 Output 370000006 -----Note----- The first sample, we will keep appending to our sequence until we get the subsequence 'ab' at least once. For instance, we get the sequence 'ab' with probability 1/4, 'bbab' with probability 1/16, and 'aab' with probability 1/8. Note, it's impossible for us to end with a sequence like 'aabab', since we would have stopped our algorithm once we had the prefix 'aab'. The expected amount of times that 'ab' will occur across all valid sequences is 2. For the second sample, the answer is equal to $\frac{341}{100}$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. In an embassy of a well-known kingdom an electronic queue is organised. Every person who comes to the embassy, needs to make the following three actions: show the ID, pay money to the cashier and be fingerprinted. Besides, the actions should be performed in the given order. For each action several separate windows are singled out: k1 separate windows for the first action (the first type windows), k2 windows for the second one (the second type windows), and k3 for the third one (the third type windows). The service time for one person in any of the first type window equals to t1. Similarly, it takes t2 time to serve a person in any of the second type windows. And it takes t3 to serve one person in any of the third type windows. Thus, the service time depends only on the window type and is independent from the person who is applying for visa. At some moment n people come to the embassy, the i-th person comes at the moment of time ci. The person is registered under some number. After that he sits in the hall and waits for his number to be shown on a special board. Besides the person's number the board shows the number of the window where one should go and the person goes there immediately. Let's consider that the time needed to approach the window is negligible. The table can show information for no more than one person at a time. The electronic queue works so as to immediately start working with the person who has approached the window, as there are no other people in front of the window. The Client Service Quality inspectors noticed that several people spend too much time in the embassy (this is particularly tiresome as the embassy has no mobile phone reception and 3G). It was decided to organise the system so that the largest time a person spends in the embassy were minimum. Help the inspectors organise the queue. Consider that all actions except for being served in at the window, happen instantly. Input The first line contains three space-separated integers k1, k2, k3 (1 ≤ ki ≤ 109), they are the number of windows of the first, second and third type correspondingly. The second line contains three space-separated integers t1, t2, t3 (1 ≤ ti ≤ 105), they are the periods of time needed to serve one person in the window of the first, second and third type correspondingly. The third line contains an integer n (1 ≤ n ≤ 105), it is the number of people. The fourth line contains n space-separated integers ci (1 ≤ ci ≤ 109) in the non-decreasing order; ci is the time when the person number i comes to the embassy. Output Print the single number, the maximum time a person will spend in the embassy if the queue is organized optimally. Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams (also you may use the %I64d specificator). Examples Input 1 1 1 1 1 1 5 1 1 1 1 1 Output 7 Input 2 1 1 5 1 1 5 1 2 3 3 5 Output 13 Note In the first test 5 people come simultaneously at the moment of time equal to 1. There is one window of every type, it takes 1 unit of time to be served at each window. That's why the maximal time a person spends in the embassy is the time needed to be served at the windows (3 units of time) plus the time the last person who comes to the first window waits (4 units of time). Windows in the second test work like this: The first window of the first type: [1, 6) — the first person, [6, 11) — third person, [11, 16) — fifth person The second window of the first type: [2, 7) — the second person, [7, 12) — the fourth person The only second type window: [6, 7) — first, [7, 8) — second, [11, 12) — third, [12, 13) — fourth, [16, 17) — fifth The only third type window: [7, 8) — first, [8, 9) — second, [12, 13) — third, [13, 14) — fourth, [17, 18) — fifth We can see that it takes most time to serve the fifth person. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A holiday weekend is coming up, and Hotel Bytelandia needs to find out if it has enough rooms to accommodate all potential guests. A number of guests have made reservations. Each reservation consists of an arrival time, and a departure time. The hotel management has hired you to calculate the maximum number of guests that will be at the hotel simultaneously. Note that if one guest arrives at the same time another leaves, they are never considered to be at the hotel simultaneously (see the second example). ------ Input ------ Input will begin with an integer T, the number of test cases. Each test case begins with an integer N, the number of guests. Two lines follow, each with exactly N positive integers. The i-th integer of the first line is the arrival time of the i-th guest, and the i-th integer of the second line is the departure time of the i-th guest (which will be strictly greater than the arrival time). ------ Output ------ For each test case, print the maximum number of guests that are simultaneously at the hotel. ------ Constraints ------ $T≤100$ $N≤100$ $All arrival/departure times will be between 1 and 1000, inclusive$ ----- Sample Input 1 ------ 3 3 1 2 3 4 5 6 5 1 2 3 4 5 2 3 4 5 6 7 13 6 5 8 2 10 12 19 18 6 9 9 11 15 ----- Sample Output 1 ------ 3 1 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Holmes children are fighting over who amongst them is the cleverest. Mycroft asked Sherlock and Eurus to find value of f(n), where f(1) = 1 and for n ≥ 2, f(n) is the number of distinct ordered positive integer pairs (x, y) that satisfy x + y = n and gcd(x, y) = 1. The integer gcd(a, b) is the greatest common divisor of a and b. Sherlock said that solving this was child's play and asked Mycroft to instead get the value of $g(n) = \sum_{d\|n} f(n / d)$. Summation is done over all positive integers d that divide n. Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft. She defined a k-composite function F_{k}(n) recursively as follows: $F_{k}(n) = \left\{\begin{array}{ll}{f(g(n)),} & {\text{for} k = 1} \\{g(F_{k - 1}(n)),} & {\text{for} k > 1 \text{and} k \operatorname{mod} 2 = 0} \\{f(F_{k - 1}(n)),} & {\text{for} k > 1 \text{and} k \operatorname{mod} 2 = 1} \end{array} \right.$ She wants them to tell the value of F_{k}(n) modulo 1000000007. -----Input----- A single line of input contains two space separated integers n (1 ≤ n ≤ 10^12) and k (1 ≤ k ≤ 10^12) indicating that Eurus asks Sherlock and Mycroft to find the value of F_{k}(n) modulo 1000000007. -----Output----- Output a single integer — the value of F_{k}(n) modulo 1000000007. -----Examples----- Input 7 1 Output 6 Input 10 2 Output 4 -----Note----- In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying x + y = 7 and gcd(x, y) = 1. Hence, f(7) = 6. So, F_1(7) = f(g(7)) = f(f(7) + f(1)) = f(6 + 1) = f(7) = 6. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Recently Lynyrd and Skynyrd went to a shop where Lynyrd bought a permutation $p$ of length $n$, and Skynyrd bought an array $a$ of length $m$, consisting of integers from $1$ to $n$. Lynyrd and Skynyrd became bored, so they asked you $q$ queries, each of which has the following form: "does the subsegment of $a$ from the $l$-th to the $r$-th positions, inclusive, have a subsequence that is a cyclic shift of $p$?" Please answer the queries. A permutation of length $n$ is a sequence of $n$ integers such that each integer from $1$ to $n$ appears exactly once in it. A cyclic shift of a permutation $(p_1, p_2, \ldots, p_n)$ is a permutation $(p_i, p_{i + 1}, \ldots, p_{n}, p_1, p_2, \ldots, p_{i - 1})$ for some $i$ from $1$ to $n$. For example, a permutation $(2, 1, 3)$ has three distinct cyclic shifts: $(2, 1, 3)$, $(1, 3, 2)$, $(3, 2, 1)$. A subsequence of a subsegment of array $a$ from the $l$-th to the $r$-th positions, inclusive, is a sequence $a_{i_1}, a_{i_2}, \ldots, a_{i_k}$ for some $i_1, i_2, \ldots, i_k$ such that $l \leq i_1 < i_2 < \ldots < i_k \leq r$. -----Input----- The first line contains three integers $n$, $m$, $q$ ($1 \le n, m, q \le 2 \cdot 10^5$) — the length of the permutation $p$, the length of the array $a$ and the number of queries. The next line contains $n$ integers from $1$ to $n$, where the $i$-th of them is the $i$-th element of the permutation. Each integer from $1$ to $n$ appears exactly once. The next line contains $m$ integers from $1$ to $n$, the $i$-th of them is the $i$-th element of the array $a$. The next $q$ lines describe queries. The $i$-th of these lines contains two integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le m$), meaning that the $i$-th query is about the subsegment of the array from the $l_i$-th to the $r_i$-th positions, inclusive. -----Output----- Print a single string of length $q$, consisting of $0$ and $1$, the digit on the $i$-th positions should be $1$, if the subsegment of array $a$ from the $l_i$-th to the $r_i$-th positions, inclusive, contains a subsequence that is a cyclic shift of $p$, and $0$ otherwise. -----Examples----- Input 3 6 3 2 1 3 1 2 3 1 2 3 1 5 2 6 3 5 Output 110 Input 2 4 3 2 1 1 1 2 2 1 2 2 3 3 4 Output 010 -----Note----- In the first example the segment from the $1$-st to the $5$-th positions is $1, 2, 3, 1, 2$. There is a subsequence $1, 3, 2$ that is a cyclic shift of the permutation. The subsegment from the $2$-nd to the $6$-th positions also contains a subsequence $2, 1, 3$ that is equal to the permutation. The subsegment from the $3$-rd to the $5$-th positions is $3, 1, 2$, there is only one subsequence of length $3$ ($3, 1, 2$), but it is not a cyclic shift of the permutation. In the second example the possible cyclic shifts are $1, 2$ and $2, 1$. The subsegment from the $1$-st to the $2$-nd positions is $1, 1$, its subsequences are not cyclic shifts of the permutation. The subsegment from the $2$-nd to the $3$-rd positions is $1, 2$, it coincides with the permutation. The subsegment from the $3$ to the $4$ positions is $2, 2$, its subsequences are not cyclic shifts of the permutation. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. This kata is part of the collection [Mary's Puzzle Books](https://www.codewars.com/collections/marys-puzzle-books). Mary brought home a "spot the differences" book. The book is full of a bunch of problems, and each problem consists of two strings that are similar. However, in each string there are a few characters that are different. An example puzzle from her book is: ``` String 1: "abcdefg" String 2: "abcqetg" ``` Notice how the "d" from String 1 has become a "q" in String 2, and "f" from String 1 has become a "t" in String 2. It's your job to help Mary solve the puzzles. Write a program `spot_diff`/`Spot` that will compare the two strings and return a list with the positions where the two strings differ. In the example above, your program should return `[3, 5]` because String 1 is different from String 2 at positions 3 and 5. NOTES: ```if-not:csharp • If both strings are the same, return `[]` ``` ```if:csharp • If both strings are the same, return `new List()` ``` • Both strings will always be the same length • Capitalization and punctuation matter Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Heidi and Doctor Who hopped out of the TARDIS and found themselves at EPFL in 2018. They were surrounded by stormtroopers and Darth Vader was approaching. Miraculously, they managed to escape to a nearby rebel base but the Doctor was very confused. Heidi reminded him that last year's HC2 theme was Star Wars. Now he understood, and he's ready to face the evils of the Empire! The rebels have $s$ spaceships, each with a certain attacking power $a$. They want to send their spaceships to destroy the empire bases and steal enough gold and supplies in order to keep the rebellion alive. The empire has $b$ bases, each with a certain defensive power $d$, and a certain amount of gold $g$. A spaceship can attack all the bases which have a defensive power less than or equal to its attacking power. If a spaceship attacks a base, it steals all the gold in that base. The rebels are still undecided which spaceship to send out first, so they asked for the Doctor's help. They would like to know, for each spaceship, the maximum amount of gold it can steal. -----Input----- The first line contains integers $s$ and $b$ ($1 \leq s, b \leq 10^5$), the number of spaceships and the number of bases, respectively. The second line contains $s$ integers $a$ ($0 \leq a \leq 10^9$), the attacking power of each spaceship. The next $b$ lines contain integers $d, g$ ($0 \leq d \leq 10^9$, $0 \leq g \leq 10^4$), the defensive power and the gold of each base, respectively. -----Output----- Print $s$ integers, the maximum amount of gold each spaceship can steal, in the same order as the spaceships are given in the input. -----Example----- Input 5 4 1 3 5 2 4 0 1 4 2 2 8 9 4 Output 1 9 11 9 11 -----Note----- The first spaceship can only attack the first base. The second spaceship can attack the first and third bases. The third spaceship can attack the first, second and third bases. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Summation Of Primes The sum of the primes below or equal to 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes _below or equal to the number passed in_. From Project Euler's [Problem #10](https://projecteuler.net/problem=10 "Project Euler - Problem 10"). Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Write a program which judges wheather given length of three side form a right triangle. Print "YES" if the given sides (integers) form a right triangle, "NO" if not so. Constraints * 1 ≤ length of the side ≤ 1,000 * N ≤ 1,000 Input Input consists of several data sets. In the first line, the number of data set, N is given. Then, N lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space. Output For each data set, print "YES" or "NO". Example Input 3 4 3 5 4 3 6 8 8 8 Output YES NO NO Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Task Mr.Nam has `n` candies, he wants to put one candy in each cell of a table-box. The table-box has `r` rows and `c` columns. Each candy was labeled by its cell number. The cell numbers are in range from 1 to N and the direction begins from right to left and from bottom to top. Nam wants to know the position of a specific `candy` and which box is holding it. The result should be an array and contain exactly 3 elements. The first element is the `label` of the table; The second element is the `row` of the candy; The third element is the `column` of the candy. If there is no candy with the given number, return `[-1, -1, -1]`. Note: When the current box is filled up, Nam buys another one. The boxes are labeled from `1`. Rows and columns are `0`-based numbered from left to right and from top to bottom. # Example For `n=6,r=2,c=2,candy=3`, the result should be `[1,0,1]` the candies will be allocated like this: ``` Box 1 +-----+-----+ \| 4 \| (3) \| --> box 1,row 0, col 1 +-----+-----+ \| 2 \| 1 \| +-----+-----+ Box 2 +-----+-----+ \| x \| x \| +-----+-----+ \| 6 \| (5) \| --> box 2,row 1, col 1 +-----+-----+``` For `candy = 5(n,r,c same as above)`, the output should be `[2,1,1]`. For `candy = 7(n,r,c same as above)`, the output should be `[-1,-1,-1]`. For `n=8,r=4,c=2,candy=3`, the result should be `[1,2,1]` ``` Box 1 +-----+-----+ \| 8 \| 7 \| +-----+-----+ \| 6 \| 5 \| +-----+-----+ \| 4 \| (3) \|--> box 1,row 2, col 1 +-----+-----+ \| 2 \| 1 \| +-----+-----+ ``` # Input/Output - `[input]` integer `n` The number of candies. `0 < n <= 100` - `[input]` integer `r` The number of rows. `0 < r <= 100` - `[input]` integer `c` The number of columns. `0 < c <= 100` - `[input]` integer `candy` The label of the candy Nam wants to get position of. `0 < c <= 120` - `[output]` an integer array Array of 3 elements: a label, a row and a column. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Let's call a positive integer extremely round if it has only one non-zero digit. For example, $5000$, $4$, $1$, $10$, $200$ are extremely round integers; $42$, $13$, $666$, $77$, $101$ are not. You are given an integer $n$. You have to calculate the number of extremely round integers $x$ such that $1 \le x \le n$. -----Input----- The first line contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. Then, $t$ lines follow. The $i$-th of them contains one integer $n$ ($1 \le n \le 999999$) — the description of the $i$-th test case. -----Output----- For each test case, print one integer — the number of extremely round integers $x$ such that $1 \le x \le n$. -----Examples----- Input 5 9 42 13 100 111 Output 9 13 10 19 19 -----Note----- None Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again. <image> --- Figure 1 --- Input The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below. The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left. The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left. The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left. ... The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left. <image> --- Figure 2 (Thick line shows where the wall is) (corresponding numbers) However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1. Output "Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance. Example Input 1111 00001 0110 01011 0010 01111 0010 01001 0111 Output RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Two children are playing tag on a number line. (In the game of tag, the child called "it" tries to catch the other child.) The child who is "it" is now at coordinate A, and he can travel the distance of V per second. The other child is now at coordinate B, and she can travel the distance of W per second. He can catch her when his coordinate is the same as hers. Determine whether he can catch her within T seconds (including exactly T seconds later). We assume that both children move optimally. Constraints * -10^9 \leq A,B \leq 10^9 * 1 \leq V,W \leq 10^9 * 1 \leq T \leq 10^9 * A \neq B * All values in input are integers. Input Input is given from Standard Input in the following format: A V B W T Output If "it" can catch the other child, print `YES`; otherwise, print `NO`. Examples Input 1 2 3 1 3 Output YES Input 1 2 3 2 3 Output NO Input 1 2 3 3 3 Output NO Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. After a long party Petya decided to return home, but he turned out to be at the opposite end of the town from his home. There are $n$ crossroads in the line in the town, and there is either the bus or the tram station at each crossroad. The crossroads are represented as a string $s$ of length $n$, where $s_i = \texttt{A}$, if there is a bus station at $i$-th crossroad, and $s_i = \texttt{B}$, if there is a tram station at $i$-th crossroad. Currently Petya is at the first crossroad (which corresponds to $s_1$) and his goal is to get to the last crossroad (which corresponds to $s_n$). If for two crossroads $i$ and $j$ for all crossroads $i, i+1, \ldots, j-1$ there is a bus station, one can pay $a$ roubles for the bus ticket, and go from $i$-th crossroad to the $j$-th crossroad by the bus (it is not necessary to have a bus station at the $j$-th crossroad). Formally, paying $a$ roubles Petya can go from $i$ to $j$ if $s_t = \texttt{A}$ for all $i \le t < j$. If for two crossroads $i$ and $j$ for all crossroads $i, i+1, \ldots, j-1$ there is a tram station, one can pay $b$ roubles for the tram ticket, and go from $i$-th crossroad to the $j$-th crossroad by the tram (it is not necessary to have a tram station at the $j$-th crossroad). Formally, paying $b$ roubles Petya can go from $i$ to $j$ if $s_t = \texttt{B}$ for all $i \le t < j$. For example, if $s$="AABBBAB", $a=4$ and $b=3$ then Petya needs:[Image] buy one bus ticket to get from $1$ to $3$, buy one tram ticket to get from $3$ to $6$, buy one bus ticket to get from $6$ to $7$. Thus, in total he needs to spend $4+3+4=11$ roubles. Please note that the type of the stop at the last crossroad (i.e. the character $s_n$) does not affect the final expense. Now Petya is at the first crossroad, and he wants to get to the $n$-th crossroad. After the party he has left with $p$ roubles. He's decided to go to some station on foot, and then go to home using only public transport. Help him to choose the closest crossroad $i$ to go on foot the first, so he has enough money to get from the $i$-th crossroad to the $n$-th, using only tram and bus tickets. -----Input----- Each test contains one or more test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). The first line of each test case consists of three integers $a, b, p$ ($1 \le a, b, p \le 10^5$) — the cost of bus ticket, the cost of tram ticket and the amount of money Petya has. The second line of each test case consists of one string $s$, where $s_i = \texttt{A}$, if there is a bus station at $i$-th crossroad, and $s_i = \texttt{B}$, if there is a tram station at $i$-th crossroad ($2 \le \|s\| \le 10^5$). It is guaranteed, that the sum of the length of strings $s$ by all test cases in one test doesn't exceed $10^5$. -----Output----- For each test case print one number — the minimal index $i$ of a crossroad Petya should go on foot. The rest of the path (i.e. from $i$ to $n$ he should use public transport). -----Example----- Input 5 2 2 1 BB 1 1 1 AB 3 2 8 AABBBBAABB 5 3 4 BBBBB 2 1 1 ABABAB Output 2 1 3 1 6 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into $n$ sub-tracks. You are given an array $a$ where $a_i$ represents the number of traffic cars in the $i$-th sub-track. You define the inconvenience of the track as $\sum\limits_{i=1}^{n} \sum\limits_{j=i+1}^{n} \lvert a_i-a_j\rvert$, where $\|x\|$ is the absolute value of $x$. You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track. Find the minimum inconvenience you can achieve. -----Input----- The first line of input contains a single integer $t$ ($1\leq t\leq 10000$) — the number of test cases. The first line of each test case contains a single integer $n$ ($1\leq n\leq 2\cdot 10^5$). The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0\leq a_i\leq 10^9$). It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$. -----Output----- For each test case, print a single line containing a single integer: the minimum inconvenience you can achieve by applying the given operation any (possibly zero) number of times. -----Examples----- Input 3 3 1 2 3 4 0 1 1 0 10 8 3 6 11 5 2 1 7 10 4 Output 0 4 21 -----Note----- For the first test case, you can move a car from the $3$-rd sub-track to the $1$-st sub-track to obtain $0$ inconvenience. For the second test case, moving any car won't decrease the inconvenience of the track. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya has two strings a and b of the same length n. The strings consist only of lucky digits. Petya can perform operations of two types: * replace any one digit from string a by its opposite (i.e., replace 4 by 7 and 7 by 4); * swap any pair of digits in string a. Petya is interested in the minimum number of operations that are needed to make string a equal to string b. Help him with the task. Input The first and the second line contains strings a and b, correspondingly. Strings a and b have equal lengths and contain only lucky digits. The strings are not empty, their length does not exceed 105. Output Print on the single line the single number — the minimum number of operations needed to convert string a into string b. Examples Input 47 74 Output 1 Input 774 744 Output 1 Input 777 444 Output 3 Note In the first sample it is enough simply to swap the first and the second digit. In the second sample we should replace the second digit with its opposite. In the third number we should replace all three digits with their opposites. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Create a program that inputs the test result data of the visual acuity test and outputs the number of people who apply to each judgment based on the following visual acuity judgment table for each of the left and right eyesight. Judgment \| Sight --- \| --- A \| 1.1 or above B \| 0.6 or more and less than 1.1 C \| 0.2 or more and less than 0.6 D \| less than 0.2 Input The input is given in the following format: l1 r1 l2 r2 l3 r3 :: :: On line i, the real number li, which represents the left visual acuity of the i-th person, and the real number ri, which represents the right visual acuity, are given, separated by blanks. However, visual acuity is 0.1 or more and 2.0 or less, and is given in 0.1 increments. The number of lines of input does not exceed 40. Output Please output the judgment table in the following format. Line 1 Left eyesight is the number of people A Right eyesight is the number of people (separated by blanks) 2nd line The number of people whose left eyesight is B The number of people whose right eyesight is B (separated by blanks) 3rd line The number of people whose left eyesight is C 4th line Number of people with left eyesight D Number of people with right eyesight D (separated by blanks) Example Input 1.0 1.2 0.8 1.5 1.2 0.7 2.0 2.0 Output 2 3 2 1 0 0 0 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Little Elephant loves numbers. He has a positive integer x. The Little Elephant wants to find the number of positive integers d, such that d is the divisor of x, and x and d have at least one common (the same) digit in their decimal representations. Help the Little Elephant to find the described number. Input A single line contains a single integer x (1 ≤ x ≤ 109). Output In a single line print an integer — the answer to the problem. Examples Input 1 Output 1 Input 10 Output 2 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string $s = s_1 s_2 \dots s_{n}$ of length $n$ where each letter is either R, S or P. While initializing, the bot is choosing a starting index $pos$ ($1 \le pos \le n$), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of $s_{pos}$: if $s_{pos}$ is equal to R the bot chooses "Rock"; if $s_{pos}$ is equal to S the bot chooses "Scissors"; if $s_{pos}$ is equal to P the bot chooses "Paper"; In the second round, the bot's choice is based on the value of $s_{pos + 1}$. In the third round — on $s_{pos + 2}$ and so on. After $s_n$ the bot returns to $s_1$ and continues his game. You plan to play $n$ rounds and you've already figured out the string $s$ but still don't know what is the starting index $pos$. But since the bot's tactic is so boring, you've decided to find $n$ choices to each round to maximize the average number of wins. In other words, let's suggest your choices are $c_1 c_2 \dots c_n$ and if the bot starts from index $pos$ then you'll win in $win(pos)$ rounds. Find $c_1 c_2 \dots c_n$ such that $\frac{win(1) + win(2) + \dots + win(n)}{n}$ is maximum possible. -----Input----- The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases. Next $t$ lines contain test cases — one per line. The first and only line of each test case contains string $s = s_1 s_2 \dots s_{n}$ ($1 \le n \le 2 \cdot 10^5$; $s_i \in \{\text{R}, \text{S}, \text{P}\}$) — the string of the bot. It's guaranteed that the total length of all strings in one test doesn't exceed $2 \cdot 10^5$. -----Output----- For each test case, print $n$ choices $c_1 c_2 \dots c_n$ to maximize the average number of wins. Print them in the same manner as the string $s$. If there are multiple optimal answers, print any of them. -----Example----- Input 3 RRRR RSP S Output PPPP RSP R -----Note----- In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all $n = 4$ rounds, so the average is also equal to $4$. In the second test case: if bot will start from $pos = 1$, then $(s_1, c_1)$ is draw, $(s_2, c_2)$ is draw and $(s_3, c_3)$ is draw, so $win(1) = 0$; if bot will start from $pos = 2$, then $(s_2, c_1)$ is win, $(s_3, c_2)$ is win and $(s_1, c_3)$ is win, so $win(2) = 3$; if bot will start from $pos = 3$, then $(s_3, c_1)$ is lose, $(s_1, c_2)$ is lose and $(s_2, c_3)$ is lose, so $win(3) = 0$; The average is equal to $\frac{0 + 3 + 0}{3} = 1$ and it can be proven that it's the maximum possible average. A picture from Wikipedia explaining "Rock paper scissors" game: $\beta$ Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given an array consisting of $n$ integers $a_1, a_2, \dots, a_n$, and a positive integer $m$. It is guaranteed that $m$ is a divisor of $n$. In a single move, you can choose any position $i$ between $1$ and $n$ and increase $a_i$ by $1$. Let's calculate $c_r$ ($0 \le r \le m-1)$ — the number of elements having remainder $r$ when divided by $m$. In other words, for each remainder, let's find the number of corresponding elements in $a$ with that remainder. Your task is to change the array in such a way that $c_0 = c_1 = \dots = c_{m-1} = \frac{n}{m}$. Find the minimum number of moves to satisfy the above requirement. -----Input----- The first line of input contains two integers $n$ and $m$ ($1 \le n \le 2 \cdot 10^5, 1 \le m \le n$). It is guaranteed that $m$ is a divisor of $n$. The second line of input contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 10^9$), the elements of the array. -----Output----- In the first line, print a single integer — the minimum number of moves required to satisfy the following condition: for each remainder from $0$ to $m - 1$, the number of elements of the array having this remainder equals $\frac{n}{m}$. In the second line, print any array satisfying the condition and can be obtained from the given array with the minimum number of moves. The values of the elements of the resulting array must not exceed $10^{18}$. -----Examples----- Input 6 3 3 2 0 6 10 12 Output 3 3 2 0 7 10 14 Input 4 2 0 1 2 3 Output 0 0 1 2 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Recently in Divanovo, a huge river locks system was built. There are now $n$ locks, the $i$-th of them has the volume of $v_i$ liters, so that it can contain any amount of water between $0$ and $v_i$ liters. Each lock has a pipe attached to it. When the pipe is open, $1$ liter of water enters the lock every second. The locks system is built in a way to immediately transfer all water exceeding the volume of the lock $i$ to the lock $i + 1$. If the lock $i + 1$ is also full, water will be transferred further. Water exceeding the volume of the last lock pours out to the river. The picture illustrates $5$ locks with two open pipes at locks $1$ and $3$. Because locks $1$, $3$, and $4$ are already filled, effectively the water goes to locks $2$ and $5$. Note that the volume of the $i$-th lock may be greater than the volume of the $i + 1$-th lock. To make all locks work, you need to completely fill each one of them. The mayor of Divanovo is interested in $q$ independent queries. For each query, suppose that initially all locks are empty and all pipes are closed. Then, some pipes are opened simultaneously. For the $j$-th query the mayor asks you to calculate the minimum number of pipes to open so that all locks are filled no later than after $t_j$ seconds. Please help the mayor to solve this tricky problem and answer his queries. -----Input----- The first lines contains one integer $n$ ($1 \le n \le 200000$) — the number of locks. The second lines contains $n$ integers $v_1, v_2, \dots, v_n$ ($1 \le v_i \le 10^9$)) — volumes of the locks. The third line contains one integer $q$ ($1 \le q \le 200000$) — the number of queries. Each of the next $q$ lines contains one integer $t_j$ ($1 \le t_j \le 10^9$) — the number of seconds you have to fill all the locks in the query $j$. -----Output----- Print $q$ integers. The $j$-th of them should be equal to the minimum number of pipes to turn on so that after $t_j$ seconds all of the locks are filled. If it is impossible to fill all of the locks in given time, print $-1$. -----Examples----- Input 5 4 1 5 4 1 6 1 6 2 3 4 5 Output -1 3 -1 -1 4 3 Input 5 4 4 4 4 4 6 1 3 6 5 2 4 Output -1 -1 4 4 -1 5 -----Note----- There are $6$ queries in the first example test. In the queries $1, 3, 4$ the answer is $-1$. We need to wait $4$ seconds to fill the first lock even if we open all the pipes. In the sixth query we can open pipes in locks $1$, $3$, and $4$. After $4$ seconds the locks $1$ and $4$ are full. In the following $1$ second $1$ liter of water is transferred to the locks $2$ and $5$. The lock $3$ is filled by its own pipe. Similarly, in the second query one can open pipes in locks $1$, $3$, and $4$. In the fifth query one can open pipes $1, 2, 3, 4$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are N monsters, numbered 1, 2, ..., N. Initially, the health of Monster i is A_i. Below, a monster with at least 1 health is called alive. Until there is only one alive monster, the following is repeated: - A random alive monster attacks another random alive monster. - As a result, the health of the monster attacked is reduced by the amount equal to the current health of the monster attacking. Find the minimum possible final health of the last monster alive. -----Constraints----- - All values in input are integers. - 2 \leq N \leq 10^5 - 1 \leq A_i \leq 10^9 -----Input----- Input is given from Standard Input in the following format: N A_1 A_2 ... A_N -----Output----- Print the minimum possible final health of the last monster alive. -----Sample Input----- 4 2 10 8 40 -----Sample Output----- 2 When only the first monster keeps on attacking, the final health of the last monster will be 2, which is minimum. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Pak Chanek plans to build a garage. He wants the garage to consist of a square and a right triangle that are arranged like the following illustration. Define $a$ and $b$ as the lengths of two of the sides in the right triangle as shown in the illustration. An integer $x$ is suitable if and only if we can construct a garage with assigning positive integer values for the lengths $a$ and $b$ ($a<b$) so that the area of the square at the bottom is exactly $x$. As a good friend of Pak Chanek, you are asked to help him find the $N$-th smallest suitable number. -----Input----- The only line contains a single integer $N$ ($1 \leq N \leq 10^9$). -----Output----- An integer that represents the $N$-th smallest suitable number. -----Examples----- Input 3 Output 7 -----Note----- The $3$-rd smallest suitable number is $7$. A square area of $7$ can be obtained by assigning $a=3$ and $b=4$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. problem There are $ N $ islands numbered from $ 1 $ to $ N $. Each island has $ N-1 $ bridges, allowing any $ 2 $ island to move to each other across several bridges. Each bridge has durability, and the durability of the $ i $ th bridge given the input is $ w_i $. There are $ 1 $ treasures on each island, and you can pick them up while you're on the island. Yebi, who is currently on the island $ S $, wants to carry all the treasures to the museum on the island $ E $. Since yebi has ✝ magical power ✝, every time he visits the island $ v $, the durability of all bridges coming out of $ v $ is reduced by $ T $. When the durability of the bridge drops below $ 0 $, the bridge collapses and cannot be crossed after that. Can yebi deliver all the treasures to the museum? However, since yebi is powerful, he can carry as many treasures as he wants at the same time. output Output "Yes" if you can deliver all the treasures to the museum, otherwise output "No". Also, output a line break at the end. Example Input 4 10 1 4 1 2 52 1 3 68 3 4 45 Output Yes Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya's birthday is approaching and Lena decided to sew a patterned handkerchief to him as a present. Lena chose digits from 0 to n as the pattern. The digits will form a rhombus. The largest digit n should be located in the centre. The digits should decrease as they approach the edges. For example, for n = 5 the handkerchief pattern should look like that: 0 0 1 0 0 1 2 1 0 0 1 2 3 2 1 0 0 1 2 3 4 3 2 1 0 0 1 2 3 4 5 4 3 2 1 0 0 1 2 3 4 3 2 1 0 0 1 2 3 2 1 0 0 1 2 1 0 0 1 0 0 Your task is to determine the way the handkerchief will look like by the given n. Input The first line contains the single integer n (2 ≤ n ≤ 9). Output Print a picture for the given n. You should strictly observe the number of spaces before the first digit on each line. Every two adjacent digits in the same line should be separated by exactly one space. There should be no spaces after the last digit at the end of each line. Examples Input 2 Output 0 0 1 0 0 1 2 1 0 0 1 0 0 Input 3 Output 0 0 1 0 0 1 2 1 0 0 1 2 3 2 1 0 0 1 2 1 0 0 1 0 0 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Super Duper Secret Meeting of the Super Duper Secret Military Squad takes place in a Super Duper Secret Place. The place is an infinite plane with introduced Cartesian coordinate system. The meeting table is represented as a rectangle whose sides are parallel to the coordinate axes and whose vertexes are located at the integer points of the plane. At each integer point which belongs to the table perimeter there is a chair in which a general sits. Some points on the plane contain radiators for the generals not to freeze in winter. Each radiator is characterized by the number ri — the radius of the area this radiator can heat. That is, if the distance between some general and the given radiator is less than or equal to ri, than the general feels comfortable and warm. Here distance is defined as Euclidean distance, so the distance between points (x1, y1) and (x2, y2) is <image> Each general who is located outside the radiators' heating area can get sick. Thus, you should bring him a warm blanket. Your task is to count the number of warm blankets you should bring to the Super Duper Secret Place. The generals who are already comfortable do not need a blanket. Also the generals never overheat, ever if they are located in the heating area of several radiators. The radiators can be located at any integer points on the plane, even inside the rectangle (under the table) or on the perimeter (directly under some general). Even in this case their radius does not change. Input The first input line contains coordinates of two opposite table corners xa, ya, xb, yb (xa ≠ xb, ya ≠ yb). The second line contains integer n — the number of radiators (1 ≤ n ≤ 103). Then n lines contain the heaters' coordinates as "xi yi ri", the numbers are separated by spaces. All input data numbers are integers. The absolute value of all coordinates does not exceed 1000, 1 ≤ ri ≤ 1000. Several radiators can be located at the same point. Output Print the only number — the number of blankets you should bring. Examples Input 2 5 4 2 3 3 1 2 5 3 1 1 3 2 Output 4 Input 5 2 6 3 2 6 2 2 6 5 3 Output 0 Note In the first sample the generals are sitting at points: (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5). Among them, 4 generals are located outside the heating range. They are the generals at points: (2, 5), (3, 5), (4, 4), (4, 5). In the second sample the generals are sitting at points: (5, 2), (5, 3), (6, 2), (6, 3). All of them are located inside the heating range. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You have m = n·k wooden staves. The i-th stave has length a_{i}. You have to assemble n barrels consisting of k staves each, you can use any k staves to construct a barrel. Each stave must belong to exactly one barrel. Let volume v_{j} of barrel j be equal to the length of the minimal stave in it. [Image] You want to assemble exactly n barrels with the maximal total sum of volumes. But you have to make them equal enough, so a difference between volumes of any pair of the resulting barrels must not exceed l, i.e. \|v_{x} - v_{y}\| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n. Print maximal total sum of volumes of equal enough barrels or 0 if it's impossible to satisfy the condition above. -----Input----- The first line contains three space-separated integers n, k and l (1 ≤ n, k ≤ 10^5, 1 ≤ n·k ≤ 10^5, 0 ≤ l ≤ 10^9). The second line contains m = n·k space-separated integers a_1, a_2, ..., a_{m} (1 ≤ a_{i} ≤ 10^9) — lengths of staves. -----Output----- Print single integer — maximal total sum of the volumes of barrels or 0 if it's impossible to construct exactly n barrels satisfying the condition \|v_{x} - v_{y}\| ≤ l for any 1 ≤ x ≤ n and 1 ≤ y ≤ n. -----Examples----- Input 4 2 1 2 2 1 2 3 2 2 3 Output 7 Input 2 1 0 10 10 Output 20 Input 1 2 1 5 2 Output 2 Input 3 2 1 1 2 3 4 5 6 Output 0 -----Note----- In the first example you can form the following barrels: [1, 2], [2, 2], [2, 3], [2, 3]. In the second example you can form the following barrels: [10], [10]. In the third example you can form the following barrels: [2, 5]. In the fourth example difference between volumes of barrels in any partition is at least 2 so it is impossible to make barrels equal enough. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. People in the Tomskaya region like magic formulas very much. You can see some of them below. Imagine you are given a sequence of positive integer numbers p_1, p_2, ..., p_{n}. Lets write down some magic formulas:$q_{i} = p_{i} \oplus(i \operatorname{mod} 1) \oplus(i \operatorname{mod} 2) \oplus \cdots \oplus(i \operatorname{mod} n)$$Q = q_{1} \oplus q_{2} \oplus \ldots \oplus q_{n}$ Here, "mod" means the operation of taking the residue after dividing. The expression $x \oplus y$ means applying the bitwise xor (excluding "OR") operation to integers x and y. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by "^", in Pascal — by "xor". People in the Tomskaya region like magic formulas very much, but they don't like to calculate them! Therefore you are given the sequence p, calculate the value of Q. -----Input----- The first line of the input contains the only integer n (1 ≤ n ≤ 10^6). The next line contains n integers: p_1, p_2, ..., p_{n} (0 ≤ p_{i} ≤ 2·10^9). -----Output----- The only line of output should contain a single integer — the value of Q. -----Examples----- Input 3 1 2 3 Output 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given two very long integers a, b (leading zeroes are allowed). You should check what number a or b is greater or determine that they are equal. The input size is very large so don't use the reading of symbols one by one. Instead of that use the reading of a whole line or token. As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java. Don't use the function input() in Python2 instead of it use the function raw_input(). -----Input----- The first line contains a non-negative integer a. The second line contains a non-negative integer b. The numbers a, b may contain leading zeroes. Each of them contains no more than 10^6 digits. -----Output----- Print the symbol "<" if a < b and the symbol ">" if a > b. If the numbers are equal print the symbol "=". -----Examples----- Input 9 10 Output < Input 11 10 Output > Input 00012345 12345 Output = Input 0123 9 Output > Input 0123 111 Output > Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Today, Wet Shark is given n bishops on a 1000 by 1000 grid. Both rows and columns of the grid are numbered from 1 to 1000. Rows are numbered from top to bottom, while columns are numbered from left to right. Wet Shark thinks that two bishops attack each other if they share the same diagonal. Note, that this is the only criteria, so two bishops may attack each other (according to Wet Shark) even if there is another bishop located between them. Now Wet Shark wants to count the number of pairs of bishops that attack each other. -----Input----- The first line of the input contains n (1 ≤ n ≤ 200 000) — the number of bishops. Each of next n lines contains two space separated integers x_{i} and y_{i} (1 ≤ x_{i}, y_{i} ≤ 1000) — the number of row and the number of column where i-th bishop is positioned. It's guaranteed that no two bishops share the same position. -----Output----- Output one integer — the number of pairs of bishops which attack each other. -----Examples----- Input 5 1 1 1 5 3 3 5 1 5 5 Output 6 Input 3 1 1 2 3 3 5 Output 0 -----Note----- In the first sample following pairs of bishops attack each other: (1, 3), (1, 5), (2, 3), (2, 4), (3, 4) and (3, 5). Pairs (1, 2), (1, 4), (2, 5) and (4, 5) do not attack each other because they do not share the same diagonal. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya has recently found out what a digital root of a number is and he decided to share his knowledge with you. Let's assume that S(n) is the sum of digits of number n, for example, S(4098) = 4 + 0 + 9 + 8 = 21. Then the digital root of number n equals to: 1. dr(n) = S(n), if S(n) < 10; 2. dr(n) = dr( S(n) ), if S(n) ≥ 10. For example, dr(4098) = dr(21) = 3. Vasya is afraid of large numbers, so the numbers he works with are at most 101000. For all such numbers, he has proved that dr(n) = S( S( S( S(n) ) ) ) (n ≤ 101000). Now Vasya wants to quickly find numbers with the given digital root. The problem is, he hasn't learned how to do that and he asked you to help him. You task is, given numbers k and d, find the number consisting of exactly k digits (the leading zeroes are not allowed), with digital root equal to d, or else state that such number does not exist. Input The first line contains two integers k and d (1 ≤ k ≤ 1000; 0 ≤ d ≤ 9). Output In a single line print either any number that meets the requirements (without the leading zeroes) or "No solution" (without the quotes), if the corresponding number does not exist. The chosen number must consist of exactly k digits. We assume that number 0 doesn't contain any leading zeroes. Examples Input 4 4 Output 5881 Input 5 1 Output 36172 Input 1 0 Output 0 Note For the first test sample dr(5881) = dr(22) = 4. For the second test sample dr(36172) = dr(19) = dr(10) = 1. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.