Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y. Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q? Input The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0). It is guaranteed that p / q is an irreducible fraction. Hacks. For hacks, an additional constraint of t ≤ 5 must be met. Output For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve. Example Input 4 3 10 1 2 7 14 3 8 20 70 2 7 5 6 1 1 Output 4 10 0 -1 Note In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2. In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8. In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7. In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1. The input will be give 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 dragon symbolizes wisdom, power and wealth. On Lunar New Year's Day, people model a dragon with bamboo strips and clothes, raise them with rods, and hold the rods high and low to resemble a flying dragon. A performer holding the rod low is represented by a 1, while one holding it high is represented by a 2. Thus, the line of performers can be represented by a sequence a1, a2, ..., an. Little Tommy is among them. He would like to choose an interval [l, r] (1 ≤ l ≤ r ≤ n), then reverse al, al + 1, ..., ar so that the length of the longest non-decreasing subsequence of the new sequence is maximum. A non-decreasing subsequence is a sequence of indices p1, p2, ..., pk, such that p1 < p2 < ... < pk and ap1 ≤ ap2 ≤ ... ≤ apk. The length of the subsequence is k. Input The first line contains an integer n (1 ≤ n ≤ 2000), denoting the length of the original sequence. The second line contains n space-separated integers, describing the original sequence a1, a2, ..., an (1 ≤ ai ≤ 2, i = 1, 2, ..., n). Output Print a single integer, which means the maximum possible length of the longest non-decreasing subsequence of the new sequence. Examples Input 4 1 2 1 2 Output 4 Input 10 1 1 2 2 2 1 1 2 2 1 Output 9 Note In the first example, after reversing [2, 3], the array will become [1, 1, 2, 2], where the length of the longest non-decreasing subsequence is 4. In the second example, after reversing [3, 7], the array will become [1, 1, 1, 1, 2, 2, 2, 2, 2, 1], where the length of the longest non-decreasing subsequence is 9. The input will be give 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 strings. Each string consists of lowercase English letters. Rearrange (reorder) the given strings in such a way that for every string, all strings that are placed before it are its substrings. String a is a substring of string b if it is possible to choose several consecutive letters in b in such a way that they form a. For example, string "for" is contained as a substring in strings "codeforces", "for" and "therefore", but is not contained as a substring in strings "four", "fofo" and "rof". Input The first line contains an integer n (1 ≤ n ≤ 100) — the number of strings. The next n lines contain the given strings. The number of letters in each string is from 1 to 100, inclusive. Each string consists of lowercase English letters. Some strings might be equal. Output If it is impossible to reorder n given strings in required order, print "NO" (without quotes). Otherwise print "YES" (without quotes) and n given strings in required order. Examples Input 5 a aba abacaba ba aba Output YES a ba aba aba abacaba Input 5 a abacaba ba aba abab Output NO Input 3 qwerty qwerty qwerty Output YES qwerty qwerty qwerty Note In the second example you cannot reorder the strings because the string "abab" is not a substring of the string "abacaba". The input will be give 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 a of N integers a1, a2, a3, ... aN you have to find the longest alternating sub-sequence of this array . An alternating sequence b1, b2 ... bk, k ≥ 1 is a sequence that has the 2 following properties: 1.\|b1\|<\|b2\|<\|b3\|<.....<\|bk\| 2. The signs alternate between adjacent elements, i.e, if b1 > 0 then b2<0, b3 >0 and so on. Alternatively, if b1<0, then b2>0, b3<0 and so on. A sub sequence of array a is a sequence obtained by dropping some elements of the array a. Here is the formal definition. It is guaranteed that the array a contains no element equal to 0. Input: The first line contains a single integer N, denoting the size of the array. The next line contains N integers , denoting the array a. Output: Print a single integer - the length of the longest alternating sub-sequence. Constraints: 1 ≤ N ≤ 5000 \|ai\| ≤ 10^9, ai not equal to 0 SAMPLE INPUT 8 1 2 -2 -3 5 -7 -8 10 SAMPLE OUTPUT 5 Explanation One of the longest alternating subsequence is 1 -2 5 -7 10 The input will be give 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. Monk has a very good friend, Puchi. As weird as his name, are the games he plays. One fine day, they decided to play a game to test how diverse their choices are. Both of them choose exactly one integer each. Monk chooses an integer M and Puchi chooses an integer P. The diversity of their choices is defined as the number of bits whose status is different in the binary representation of M and P , i.e. , count of bits that are ,either set in M and unset in P or set in P and unset in M. Find the answer to their game. Input: First line contains T. T test cases follow. Each test case consists of 2 space-separated integers P and M. Output: Print the answer to each test case in a new line. Constraints: 1 ≤ T ≤ 10^4 0 ≤ M, P ≤ 10^16 SAMPLE INPUT 4 1 4 3 3 5 1 8 7 SAMPLE OUTPUT 2 0 1 4 Explanation 1 (0001) and 4 (0100) differ in 2 bits. The two numbers are identical. 5 (0101) and 1(0001) differ in 1 bit. 8 (1000) and 7(0111) differ in 4 bits. The input will be give 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 professor Ka has given a string task to Oz and RK. He has given a string STR consisting only of characters '(' and ')' and asked them to convert the string STR into a closed one by adding parenthesis to start and/or end of string STR. This means that they could add characters either only to the start of string or only to to the end of string or both. According to professor, a string is said to be closed if it's each left parenthesis '(' can be paired with a right parenthesis ')' which occurs later in the string. As Oz and RK are in hurry beacuse of their other assignments so they wants to add minimum number of parenthesis to start and/or end of string STR to make it a closed one. Help Oz and RK in this string task. Input: First line contain an integer T - number of test cases. Each test case contains string STR consisting of characters '(' and ')' only. Output: For each test case output the required string. Constraints: 1 ≤ T ≤ 20 1 ≤ Length Of STR ≤ 10^3 SAMPLE INPUT 1 )( SAMPLE OUTPUT ()() Explanation Add one '(' to the start and one ')' to the end The input will be give 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. Roy is going to organize Finals of Coding Contest in his college's computer labs. According to the rules of contest, problem statements will be available on each computer as pdf file. Now there are N number of computers and only one of them has the pdf file. Roy has collected M number of pendrives from his friends. Copying pdf from computer to pendrive or from pendrive to computer takes exactly 1 minute. Roy has to copy pdf to all N computers in minimum (optimal) time possible. You are to find this minimum time. Please see Sample Test Explanation for clarity. Input: First line will contain integer T - number of test cases. Next T lines each will contain two space separated integers, N - number of computers, M - number of pendrives. Output: Print the minimum time (in minutes) for each test case in a new line. Constraints: 1 ≤ T ≤ 10000 1 ≤ N,M ≤ 1000000000 (10^9) SAMPLE INPUT 1 10 3SAMPLE OUTPUT 5Explanation Just for the sake of understanding, let us number computers from 1 to 10 and pendrives from 1 to 3. Initially only 1st computer has the pdf. 1st minute: Roy copies the pdf from 1st computer to 1st pendrive, so 1 computer and 1 pendrive has the pdf 2nd minute: He copies the pdf from 1st pendrive to 2nd computer and alongside he copies pdf from 1st computer to 2nd pendrive. 3rd minute: Now he has two pendrives with pdf, so he copies the pdf to 3rd and 4th computer using 1st and 2nd pendrive. Alongside he already copied pdf to 1st and 2nd computer and has one pendrive blank. So he copies pdf into 3rd pendrive using any of the 1st or 2nd computer. 4th minute: Now first 4 computers are done and we have pdf in all 3 pendrives. So he simply copies pdf into 5th, 6th and 7th computer using three pendrive respectively. 5th minute: He copies the pdf into 8th, 9th and 10th computers using three pendrives respectively. The input will be give 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. Utkarsh is going to Cherrapunji to visit his brother Saharsh. Cherrapunji faces one of largest rainfall in the country. So, Saharsh and Utkarsh decided to measure this rainfall by T Rain Gauges. They were going to measure it by taking the product of the readings of all the gauges. But, they found out that the gauges were not working properly and were producing random values. The brothers want to know what will be the expected result of the experiment. The i^th Rain Gauge has a least count of 1/Ri units. It has Ni divisions on its surface. Formally, it can give any reading from the set {0, 1/Ri , 2/Ri , ... ,Ni/Ri}. It gives a reading x with a probability proportional to x^2. Input Format: The first line contains the integer T. T lines follow each containing 2 integers - Ni and Ri. Output format: Print the answer to the problem as real number exactly 4 decimal places. It is guaranteed that the answer is always less than 10^9. Constraints: 1 ≤ T ≤ 10^3 1 ≤ Ni ≤ 10^3 1 ≤ Ri ≤ 10^3 NOTE: A function p(x) is said to be proportional to x^2 means p(x) = ax^2 for some non negative a. All the rain gauges produce values independently from each other. SAMPLE INPUT 2 2 4 2 5 SAMPLE OUTPUT 0.1620 Explanation First gauge produces output 1/4 with probability = 0.2 2/4 with probability = 0.8 Second gauge produces output 1/5 with probability = 0.2 2/5 with probability = 0.8 The product is 1/4 * 1/5 ( = 0.05) with a probability of 0.2 * 0.2 ( = 0.04) The product is 1/4 * 2/5 ( = 0.1) with a probability of 0.2 * 0.8 ( = 0.16) The product is 2/4 * 1/5 ( = 0.1) with a probability of 0.8 * 0.2 ( = 0.16) The product is 2/4 * 2/5 ( = 0.2) with a probability of 0.8 * 0.8 ( = 0.64) Therefore the result is 0.05 with probability = 0.04 0.1 with probability = .016+0.16 = 0.32 0.2 with probability = 0.64 The Expected Result is therefore = 0.05 * 0.04 + 0.1 * 0.32 + 0.2 * 0.64 = 0.1620 The input will be give 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 will turn on the air conditioner if, and only if, the temperature of the room is 30 degrees Celsius or above. The current temperature of the room is X degrees Celsius. Will you turn on the air conditioner? Constraints * -40 \leq X \leq 40 * X is an integer. Input Input is given from Standard Input in the following format: X Output Print `Yes` if you will turn on the air conditioner; print `No` otherwise. Examples Input 25 Output No Input 30 Output Yes The input will be give 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 circular pond with a perimeter of K meters, and N houses around them. The i-th house is built at a distance of A_i meters from the northmost point of the pond, measured clockwise around the pond. When traveling between these houses, you can only go around the pond. Find the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses. Constraints * 2 \leq K \leq 10^6 * 2 \leq N \leq 2 \times 10^5 * 0 \leq A_1 < ... < A_N < K * All values in input are integers. Input Input is given from Standard Input in the following format: K N A_1 A_2 ... A_N Output Print the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses. Examples Input 20 3 5 10 15 Output 10 Input 20 3 0 5 15 Output 10 The input will be give 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. N programmers are going to participate in the preliminary stage of DDCC 20XX. Due to the size of the venue, however, at most 9 contestants can participate in the finals. The preliminary stage consists of several rounds, which will take place as follows: * All the N contestants will participate in the first round. * When X contestants participate in some round, the number of contestants advancing to the next round will be decided as follows: * The organizer will choose two consecutive digits in the decimal notation of X, and replace them with the sum of these digits. The number resulted will be the number of contestants advancing to the next round. For example, when X = 2378, the number of contestants advancing to the next round will be 578 (if 2 and 3 are chosen), 2108 (if 3 and 7 are chosen), or 2315 (if 7 and 8 are chosen). When X = 100, the number of contestants advancing to the next round will be 10, no matter which two digits are chosen. * The preliminary stage ends when 9 or fewer contestants remain. Ringo, the chief organizer, wants to hold as many rounds as possible. Find the maximum possible number of rounds in the preliminary stage. Since the number of contestants, N, can be enormous, it is given to you as two integer sequences d_1, \ldots, d_M and c_1, \ldots, c_M, which means the following: the decimal notation of N consists of c_1 + c_2 + \ldots + c_M digits, whose first c_1 digits are all d_1, the following c_2 digits are all d_2, \ldots, and the last c_M digits are all d_M. Constraints * 1 \leq M \leq 200000 * 0 \leq d_i \leq 9 * d_1 \neq 0 * d_i \neq d_{i+1} * c_i \geq 1 * 2 \leq c_1 + \ldots + c_M \leq 10^{15} Input Input is given from Standard Input in the following format: M d_1 c_1 d_2 c_2 : d_M c_M Output Print the maximum possible number of rounds in the preliminary stage. Examples Input 2 2 2 9 1 Output 3 Input 3 1 1 0 8 7 1 Output 9 The input will be give 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. E869120 has A 1-yen coins and infinitely many 500-yen coins. Determine if he can pay exactly N yen using only these coins. Constraints * N is an integer between 1 and 10000 (inclusive). * A is an integer between 0 and 1000 (inclusive). Input Input is given from Standard Input in the following format: N A Output If E869120 can pay exactly N yen using only his 1-yen and 500-yen coins, print `Yes`; otherwise, print `No`. Examples Input 2018 218 Output Yes Input 2763 0 Output No Input 37 514 Output Yes The input will be give 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 grid with N rows and M columns of squares. Initially, all the squares are white. There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted. Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid. Constraints * 1 \leq N,M \leq 1000 * 0 \leq K \leq NM Input Input is given from Standard Input in the following format: N M K Output If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`. Examples Input 2 2 2 Output Yes Input 2 2 1 Output No Input 3 5 8 Output Yes Input 7 9 20 Output No The input will be give 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. Joisino has a bar of length N, which has M marks on it. The distance from the left end of the bar to the i-th mark is X_i. She will place several squares on this bar. Here, the following conditions must be met: * Only squares with integral length sides can be placed. * Each square must be placed so that its bottom side touches the bar. * The bar must be completely covered by squares. That is, no square may stick out of the bar, and no part of the bar may be left uncovered. * The boundary line of two squares may not be directly above a mark. <image> Examples of arrangements that satisfy/violate the conditions The beauty of an arrangement of squares is defined as the product of the areas of all the squares placed. Joisino is interested in the sum of the beauty over all possible arrangements that satisfy the conditions. Write a program to find it. Since it can be extremely large, print the sum modulo 10^9+7. Constraints * All input values are integers. * 1 \leq N \leq 10^9 * 0 \leq M \leq 10^5 * 1 \leq X_1 < X_2 < ... < X_{M-1} < X_M \leq N-1 Input Input is given from Standard Input in the following format: N M X_1 X_2 ... X_{M-1} X_M Output Print the sum of the beauty over all possible arrangements that satisfy the conditions, modulo 10^9+7. Examples Input 3 1 2 Output 13 Input 5 2 2 3 Output 66 Input 10 9 1 2 3 4 5 6 7 8 9 Output 100 Input 1000000000 0 Output 693316425 The input will be give 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. Rng is baking cookies. Initially, he can bake one cookie per second. He can also eat the cookies baked by himself. When there are x cookies not yet eaten, he can choose to eat all those cookies. After he finishes eating those cookies, the number of cookies he can bake per second becomes x. Note that a cookie always needs to be baked for 1 second, that is, he cannot bake a cookie in 1/x seconds when x > 1. When he choose to eat the cookies, he must eat all of them; he cannot choose to eat only part of them. It takes him A seconds to eat the cookies regardless of how many, during which no cookies can be baked. He wants to give N cookies to Grandma. Find the shortest time needed to produce at least N cookies not yet eaten. Constraints * 1≦N≦10^{12} * 0≦A≦10^{12} * A is an integer. Input The input is given from Standard Input in the following format: N A Output Print the shortest time needed to produce at least N cookies not yet eaten. Examples Input 8 1 Output 7 Input 1000000000000 1000000000000 Output 1000000000000 The input will be give 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. "Fukusekiken" is a popular ramen shop where you can line up. But recently, I've heard some customers say, "I can't afford to have vacant seats when I enter the store, even though I have a long waiting time." I'd like to find out why such dissatisfaction occurs, but I'm too busy to check the actual procession while the shop is open. However, since I know the interval and number of customers coming from many years of experience, I decided to analyze the waiting time based on that. There are 17 seats in the store facing the counter. The store opens at noon, and customers come as follows. * 100 groups from 0 to 99 will come. * The i-th group will arrive at the store 5i minutes after noon. * The number of people in the i-th group is 5 when i% 5 is 1, and 2 otherwise. (x% y represents the remainder when x is divided by y.) * The i-th group finishes the meal in 17 (i% 2) + 3 (i% 3) + 19 minutes when seated. The arrival times, number of people, and meal times for the first 10 groups are as follows: Group number \| 0 \| 1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 8 \| 9 --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- Arrival time (minutes later) \| 0 \| 5 \| 10 \| 15 \| 20 \| 25 \| 30 \| 35 \| 40 \| 45 Number of people (people) \| 2 \| 5 \| 2 \| 2 \| 2 \| 2 \| 5 \| 2 \| 2 \| 2 Meal time (minutes) \| 19 \| 39 \| 25 \| 36 \| 22 \| 42 \| 19 \| 39 \| 25 \| 36 In addition, when guiding customers to their seats, we do the following. * Seats are numbered from 0 to 16. * A group of x people can only be seated when there are x open seats in a row. Also, if there are multiple places to sit, sit in the place with the lowest seat number. For example, if only seats 0, 1, 2, 4, and 5 are available, a group of 5 people cannot be seated. If you are in a group of two, you will be seated at number 0 and 1. * Once you are seated, you will not be asked to move your seat. * Customers come and go in 1 minute increments. At each time, we will guide customers in the following order. 1. The next group can be seated at the same time as the previous group leaves. 2. When seating customers, seat as many groups as possible at the same time, starting with the group at the top of the line. It does not overtake the order of the matrix. In other words, if the first group cannot be seated, even if other groups in the procession can be seated, they will not be seated. 3. Groups arriving at that time will line up at the end of the procession, if any. If there is no line and you can sit down, you will be seated, and if you cannot, you will wait in line. As an example, the following shows how the first 10 groups arrive. From left to right, the three columns in each row show the time, seating, and queue. For seats, the "_" is vacant and the number indicates that the group with that number is sitting in that seat. Time: Seat procession 0: 00 _______________: 5: 0011111 ___________: 10: 001111122 ________: 15: 00111112233______: 18: 00111112233______: 19: __111112233______: 20: 44111112233 ______: 25: 4411111223355____: 30: 4411111223355____: 66666 Group 6 arrives 34: 4411111223355____: 66666 35: 4411111__3355____: 6666677 Group 7 arrives 40: 4411111__3355____: 666667788 Group 8 arrives 41: 4411111__3355____: 666667788 42: __11111__3355____: 666667788 43: __11111__3355____: 666667788 44: 6666677883355____: Groups 6, 7 and 8 are seated 45: 666667788335599__: Group 9 arrives and sits down For example, at time 40, the eighth group arrives, but cannot be seated and joins the procession. The fourth group eats until time 41. At time 42, seats in the 4th group are available, but the 6th group is not yet seated due to the lack of consecutive seats. The first group eats until time 43. At time 44, the first group will be vacant, so the sixth group will be seated, and at the same time the seventh and eighth groups will be seated. The ninth group arrives at time 45 and will be seated as they are available. Based on this information, create a program that outputs the time (in minutes) that the nth group of customers waits by inputting an integer n that is 0 or more and 99 or less. Input Given multiple datasets. Each dataset consists of one integer n. The number of datasets does not exceed 20. Output For each dataset, print the minute wait time (integer greater than or equal to 0) for the nth customer on a single line. Example Input 5 6 7 8 Output 0 14 9 4 The input will be give 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 was a powerful school where powerful people gathered. At the athletic meet of the powerful school, powerful people march in a formation. While the powerhouses always want to show off their power, most of them don't want to walk on their own. So I thought that some of them would be at the bottom, and a lot of people would be lifted up in a row and walked on top of it to reduce the number of people actually walking. First, the N powerhouses are lined up in a row on the ground, called 1, 2, 3, ..., N from the left, respectively. The powerful weight of serial number i can be up to the weight of ci with wi. A strong man can lift either the left or right strong man standing next to him only when all of the following conditions are met. * There is no power above or below me. In other words, no one has lifted it, and no one has lifted it. * The weight of the next strong man is less than or equal to the maximum weight that you can have. However, if the next powerhouse is already lifting someone, the total weight of the vertically stacked powerhouses must be less than or equal to the maximum weight you can have. For example, consider the following three powerful formations. <image> As shown in the figure below, when the weight that 2 powerhouses can have is w3 or more, 2 powerhouses can lift 3 powerhouses. Then, when the weight that 1 powerhouse can have is w2 + w3 or more, 1 powerhouse can lift 2 powerhouses. <image> \|-> \| <image> --- \| --- \| --- Also, as shown in the figure below, if the power of 3 lifts the power of 2, the power of 1 will be the power of 3 with the power of 2, so the power of 1 will lift the power of 3. can do. <image> \|-> \| <image> --- \| --- \| --- The power of 2 cannot have both powers of 1 and 3 as shown in the figure below. <image> As a dedicated programmer at a powerful school, seek the minimum number of people to walk at the bottom. input The input is given in the following format. N c1 w1 c2 w2 :: cN wN The number of powerful people N (1 ≤ N ≤ 1000) is given in the first line. The following N lines give the maximum weight ci (1 ≤ ci ≤ 100000) and the weight wi (1 ≤ wi ≤ 100000) that the i-th power can have. output Output the minimum number of people on one line. Example Input 3 150 120 100 50 80 100 Output 1 The input will be give 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 You decide to invite your friends of the school and your friends of a friend to the Christmas party. The number of students in your school is n, and each student is assigned a number from 1 to n. Your number is 1. You have a list of who and who are your friends. Based on this list, create a program that asks for the number of students you will invite to your Christmas party. input The input consists of multiple datasets. Each dataset is given in the following format. The first line of the dataset contains the number of students in the school n (2 ≤ n ≤ 500), and the second line contains the length of the list m (1 ≤ m ≤ 10000). The input consists of 2 + m lines in total. Line 2 + i (1 ≤ i ≤ m) contains two integers ai and bi (1 ≤ ai <bi ≤ n) separated by blanks, and the students with numbers ai and bi are friends. Represents that. From the 3rd line to the 2 + m line, the lines representing the same friendship do not appear twice. When both n and m are 0, it indicates the end of input. The number of data sets does not exceed 5. output For each dataset, print the number of students you invite to the Christmas party on one line. Examples Input 6 5 1 2 1 3 3 4 2 3 4 5 6 5 2 3 3 4 4 5 5 6 2 5 0 0 Output 3 0 Input None Output None The input will be give 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. I came to the summer festival with the elementary school students in my neighborhood. To put it bluntly, it plays the role of a guardian, but the smell of yakisoba and takoyaki in the store, and the sound of fireworks that can be heard from time to time, are still exciting even at this age. But today I have to keep an eye on the curious children so they don't get lost. The children seemed to be interested in opening a store. When I looked into it, I was supposed to play a game using dice with the uncle who opened the store, and if I win, I would get a prize. The game is a simple one called High & Low. Participants and uncles roll one dice each, but before that, participants predict whether their rolls will be greater or lesser than their uncle's rolls. If the prediction is correct, it is a victory, and if the same result is rolled, both roll the dice again. The tricky part of this game is that the dice of the participants and the dice of the uncle may be different. Participants can see the development of both dice in advance, so they can expect it as a hint. In other words, it's a simple probability calculation. However, the probability is in the range of high school mathematics, and it may be a little heavy for elementary school students. Even the most clever of the kids are thinking, shaking their braided hair. I'll be asking for help soon. By the way, let's show you something that seems to be an adult once in a while. Input The input consists of multiple cases. In each case, a development of the dice is given in a 21x57 grid. The first 21x28 ((0,0) is the upper left, (20,27) is the lower right) grid represents the participants' dice. The last 21x28 ((0,29) is the upper left, (20,56) is the lower right) represents the uncle's dice. Each side of the participant's dice is 7x7 with (0,7), (7,0), (7,7), (7,14), (7,21), (14,7) as the upper left. Given in the subgrid of. The numbers written on the development drawing are the original numbers. Flip horizontal Flip left and right, then rotate 90 degrees counterclockwise Flip horizontal Flip left and right, then rotate 270 degrees counterclockwise Flip horizontal Flip upside down, then flip left and right It was made to do. Each side of the uncle's dice is 7x7 with (0,36), (7,29), (7,36), (7,43), (7,50), (14,36) as the upper left. Given in the subgrid. The numbers on the uncle's dice development are drawn according to the same rules as the participants' dice. One of 1 to 9 is written on each side of the dice. The numbers are given in a 7x7 grid like this: ..... # ... \|. # ..... # ... \|. # ..-.. # ..-.. # ... \|. # ..-.. # . \| ... # ..-.. # ..-.. # ... \|. # ..-.. # ... \|. # ..-.. # ..... # . \|. \|. # ..-.. # ... \|. # ..... # ..-.. # . \| ... # ..-.. # ... \|. # ..-.. # ..-.. # . \| ... # ..-.. # . \|. \|. # ..-.. # ..-.. # ... \|. # ..... # ... \|. # ..... # ..-.. # . \|. \|. # ..-.. # . \|. \|. # ..-.. # ..-.. # . \|. \|. # ..-.. # ... \|. # ..-.. # However, when the above numbers are rotated 90 degrees or 270 degrees, the "\|" and "-" are interchanged. The end of the input is given by a single 0 line The dice given as input are always correct. Also, dice that cannot be settled are not given. Output Output the one with the higher probability in one line when it becomes "HIGH" and when it becomes "LOW". If both probabilities are the same, output "HIGH". Examples Input .......#######......................#######.............. .......#.....#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#.....#......................#..-..#.............. .......#.\|...#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. ############################.############################ #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# #.-.-.##...\|.##.-.-.##.\|.\|.#.#.....##.\|.\|.##.-.-.##.\|.\|.# #\|.\|.\|##..-..##\|.\|.\|##..-..#.#....\|##..-..##\|.\|.\|##..-..# #...-.##.\|...##...-.##.\|.\|.#.#.-.-.##.\|...##...-.##.\|...# #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# ############################.############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#.\|.\|.#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. ############################.############################ #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# #.-.-.##...\|.##.-.-.##.\|.\|.#.#...-.##...\|.##.-...##.\|.\|.# #\|.\|.\|##..-..##\|.\|.\|##..-..#.#\|.\|.\|##..-..##\|.\|.\|##..-..# #.-.-.##.\|...##...-.##.\|...#.#.-...##.\|.\|.##.-.-.##.\|...# #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# ############################.############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. ############################.############################ #.....##..-..##.....##..-..#.#.....##..-..##.....##.....# #.-.-.##.\|.\|.##.-.-.##...\|.#.#.....##.\|.\|.##...-.##.\|...# #\|.\|.\|##..-..##\|....##..-..#.#....\|##..-..##\|.\|.\|##.....# #.-.-.##.\|.\|.##.....##.\|.\|.#.#.-.-.##.\|.\|.##.-...##.\|...# #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# ############################.############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|.\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. ############################.############################ #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# #.-.-.##...\|.##.-.-.##.\|.\|.#.#.-...##.\|.\|.##.-...##.\|.\|.# #\|.\|.\|##..-..##\|.\|.\|##..-..#.#\|.\|.\|##..-..##\|.\|.\|##..-..# #...-.##.\|...##.-.-.##.\|.\|.#.#.-.-.##.\|...##.-.-.##.\|.\|.# #.....##..-..##.....##..-..#.#.....##..-..##.....##..-..# ############################.############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. 0 Output LOW HIGH HIGH LOW Input .......#######......................#######.............. .......#.....#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#.....#......................#..-..#.............. .......#.\|...#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .############################ .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .-.-.##...\|.##.-.-.##.\|.\|.#.#.....##.\|.\|.##.-.-.##.\|.\|.# \|.\|.\|##..-..##\|.\|.\|##..-..#.#....\|##..-..##\|.\|.\|##..-..# ...-.##.\|...##...-.##.\|.\|.#.#.-.-.##.\|...##...-.##.\|...# .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#.\|.\|.#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .############################ .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .-.-.##...\|.##.-.-.##.\|.\|.#.#...-.##...\|.##.-...##.\|.\|.# \|.\|.\|##..-..##\|.\|.\|##..-..#.#\|.\|.\|##..-..##\|.\|.\|##..-..# .-.-.##.\|...##...-.##.\|...#.#.-...##.\|.\|.##.-.-.##.\|...# .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .############################ .....##..-..##.....##..-..#.#.....##..-..##.....##.....# .-.-.##.\|.\|.##.-.-.##...\|.#.#.....##.\|.\|.##...-.##.\|...# \|.\|.\|##..-..##\|....##..-..#.#....\|##..-..##\|.\|.\|##.....# .-.-.##.\|.\|.##.....##.\|.\|.#.#.-.-.##.\|.\|.##.-...##.\|...# .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|.\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|...#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. .############################ .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .-.-.##...\|.##.-.-.##.\|.\|.#.#.-...##.\|.\|.##.-...##.\|.\|.# \|.\|.\|##..-..##\|.\|.\|##..-..#.#\|.\|.\|##..-..##\|.\|.\|##..-..# ...-.##.\|...##.-.-.##.\|.\|.#.#.-.-.##.\|...##.-.-.##.\|.\|.# .....##..-..##.....##..-..#.#.....##..-..##.....##..-..# .############################ .......#######......................#######.............. .......#..-..#......................#..-..#.............. .......#...\|.#......................#.\|.\|.#.............. .......#..-..#......................#..-..#.............. .......#.\|...#......................#...\|.#.............. .......#..-..#......................#..-..#.............. .......#######......................#######.............. 0 Output LOW HIGH HIGH LOW The input will be give 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 surveyor starship Hakodate-maru is famous for her two fuel containers with unbounded capacities. They hold the same type of atomic fuel balls. There, however, is an inconvenience. The shapes of the fuel containers #1 and #2 are always cubic and regular tetrahedral respectively. Both of the fuel containers should be either empty or filled according to their shapes. Otherwise, the fuel balls become extremely unstable and may explode in the fuel containers. Thus, the number of fuel balls for the container #1 should be a cubic number (n3 for some n = 0, 1, 2, 3,... ) and that for the container #2 should be a tetrahedral number ( n(n + 1)(n + 2)/6 for some n = 0, 1, 2, 3,... ). Hakodate-maru is now at the star base Goryokaku preparing for the next mission to create a precise and detailed chart of stars and interstellar matters. Both of the fuel containers are now empty. Commander Parus of Goryokaku will soon send a message to Captain Future of Hakodate-maru on how many fuel balls Goryokaku can supply. Captain Future should quickly answer to Commander Parus on how many fuel balls she requests before her ship leaves Goryokaku. Of course, Captain Future and her omcers want as many fuel balls as possible. For example, consider the case Commander Parus offers 151200 fuel balls. If only the fuel container #1 were available (i.e. ifthe fuel container #2 were unavailable), at most 148877 fuel balls could be put into the fuel container since 148877 = 53 × 53 × 53 < 151200 < 54 × 54 × 54 . If only the fuel container #2 were available, at most 147440 fuel balls could be put into the fuel container since 147440 = 95 × 96 × 97/6 < 151200 < 96 × 97 × 98/6 . Using both of the fuel containers #1 and #2, 151200 fuel balls can be put into the fuel containers since 151200 = 39 × 39 × 39 + 81 × 82 × 83/6 . In this case, Captain Future's answer should be "151200". Commander Parus's offer cannot be greater than 151200 because of the capacity of the fuel storages of Goryokaku. Captain Future and her omcers know that well. You are a fuel engineer assigned to Hakodate-maru. Your duty today is to help Captain Future with calculating the number of fuel balls she should request. Input The input is a sequence of at most 1024 positive integers. Each line contains a single integer. The sequence is followed by a zero, which indicates the end of data and should not be treated as input. You may assume that none of the input integers is greater than 151200. Output The output is composed of lines, each containing a single integer. Each output integer should be the greatest integer that is the sum of a nonnegative cubic number and a nonnegative tetrahedral number and that is not greater than the corresponding input number. No other characters should appear in the output. Example Input 100 64 50 20 151200 0 Output 99 64 47 20 151200 The input will be give 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 tree that has n nodes and n-1 edges. There are military bases on t out of the n nodes. We want to disconnect the bases as much as possible by destroying k edges. The tree will be split into k+1 regions when we destroy k edges. Given the purpose to disconnect the bases, we only consider to split in a way that each of these k+1 regions has at least one base. When we destroy an edge, we must pay destroying cost. Find the minimum destroying cost to split the tree. Input The input consists of multiple data sets. Each data set has the following format. The first line consists of three integers n, t, and k (1 \leq n \leq 10,000, 1 \leq t \leq n, 0 \leq k \leq t-1). Each of the next n-1 lines consists of three integers representing an edge. The first two integers represent node numbers connected by the edge. A node number is a positive integer less than or equal to n. The last one integer represents destroying cost. Destroying cost is a non-negative integer less than or equal to 10,000. The next t lines contain a distinct list of integers one in each line, and represent the list of nodes with bases. The input ends with a line containing three zeros, which should not be processed. Output For each test case, print its case number and the minimum destroying cost to split the tree with the case number. Example Input 2 2 1 1 2 1 1 2 4 3 2 1 2 1 1 3 2 1 4 3 2 3 4 0 0 0 Output Case 1: 1 Case 2: 3 The input will be give 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 Gaccho loses motivation as the final exam approaches and often misses school. There are N days left until the final exam. Gaccho's motivation on day i is Xi, and the motivation needed to go to school on day i is Yi. Gaccho goes to school only on days when Xi ≥ Yi. Haji, who was worried about Gaccho, decided to encourage him to go to school as much as possible. Haji has an encouraging power P at first. When Haji encourages Gacho by consuming the encouragement force t (t is any real number greater than or equal to 0) on day i, Gacho's motivation on day i increases by t, and Haji Your encouragement is reduced by t. Furthermore, when i & plus; 1 ≤ N, Gacho-kun's motivation Xi & plus; 1 on the first day of i & plus; changes to max (0, Xi & plus; 1 − t). Haji cannot encourage beyond his own encouraging power. Find the maximum number of days Gacho will go to school when Haji gives the best encouragement. Constraints The input satisfies the following conditions. * 1 ≤ N ≤ 100 * 0 ≤ P ≤ 106 * 0 ≤ Xi ≤ 106 * 0 ≤ Yi ≤ 106 Input The input is given in the following format. N P X1 Y1 X2 Y2 ... XN YN All inputs are given as integers. On the first line, the number of days until the final exam and the encouraging power P that Haji has first are given separated by blanks. The N lines that continue from the second line are given the motivation Xi of the i (i = 1,2, ..., N) day of Gacho-kun and the motivation Yi necessary to go to school, separated by blanks. Output Print out the maximum number of days you can go to school on one line. Examples Input 3 10 1 6 5 10 0 5 Output 2 Input 5 5 1 1 1 2 1 2 1 3 1 3 Output 4 The input will be give 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 reads an directed graph $G = (V, E)$, and finds the shortest distance from vertex $1$ to each vertex (the number of edges in the shortest path). Vertices are identified by IDs $1, 2, ... n$. Constraints * $1 \leq n \leq 100$ Input In the first line, an integer $n$ denoting the number of vertices, is given. In the next $n$ lines, adjacent lists of vertex $u$ are given in the following format: $u$ $k$ $v_1$ $v_2$ ... $v_k$ $u$ is ID of the vertex and $k$ denotes its degree.$v_i$ are IDs of vertices adjacent to $u$. Output For each vertex $u$, print $id$ and $d$ in a line. $id$ is ID of vertex $u$ and $d$ is the distance from vertex $1$ to vertex $u$. If there are no path from vertex $1$ to vertex $u$, print -1 as the shortest distance. Print in order of IDs. Example Input 4 1 2 2 4 2 1 4 3 0 4 1 3 Output 1 0 2 1 3 2 4 1 The input will be give 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 reads the two dices constructed in the same way as Dice I, and determines whether these two dices are identical. You can roll a dice in the same way as Dice I, and if all integers observed from the six directions are the same as that of another dice, these dices can be considered as identical. Constraints * $0 \leq $ the integer assigned to a face $ \leq 100$ Input In the first line, six integers assigned to faces of a dice are given in ascending order of their corresponding labels. In the second line, six integers assigned to faces of another dice are given in ascending order of their corresponding labels. Output Print "Yes" if two dices are identical, otherwise "No" in a line. Examples Input 1 2 3 4 5 6 6 2 4 3 5 1 Output Yes Input 1 2 3 4 5 6 6 5 4 3 2 1 Output No The input will be give 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 bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp. The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{\|a\|} < M. All a_i must be integers. Of course, preinstalled program is a good program. The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state. Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a. Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up. Input First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off. Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a. Output Print the only integer — maximum possible total time when the lamp is lit. Examples Input 3 10 4 6 7 Output 8 Input 2 12 1 10 Output 9 Input 2 7 3 4 Output 6 Note In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place. In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9. In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6. The input will be give 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. Is there anything better than going to the zoo after a tiresome week at work? No wonder Grisha feels the same while spending the entire weekend accompanied by pretty striped zebras. Inspired by this adventure and an accidentally found plasticine pack (represented as a sequence of black and white stripes), Grisha now wants to select several consequent (contiguous) pieces of alternating colors to create a zebra. Let's call the number of selected pieces the length of the zebra. Before assembling the zebra Grisha can make the following operation 0 or more times. He splits the sequence in some place into two parts, then reverses each of them and sticks them together again. For example, if Grisha has pieces in the order "bwbbw" (here 'b' denotes a black strip, and 'w' denotes a white strip), then he can split the sequence as bw\|bbw (here the vertical bar represents the cut), reverse both parts and obtain "wbwbb". Determine the maximum possible length of the zebra that Grisha can produce. Input The only line contains a string s (1 ≤ \|s\| ≤ 10^5, where \|s\| denotes the length of the string s) comprised of lowercase English letters 'b' and 'w' only, where 'w' denotes a white piece and 'b' denotes a black piece. Output Print a single integer — the maximum possible zebra length. Examples Input bwwwbwwbw Output 5 Input bwwbwwb Output 3 Note In the first example one of the possible sequence of operations is bwwwbww\|bw → w\|wbwwwbwb → wbwbwwwbw, that gives the answer equal to 5. In the second example no operation can increase the answer. The input will be give 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. Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog. Let us define k-multihedgehog as follows: * 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1. * For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift. Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog. Input First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter. Next n-1 lines contains two integers u v (1 ≤ u, v ≤ n; u ≠ v) — indices of vertices connected by edge. It is guaranteed that given graph is a tree. Output Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise. Examples Input 14 2 1 4 2 4 3 4 4 13 10 5 11 5 12 5 14 5 5 13 6 7 8 6 13 6 9 6 Output Yes Input 3 1 1 3 2 3 Output No Note 2-multihedgehog from the first example looks like this: <image> Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13]. Tree from second example is not a hedgehog because degree of center should be at least 3. The input will be give 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. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number n is a nearly lucky number. Input The only line contains an integer n (1 ≤ n ≤ 1018). Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. Output Print on the single line "YES" if n is a nearly lucky number. Otherwise, print "NO" (without the quotes). Examples Input 40047 Output NO Input 7747774 Output YES Input 1000000000000000000 Output NO Note In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO". In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES". In the third sample there are no lucky digits, so the answer is "NO". The input will be give 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. Vivek initially has an empty array a and some integer constant m. He performs the following algorithm: 1. Select a random integer x uniformly in range from 1 to m and append it to the end of a. 2. Compute the greatest common divisor of integers in a. 3. In case it equals to 1, break 4. Otherwise, return to step 1. Find the expected length of a. It can be shown that it can be represented as P/Q where P and Q are coprime integers and Q≠ 0 \pmod{10^9+7}. Print the value of P ⋅ Q^{-1} \pmod{10^9+7}. Input The first and only line contains a single integer m (1 ≤ m ≤ 100000). Output Print a single integer — the expected length of the array a written as P ⋅ Q^{-1} \pmod{10^9+7}. Examples Input 1 Output 1 Input 2 Output 2 Input 4 Output 333333338 Note In the first example, since Vivek can choose only integers from 1 to 1, he will have a=[1] after the first append operation, and after that quit the algorithm. Hence the length of a is always 1, so its expected value is 1 as well. In the second example, Vivek each time will append either 1 or 2, so after finishing the algorithm he will end up having some number of 2's (possibly zero), and a single 1 in the end. The expected length of the list is 1⋅ 1/2 + 2⋅ (1)/(2^2) + 3⋅ (1)/(2^3) + … = 2. The input will be give 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. And now the numerous qualifying tournaments for one of the most prestigious Russian contests Russian Codec Cup are over. All n participants who have made it to the finals found themselves in a huge m-floored 108-star hotel. Of course the first thought to come in a place like this is "How about checking out the elevator?". The hotel's elevator moves between floors according to one never changing scheme. Initially (at the moment of time 0) the elevator is located on the 1-st floor, then it moves to the 2-nd floor, then — to the 3-rd floor and so on until it reaches the m-th floor. After that the elevator moves to floor m - 1, then to floor m - 2, and so on until it reaches the first floor. This process is repeated infinitely. We know that the elevator has infinite capacity; we also know that on every floor people get on the elevator immediately. Moving between the floors takes a unit of time. For each of the n participant you are given si, which represents the floor where the i-th participant starts, fi, which represents the floor the i-th participant wants to reach, and ti, which represents the time when the i-th participant starts on the floor si. For each participant print the minimum time of his/her arrival to the floor fi. If the elevator stops on the floor si at the time ti, then the i-th participant can enter the elevator immediately. If the participant starts on the floor si and that's the floor he wanted to reach initially (si = fi), then the time of arrival to the floor fi for this participant is considered equal to ti. Input The first line contains two space-separated integers n and m (1 ≤ n ≤ 105, 2 ≤ m ≤ 108). Next n lines contain information about the participants in the form of three space-separated integers si fi ti (1 ≤ si, fi ≤ m, 0 ≤ ti ≤ 108), described in the problem statement. Output Print n lines each containing one integer — the time of the arrival for each participant to the required floor. Examples Input 7 4 2 4 3 1 2 0 2 2 0 1 2 1 4 3 5 1 2 2 4 2 0 Output 9 1 0 7 10 7 5 Input 5 5 1 5 4 1 3 1 1 3 4 3 1 5 4 2 5 Output 12 10 10 8 7 Note Let's consider the first sample. The first participant starts at floor s = 2 by the time equal to t = 3. To get to the floor f = 4, he has to wait until the time equals 7, that's the time when the elevator will go upwards for the second time. Then the first participant should get on the elevator and go two floors up. In this case the first participant gets to the floor f at time equal to 9. The second participant starts at the time t = 0 on the floor s = 1, enters the elevator immediately, and arrives to the floor f = 2. The third participant doesn't wait for the elevator, because he needs to arrive to the same floor where he starts. The input will be give 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 country with n citizens. The i-th of them initially has a_{i} money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have. Sometimes the government makes payouts to the poor: all citizens who have strictly less money than x are paid accordingly so that after the payout they have exactly x money. In this case the citizens don't send a receipt. You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events. Input The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the numer of citizens. The next line contains n integers a_1, a_2, ..., a_n (0 ≤ a_{i} ≤ 10^{9}) — the initial balances of citizens. The next line contains a single integer q (1 ≤ q ≤ 2 ⋅ 10^{5}) — the number of events. Each of the next q lines contains a single event. The events are given in chronological order. Each event is described as either 1 p x (1 ≤ p ≤ n, 0 ≤ x ≤ 10^{9}), or 2 x (0 ≤ x ≤ 10^{9}). In the first case we have a receipt that the balance of the p-th person becomes equal to x. In the second case we have a payoff with parameter x. Output Print n integers — the balances of all citizens after all events. Examples Input 4 1 2 3 4 3 2 3 1 2 2 2 1 Output 3 2 3 4 Input 5 3 50 2 1 10 3 1 2 0 2 8 1 3 20 Output 8 8 20 8 10 Note In the first example the balances change as follows: 1 2 3 4 → 3 3 3 4 → 3 2 3 4 → 3 2 3 4 In the second example the balances change as follows: 3 50 2 1 10 → 3 0 2 1 10 → 8 8 8 8 10 → 8 8 20 8 10 The input will be give 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 final match of the Berland Football Cup has been held recently. The referee has shown n yellow cards throughout the match. At the beginning of the match there were a_1 players in the first team and a_2 players in the second team. The rules of sending players off the game are a bit different in Berland football. If a player from the first team receives k_1 yellow cards throughout the match, he can no longer participate in the match — he's sent off. And if a player from the second team receives k_2 yellow cards, he's sent off. After a player leaves the match, he can no longer receive any yellow cards. Each of n yellow cards was shown to exactly one player. Even if all players from one team (or even from both teams) leave the match, the game still continues. The referee has lost his records on who has received each yellow card. Help him to determine the minimum and the maximum number of players that could have been thrown out of the game. Input The first line contains one integer a_1 (1 ≤ a_1 ≤ 1 000) — the number of players in the first team. The second line contains one integer a_2 (1 ≤ a_2 ≤ 1 000) — the number of players in the second team. The third line contains one integer k_1 (1 ≤ k_1 ≤ 1 000) — the maximum number of yellow cards a player from the first team can receive (after receiving that many yellow cards, he leaves the game). The fourth line contains one integer k_2 (1 ≤ k_2 ≤ 1 000) — the maximum number of yellow cards a player from the second team can receive (after receiving that many yellow cards, he leaves the game). The fifth line contains one integer n (1 ≤ n ≤ a_1 ⋅ k_1 + a_2 ⋅ k_2) — the number of yellow cards that have been shown during the match. Output Print two integers — the minimum and the maximum number of players that could have been thrown out of the game. Examples Input 2 3 5 1 8 Output 0 4 Input 3 1 6 7 25 Output 4 4 Input 6 4 9 10 89 Output 5 9 Note In the first example it could be possible that no player left the game, so the first number in the output is 0. The maximum possible number of players that could have been forced to leave the game is 4 — one player from the first team, and three players from the second. In the second example the maximum possible number of yellow cards has been shown (3 ⋅ 6 + 1 ⋅ 7 = 25), so in any case all players were sent off. The input will be give 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 playing a game where your character should overcome different obstacles. The current problem is to come down from a cliff. The cliff has height h, and there is a moving platform on each height x from 1 to h. Each platform is either hidden inside the cliff or moved out. At first, there are n moved out platforms on heights p_1, p_2, ..., p_n. The platform on height h is moved out (and the character is initially standing there). If you character is standing on some moved out platform on height x, then he can pull a special lever, which switches the state of two platforms: on height x and x - 1. In other words, the platform you are currently standing on will hide in the cliff and the platform one unit below will change it state: it will hide if it was moved out or move out if it was hidden. In the second case, you will safely land on it. Note that this is the only way to move from one platform to another. Your character is quite fragile, so it can safely fall from the height no more than 2. In other words falling from the platform x to platform x - 2 is okay, but falling from x to x - 3 (or lower) is certain death. Sometimes it's not possible to come down from the cliff, but you can always buy (for donate currency) several magic crystals. Each magic crystal can be used to change the state of any single platform (except platform on height h, which is unaffected by the crystals). After being used, the crystal disappears. What is the minimum number of magic crystal you need to buy to safely land on the 0 ground level? Input The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query contains two lines and is independent of all other queries. The first line of each query contains two integers h and n (1 ≤ h ≤ 10^9, 1 ≤ n ≤ min(h, 2 ⋅ 10^5)) — the height of the cliff and the number of moved out platforms. The second line contains n integers p_1, p_2, ..., p_n (h = p_1 > p_2 > ... > p_n ≥ 1) — the corresponding moved out platforms in the descending order of their heights. The sum of n over all queries does not exceed 2 ⋅ 10^5. Output For each query print one integer — the minimum number of magic crystals you have to spend to safely come down on the ground level (with height 0). Example Input 4 3 2 3 1 8 6 8 7 6 5 3 2 9 6 9 8 5 4 3 1 1 1 1 Output 0 1 2 0 The input will be give 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 a binary string of length n (i. e. a string consisting of n characters '0' and '1'). In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all. Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move. You have to answer q independent test cases. Input The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform. The second line of the test case contains one string consisting of n characters '0' and '1'. It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6). Output For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves. Example Input 3 8 5 11011010 7 9 1111100 7 11 1111100 Output 01011110 0101111 0011111 Note In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110. In the third example, there are enough operations to make the string sorted. The input will be give 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. Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them. A little later they found a string s, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring t of the string s. Prefix supposed that the substring t is the beginning of the string s; Suffix supposed that the substring t should be the end of the string s; and Obelix supposed that t should be located somewhere inside the string s, that is, t is neither its beginning, nor its end. Asterix chose the substring t so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring t aloud, the temple doors opened. You know the string s. Find the substring t or determine that such substring does not exist and all that's been written above is just a nice legend. Input You are given the string s whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters. Output Print the string t. If a suitable t string does not exist, then print "Just a legend" without the quotes. Examples Input fixprefixsuffix Output fix Input abcdabc Output Just a legend The input will be give 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 spring is coming and it means that a lot of fruits appear on the counters. One sunny day little boy Valera decided to go shopping. He made a list of m fruits he wanted to buy. If Valera want to buy more than one fruit of some kind, he includes it into the list several times. When he came to the fruit stall of Ashot, he saw that the seller hadn't distributed price tags to the goods, but put all price tags on the counter. Later Ashot will attach every price tag to some kind of fruits, and Valera will be able to count the total price of all fruits from his list. But Valera wants to know now what can be the smallest total price (in case of the most «lucky» for him distribution of price tags) and the largest total price (in case of the most «unlucky» for him distribution of price tags). Input The first line of the input contains two integer number n and m (1 ≤ n, m ≤ 100) — the number of price tags (which is equal to the number of different kinds of fruits that Ashot sells) and the number of items in Valera's list. The second line contains n space-separated positive integer numbers. Each of them doesn't exceed 100 and stands for the price of one fruit of some kind. The following m lines contain names of the fruits from the list. Each name is a non-empty string of small Latin letters which length doesn't exceed 32. It is guaranteed that the number of distinct fruits from the list is less of equal to n. Also it is known that the seller has in stock all fruits that Valera wants to buy. Output Print two numbers a and b (a ≤ b) — the minimum and the maximum possible sum which Valera may need to buy all fruits from his list. Examples Input 5 3 4 2 1 10 5 apple orange mango Output 7 19 Input 6 5 3 5 1 6 8 1 peach grapefruit banana orange orange Output 11 30 The input will be give 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. Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task. You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0). Wu is too tired after his training to solve this problem. Help him! Input The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow. The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively. The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph. Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges. Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well. Output For each test case print a single integer — the required greatest common divisor. Example Input 3 2 4 1 1 1 1 1 2 2 1 2 2 3 4 1 1 1 1 1 1 2 2 2 2 3 4 7 36 31 96 29 1 2 1 3 1 4 2 2 2 4 3 1 4 3 Output 2 1 12 Note The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g. In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2. In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1. The input will be give 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 of integers a_1,a_2,…,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t). Input The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 2 ⋅ 10^4) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer n (5≤ n≤ 10^5) — the size of the array. The second line of each test case contains n integers a_1,a_2,…,a_n (-3× 10^3≤ a_i≤ 3× 10^3) — given array. It's guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5. Output For each test case, print one integer — the answer to the problem. Example Input 4 5 -1 -2 -3 -4 -5 6 -1 -2 -3 1 2 -1 6 -1 0 0 0 -1 -1 6 -9 -7 -5 -3 -2 1 Output -120 12 0 945 Note In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)⋅ (-2) ⋅ (-3)⋅ (-4)⋅ (-5)=-120. In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)⋅ (-2) ⋅ (-3)⋅ 2⋅ (-1)=12. In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)⋅ 0⋅ 0⋅ 0⋅ (-1)=0. In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)⋅ (-7) ⋅ (-5)⋅ (-3)⋅ 1=945. The input will be give 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 a paparazzi working in Manhattan. Manhattan has r south-to-north streets, denoted by numbers 1, 2,…, r in order from west to east, and r west-to-east streets, denoted by numbers 1,2,…,r in order from south to north. Each of the r south-to-north streets intersects each of the r west-to-east streets; the intersection between the x-th south-to-north street and the y-th west-to-east street is denoted by (x, y). In order to move from the intersection (x,y) to the intersection (x', y') you need \|x-x'\|+\|y-y'\| minutes. You know about the presence of n celebrities in the city and you want to take photos of as many of them as possible. More precisely, for each i=1,..., n, you know that the i-th celebrity will be at the intersection (x_i, y_i) in exactly t_i minutes from now (and he will stay there for a very short time, so you may take a photo of him only if at the t_i-th minute from now you are at the intersection (x_i, y_i)). You are very good at your job, so you are able to take photos instantaneously. You know that t_i < t_{i+1} for any i=1,2,…, n-1. Currently you are at your office, which is located at the intersection (1, 1). If you plan your working day optimally, what is the maximum number of celebrities you can take a photo of? Input The first line of the input contains two positive integers r, n (1≤ r≤ 500, 1≤ n≤ 100,000) – the number of south-to-north/west-to-east streets and the number of celebrities. Then n lines follow, each describing the appearance of a celebrity. The i-th of these lines contains 3 positive integers t_i, x_i, y_i (1≤ t_i≤ 1,000,000, 1≤ x_i, y_i≤ r) — denoting that the i-th celebrity will appear at the intersection (x_i, y_i) in t_i minutes from now. It is guaranteed that t_i<t_{i+1} for any i=1,2,…, n-1. Output Print a single integer, the maximum number of celebrities you can take a photo of. Examples Input 10 1 11 6 8 Output 0 Input 6 9 1 2 6 7 5 1 8 5 5 10 3 1 12 4 4 13 6 2 17 6 6 20 1 4 21 5 4 Output 4 Input 10 4 1 2 1 5 10 9 13 8 8 15 9 9 Output 1 Input 500 10 69 477 122 73 186 235 341 101 145 372 77 497 390 117 440 494 471 37 522 300 498 682 149 379 821 486 359 855 157 386 Output 3 Note Explanation of the first testcase: There is only one celebrity in the city, and he will be at intersection (6,8) exactly 11 minutes after the beginning of the working day. Since you are initially at (1,1) and you need \|1-6\|+\|1-8\|=5+7=12 minutes to reach (6,8) you cannot take a photo of the celebrity. Thus you cannot get any photo and the answer is 0. Explanation of the second testcase: One way to take 4 photos (which is the maximum possible) is to take photos of celebrities with indexes 3, 5, 7, 9 (see the image for a visualization of the strategy): * To move from the office at (1,1) to the intersection (5,5) you need \|1-5\|+\|1-5\|=4+4=8 minutes, so you arrive at minute 8 and you are just in time to take a photo of celebrity 3. * Then, just after you have taken a photo of celebrity 3, you move toward the intersection (4,4). You need \|5-4\|+\|5-4\|=1+1=2 minutes to go there, so you arrive at minute 8+2=10 and you wait until minute 12, when celebrity 5 appears. * Then, just after you have taken a photo of celebrity 5, you go to the intersection (6,6). You need \|4-6\|+\|4-6\|=2+2=4 minutes to go there, so you arrive at minute 12+4=16 and you wait until minute 17, when celebrity 7 appears. * Then, just after you have taken a photo of celebrity 7, you go to the intersection (5,4). You need \|6-5\|+\|6-4\|=1+2=3 minutes to go there, so you arrive at minute 17+3=20 and you wait until minute 21 to take a photo of celebrity 9. <image> Explanation of the third testcase: The only way to take 1 photo (which is the maximum possible) is to take a photo of the celebrity with index 1 (since \|2-1\|+\|1-1\|=1, you can be at intersection (2,1) after exactly one minute, hence you are just in time to take a photo of celebrity 1). Explanation of the fourth testcase: One way to take 3 photos (which is the maximum possible) is to take photos of celebrities with indexes 3, 8, 10: * To move from the office at (1,1) to the intersection (101,145) you need \|1-101\|+\|1-145\|=100+144=244 minutes, so you can manage to be there when the celebrity 3 appears (at minute 341). * Then, just after you have taken a photo of celebrity 3, you move toward the intersection (149,379). You need \|101-149\|+\|145-379\|=282 minutes to go there, so you arrive at minute 341+282=623 and you wait until minute 682, when celebrity 8 appears. * Then, just after you have taken a photo of celebrity 8, you go to the intersection (157,386). You need \|149-157\|+\|379-386\|=8+7=15 minutes to go there, so you arrive at minute 682+15=697 and you wait until minute 855 to take a photo of celebrity 10. The input will be give 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 the easy and hard versions is that tokens of type O do not appear in the input of the easy version. Errichto gave Monogon the following challenge in order to intimidate him from taking his top contributor spot on Codeforces. In a Tic-Tac-Toe grid, there are n rows and n columns. Each cell of the grid is either empty or contains a token. There are two types of tokens: X and O. If there exist three tokens of the same type consecutive in a row or column, it is a winning configuration. Otherwise, it is a draw configuration. <image> The patterns in the first row are winning configurations. The patterns in the second row are draw configurations. In an operation, you can change an X to an O, or an O to an X. Let k denote the total number of tokens in the grid. Your task is to make the grid a draw in at most ⌊ k/3⌋ (rounding down) operations. You are not required to minimize the number of operations. Input The first line contains a single integer t (1≤ t≤ 100) — the number of test cases. The first line of each test case contains a single integer n (1≤ n≤ 300) — the size of the grid. The following n lines each contain a string of n characters, denoting the initial grid. The character in the i-th row and j-th column is '.' if the cell is empty, or it is the type of token in the cell: 'X' or 'O'. It is guaranteed that not all cells are empty. In the easy version, the character 'O' does not appear in the input. The sum of n across all test cases does not exceed 300. Output For each test case, print the state of the grid after applying the operations. We have proof that a solution always exists. If there are multiple solutions, print any. Example Input 3 3 .X. XXX .X. 6 XX.XXX XXXXXX XXX.XX XXXXXX XX.X.X XXXXXX 5 XXX.X .X..X XXX.X ..X.. ..X.. Output .X. XOX .X. XX.XXO XOXXOX OXX.XX XOOXXO XX.X.X OXXOXX XOX.X .X..X XXO.O ..X.. ..X.. Note In the first test case, there are initially three 'X' consecutive in the second row and the second column. By changing the middle token to 'O' we make the grid a draw, and we only changed 1≤ ⌊ 5/3⌋ token. In the second test case, we change only 9≤ ⌊ 32/3⌋ tokens, and there does not exist any three 'X' or 'O' consecutive in a row or column, so it is a draw. In the third test case, we change only 3≤ ⌊ 12/3⌋ tokens, and the resulting grid is a draw. The input will be give 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 the 2022 year, Mike found two binary integers a and b of length n (both of them are written only by digits 0 and 1) that can have leading zeroes. In order not to forget them, he wanted to construct integer d in the following way: * he creates an integer c as a result of bitwise summing of a and b without transferring carry, so c may have one or more 2-s. For example, the result of bitwise summing of 0110 and 1101 is 1211 or the sum of 011000 and 011000 is 022000; * after that Mike replaces equal consecutive digits in c by one digit, thus getting d. In the cases above after this operation, 1211 becomes 121 and 022000 becomes 020 (so, d won't have equal consecutive digits). Unfortunately, Mike lost integer a before he could calculate d himself. Now, to cheer him up, you want to find any binary integer a of length n such that d will be maximum possible as integer. Maximum possible as integer means that 102 > 21, 012 < 101, 021 = 21 and so on. Input The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. The first line of each test case contains the integer n (1 ≤ n ≤ 10^5) — the length of a and b. The second line of each test case contains binary integer b of length n. The integer b consists only of digits 0 and 1. It is guaranteed that the total sum of n over all t test cases doesn't exceed 10^5. Output For each test case output one binary integer a of length n. Note, that a or b may have leading zeroes but must have the same length n. Example Input 5 1 0 3 011 3 110 6 111000 6 001011 Output 1 110 100 101101 101110 Note In the first test case, b = 0 and choosing a = 1 gives d = 1 as a result. In the second test case, b = 011 so: * if you choose a = 000, c will be equal to 011, so d = 01; * if you choose a = 111, c will be equal to 122, so d = 12; * if you choose a = 010, you'll get d = 021. * If you select a = 110, you'll get d = 121. We can show that answer a = 110 is optimal and d = 121 is maximum possible. In the third test case, b = 110. If you choose a = 100, you'll get d = 210 and it's the maximum possible d. In the fourth test case, b = 111000. If you choose a = 101101, you'll get d = 212101 and it's maximum possible d. In the fifth test case, b = 001011. If you choose a = 101110, you'll get d = 102121 and it's maximum possible d. The input will be give 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 football very much, especially when his parents aren't home. Each morning he comes to the yard, gathers his friends and they play all day. From time to time they have a break to have some food or do some chores (for example, water the flowers). The key in football is to divide into teams fairly before the game begins. There are n boys playing football in the yard (including Petya), each boy's football playing skill is expressed with a non-negative characteristic ai (the larger it is, the better the boy plays). Let's denote the number of players in the first team as x, the number of players in the second team as y, the individual numbers of boys who play for the first team as pi and the individual numbers of boys who play for the second team as qi. Division n boys into two teams is considered fair if three conditions are fulfilled: * Each boy plays for exactly one team (x + y = n). * The sizes of teams differ in no more than one (\|x - y\| ≤ 1). * The total football playing skills for two teams differ in no more than by the value of skill the best player in the yard has. More formally: <image> Your task is to help guys divide into two teams fairly. It is guaranteed that a fair division into two teams always exists. Input The first line contains the only integer n (2 ≤ n ≤ 105) which represents the number of guys in the yard. The next line contains n positive space-separated integers, ai (1 ≤ ai ≤ 104), the i-th number represents the i-th boy's playing skills. Output On the first line print an integer x — the number of boys playing for the first team. On the second line print x integers — the individual numbers of boys playing for the first team. On the third line print an integer y — the number of boys playing for the second team, on the fourth line print y integers — the individual numbers of boys playing for the second team. Don't forget that you should fulfil all three conditions: x + y = n, \|x - y\| ≤ 1, and the condition that limits the total skills. If there are multiple ways to solve the problem, print any of them. The boys are numbered starting from one in the order in which their skills are given in the input data. You are allowed to print individual numbers of boys who belong to the same team in any order. Examples Input 3 1 2 1 Output 2 1 2 1 3 Input 5 2 3 3 1 1 Output 3 4 1 3 2 5 2 Note Let's consider the first sample test. There we send the first and the second boy to the first team and the third boy to the second team. Let's check all three conditions of a fair division. The first limitation is fulfilled (all boys play), the second limitation on the sizes of groups (\|2 - 1\| = 1 ≤ 1) is fulfilled, the third limitation on the difference in skills ((2 + 1) - (1) = 2 ≤ 2) is fulfilled. The input will be give 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. <image> William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands. A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types: 1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or 2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level). Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section. When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number. William wants you to help him restore a fitting original nested list. Input Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows. The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list. Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list. It is guaranteed that in each test case at least one fitting list exists. It is guaranteed that the sum of values n across all test cases does not exceed 10^3. Output For each test case output n lines which represent a valid nested list, which could become the data provided to you by William. If there are multiple answers, print any. Example Input 2 4 1 1 2 3 9 1 1 1 2 2 1 2 1 2 Output 1 1.1 1.2 1.3 1 1.1 1.1.1 1.1.2 1.2 1.2.1 2 2.1 2.2 Note In the second example test case one example of a fitting list is: 1 1.1 1.1.1 1.1.2 1.2 1.2.1 2 2.1 2.2 This list can be produced by using the sequence of operations shown below: <image> 1. Original list with a single item 1. 2. Insert item 2 by using the insertion operation of the second type after item 1. 3. Insert item 1.1 by using the insertion operation of the first type after item 1. 4. Insert item 1.2 by using the insertion operation of the second type after item 1.1. 5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1. 6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1. 7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2. 8. Insert item 2.1 by using the insertion operation of the first type after item 2. 9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. The input will be give 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. Ilya plays a card game by the following rules. A player has several cards. Each card contains two non-negative integers inscribed, one at the top of the card and one at the bottom. At the beginning of the round the player chooses one of his cards to play it. If the top of the card contains number ai, and the bottom contains number bi, then when the player is playing the card, he gets ai points and also gets the opportunity to play additional bi cards. After the playing the card is discarded. More formally: let's say that there is a counter of the cards that can be played. At the beginning of the round the counter equals one. When a card is played, the counter decreases by one for the played card and increases by the number bi, which is written at the bottom of the card. Then the played card is discarded. If after that the counter is not equal to zero, the player gets the opportunity to play another card from the remaining cards. The round ends when the counter reaches zero or the player runs out of cards. Of course, Ilya wants to get as many points as possible. Can you determine the maximum number of points he can score provided that you know his cards? Input The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of cards Ilya has. Each of the next n lines contains two non-negative space-separated integers — ai and bi (0 ≤ ai, bi ≤ 104) — the numbers, written at the top and the bottom of the i-th card correspondingly. Output Print the single number — the maximum number of points you can score in one round by the described rules. Examples Input 2 1 0 2 0 Output 2 Input 3 1 0 2 0 0 2 Output 3 Note In the first sample none of two cards brings extra moves, so you should play the one that will bring more points. In the second sample you should first play the third card that doesn't bring any points but lets you play both remaining cards. The input will be give 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. To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings. More formally, for each invited person the following conditions should be fulfilled: * all his friends should also be invited to the party; * the party shouldn't have any people he dislikes; * all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends. Help the Beaver find the maximum number of acquaintances he can invite. Input The first line of input contains an integer n — the number of the Beaver's acquaintances. The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends. The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described. Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time. The input limitations for getting 30 points are: * 2 ≤ n ≤ 14 The input limitations for getting 100 points are: * 2 ≤ n ≤ 2000 Output Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0. Examples Input 9 8 1 2 1 3 2 3 4 5 6 7 7 8 8 9 9 6 2 1 6 7 9 Output 3 Note Let's have a look at the example. <image> Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). The input will be give 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 playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai. Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj. Help the Little Elephant to count the answers to all queries. Input The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n). Output In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query. Examples Input 7 2 3 1 2 2 3 3 7 1 7 3 4 Output 3 1 The input will be give 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. Polycarpus just has been out of luck lately! As soon as he found a job in the "Binary Cat" cafe, the club got burgled. All ice-cream was stolen. On the burglary night Polycarpus kept a careful record of all club visitors. Each time a visitor entered the club, Polycarpus put down character "+" in his notes. Similarly, each time a visitor left the club, Polycarpus put character "-" in his notes. We know that all cases of going in and out happened consecutively, that is, no two events happened at the same time. Polycarpus doesn't remember whether there was somebody in the club at the moment when his shift begun and at the moment when it ended. Right now the police wonders what minimum number of distinct people Polycarpus could have seen. Assume that he sees anybody coming in or out of the club. Each person could have come in or out an arbitrary number of times. Input The only line of the input contains a sequence of characters "+" and "-", the characters are written one after another without any separators. The characters are written in the order, in which the corresponding events occurred. The given sequence has length from 1 to 300 characters, inclusive. Output Print the sought minimum number of people Examples Input +-+-+ Output 1 Input --- Output 3 The input will be give 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. Emuskald is a well-known illusionist. One of his trademark tricks involves a set of magical boxes. The essence of the trick is in packing the boxes inside other boxes. From the top view each magical box looks like a square with side length equal to 2k (k is an integer, k ≥ 0) units. A magical box v can be put inside a magical box u, if side length of v is strictly less than the side length of u. In particular, Emuskald can put 4 boxes of side length 2k - 1 into one box of side length 2k, or as in the following figure: <image> Emuskald is about to go on tour performing around the world, and needs to pack his magical boxes for the trip. He has decided that the best way to pack them would be inside another magical box, but magical boxes are quite expensive to make. Help him find the smallest magical box that can fit all his boxes. Input The first line of input contains an integer n (1 ≤ n ≤ 105), the number of different sizes of boxes Emuskald has. Each of following n lines contains two integers ki and ai (0 ≤ ki ≤ 109, 1 ≤ ai ≤ 109), which means that Emuskald has ai boxes with side length 2ki. It is guaranteed that all of ki are distinct. Output Output a single integer p, such that the smallest magical box that can contain all of Emuskald’s boxes has side length 2p. Examples Input 2 0 3 1 5 Output 3 Input 1 0 4 Output 1 Input 2 1 10 2 2 Output 3 Note Picture explanation. If we have 3 boxes with side length 2 and 5 boxes with side length 1, then we can put all these boxes inside a box with side length 4, for example, as shown in the picture. In the second test case, we can put all four small boxes into a box with side length 2. The input will be give 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 system of n vessels with water is given. Several pairs of vessels are connected by tubes with transfusion mechanisms. One may transfer an integer amount of liters of water between two vessels connected by such tube (tube works in both directions). There might be multiple tubes between two vessels. Total number of tubes equals e. Volume of each vessel equals v liters. Of course, the amount of the water in any vessel cannot exceed v liters in the process of transfusions. Given the initial amounts ai of water in the vessels and the desired amounts bi find a sequence of transfusions that deals with the task. Total number of transfusions must not exceed 2·n2. Input First line of the input contains integers n, v, e (1 ≤ n ≤ 300, 1 ≤ v ≤ 109, 0 ≤ e ≤ 50000). Next two lines contain n integers each: initial ai and the desired amounts bi of water in corresponding vessels (0 ≤ ai, bi ≤ v). Next e lines describe one tube each in the format x y (1 ≤ x, y ≤ n, x ≠ y) for a tube between vessels number x and y. There might be multiple tubes between two vessels. You may assume that vessels are numbered from 1 to n in some way. Output Print "NO" (without quotes), if such sequence of transfusions does not exist. Otherwise print any suitable sequence in the following format. On the first line print the total number of transfusions k (k should not exceed 2·n2). In the following k lines print transfusions in the format x y d (transfusion of d liters from the vessel number x to the vessel number y, x and y must be distinct). For all transfusions d must be a non-negative integer. Examples Input 2 10 1 1 9 5 5 1 2 Output 1 2 1 4 Input 2 10 0 5 2 4 2 Output NO Input 2 10 0 4 2 4 2 Output 0 The input will be give 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. Iahub is so happy about inventing bubble sort graphs that he's staying all day long at the office and writing permutations. Iahubina is angry that she is no more important for Iahub. When Iahub goes away, Iahubina comes to his office and sabotage his research work. The girl finds an important permutation for the research. The permutation contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n). She replaces some of permutation elements with -1 value as a revenge. When Iahub finds out his important permutation is broken, he tries to recover it. The only thing he remembers about the permutation is it didn't have any fixed point. A fixed point for a permutation is an element ak which has value equal to k (ak = k). Your job is to proof to Iahub that trying to recover it is not a good idea. Output the number of permutations which could be originally Iahub's important permutation, modulo 1000000007 (109 + 7). Input The first line contains integer n (2 ≤ n ≤ 2000). On the second line, there are n integers, representing Iahub's important permutation after Iahubina replaces some values with -1. It's guaranteed that there are no fixed points in the given permutation. Also, the given sequence contains at least two numbers -1 and each positive number occurs in the sequence at most once. It's guaranteed that there is at least one suitable permutation. Output Output a single integer, the number of ways Iahub could recover his permutation, modulo 1000000007 (109 + 7). Examples Input 5 -1 -1 4 3 -1 Output 2 Note For the first test example there are two permutations with no fixed points are [2, 5, 4, 3, 1] and [5, 1, 4, 3, 2]. Any other permutation would have at least one fixed point. The input will be give 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. Fox Ciel studies number theory. She thinks a non-empty set S contains non-negative integers is perfect if and only if for any <image> (a can be equal to b), <image>. Where operation xor means exclusive or operation (http://en.wikipedia.org/wiki/Exclusive_or). Please calculate the number of perfect sets consisting of integers not greater than k. The answer can be very large, so print it modulo 1000000007 (109 + 7). Input The first line contains an integer k (0 ≤ k ≤ 109). Output Print a single integer — the number of required sets modulo 1000000007 (109 + 7). Examples Input 1 Output 2 Input 2 Output 3 Input 3 Output 5 Input 4 Output 6 Note In example 1, there are 2 such sets: {0} and {0, 1}. Note that {1} is not a perfect set since 1 xor 1 = 0 and {1} doesn't contain zero. In example 4, there are 6 such sets: {0}, {0, 1}, {0, 2}, {0, 3}, {0, 4} and {0, 1, 2, 3}. The input will be give 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 a mysterious language (codenamed "Secret") available in "Custom Invocation" tab. Figure out what this language is and write a program which prints its name. Note that the program must be written in this language. Input This program has only one test (your program doesn't have to read anything). Output Output the name of the mysterious language. Note that the name is case-sensitive and might contain digits and special characters. Examples Note Some scientists disagree on what should be considered as a language and what should be considered as a dialect. The input will be give 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. Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak. There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l ≤ k ≤ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 ≤ i < j ≤ n) such that f(1, i, ai) > f(j, n, aj). Help Pashmak with the test. Input The first line of the input contains an integer n (1 ≤ n ≤ 106). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109). Output Print a single integer — the answer to the problem. Examples Input 7 1 2 1 1 2 2 1 Output 8 Input 3 1 1 1 Output 1 Input 5 1 2 3 4 5 Output 0 The input will be give 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. Imagine that you are in a building that has exactly n floors. You can move between the floors in a lift. Let's number the floors from bottom to top with integers from 1 to n. Now you're on the floor number a. You are very bored, so you want to take the lift. Floor number b has a secret lab, the entry is forbidden. However, you already are in the mood and decide to make k consecutive trips in the lift. Let us suppose that at the moment you are on the floor number x (initially, you were on floor a). For another trip between floors you choose some floor with number y (y ≠ x) and the lift travels to this floor. As you cannot visit floor b with the secret lab, you decided that the distance from the current floor x to the chosen y must be strictly less than the distance from the current floor x to floor b with the secret lab. Formally, it means that the following inequation must fulfill: \|x - y\| < \|x - b\|. After the lift successfully transports you to floor y, you write down number y in your notepad. Your task is to find the number of distinct number sequences that you could have written in the notebook as the result of k trips in the lift. As the sought number of trips can be rather large, find the remainder after dividing the number by 1000000007 (109 + 7). Input The first line of the input contains four space-separated integers n, a, b, k (2 ≤ n ≤ 5000, 1 ≤ k ≤ 5000, 1 ≤ a, b ≤ n, a ≠ b). Output Print a single integer — the remainder after dividing the sought number of sequences by 1000000007 (109 + 7). Examples Input 5 2 4 1 Output 2 Input 5 2 4 2 Output 2 Input 5 3 4 1 Output 0 Note Two sequences p1, p2, ..., pk and q1, q2, ..., qk are distinct, if there is such integer j (1 ≤ j ≤ k), that pj ≠ qj. Notes to the samples: 1. In the first sample after the first trip you are either on floor 1, or on floor 3, because \|1 - 2\| < \|2 - 4\| and \|3 - 2\| < \|2 - 4\|. 2. In the second sample there are two possible sequences: (1, 2); (1, 3). You cannot choose floor 3 for the first trip because in this case no floor can be the floor for the second trip. 3. In the third sample there are no sought sequences, because you cannot choose the floor for the first trip. The input will be give 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. Many years have passed, and n friends met at a party again. Technologies have leaped forward since the last meeting, cameras with timer appeared and now it is not obligatory for one of the friends to stand with a camera, and, thus, being absent on the photo. Simply speaking, the process of photographing can be described as follows. Each friend occupies a rectangle of pixels on the photo: the i-th of them in a standing state occupies a wi pixels wide and a hi pixels high rectangle. But also, each person can lie down for the photo, and then he will occupy a hi pixels wide and a wi pixels high rectangle. The total photo will have size W × H, where W is the total width of all the people rectangles, and H is the maximum of the heights. The friends want to determine what minimum area the group photo can they obtain if no more than n / 2 of them can lie on the ground (it would be strange if more than n / 2 gentlemen lie on the ground together, isn't it?..) Help them to achieve this goal. Input The first line contains integer n (1 ≤ n ≤ 1000) — the number of friends. The next n lines have two integers wi, hi (1 ≤ wi, hi ≤ 1000) each, representing the size of the rectangle, corresponding to the i-th friend. Output Print a single integer equal to the minimum possible area of the photo containing all friends if no more than n / 2 of them can lie on the ground. Examples Input 3 10 1 20 2 30 3 Output 180 Input 3 3 1 2 2 4 3 Output 21 Input 1 5 10 Output 50 The input will be give 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 define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on. Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place. Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63). Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3]. Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list. Input The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list). Output Print n space-separated integers, representing the permutation that is the answer for the question. Examples Input 4 3 Output 1 3 2 4 Input 10 1 Output 1 2 3 4 5 6 7 8 9 10 Note The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. The input will be give 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. Kefa decided to celebrate his first big salary by going to the restaurant. He lives by an unusual park. The park is a rooted tree consisting of n vertices with the root at vertex 1. Vertex 1 also contains Kefa's house. Unfortunaely for our hero, the park also contains cats. Kefa has already found out what are the vertices with cats in them. The leaf vertices of the park contain restaurants. Kefa wants to choose a restaurant where he will go, but unfortunately he is very afraid of cats, so there is no way he will go to the restaurant if the path from the restaurant to his house contains more than m consecutive vertices with cats. Your task is to help Kefa count the number of restaurants where he can go. Input The first line contains two integers, n and m (2 ≤ n ≤ 105, 1 ≤ m ≤ n) — the number of vertices of the tree and the maximum number of consecutive vertices with cats that is still ok for Kefa. The second line contains n integers a1, a2, ..., an, where each ai either equals to 0 (then vertex i has no cat), or equals to 1 (then vertex i has a cat). Next n - 1 lines contains the edges of the tree in the format "xi yi" (without the quotes) (1 ≤ xi, yi ≤ n, xi ≠ yi), where xi and yi are the vertices of the tree, connected by an edge. It is guaranteed that the given set of edges specifies a tree. Output A single integer — the number of distinct leaves of a tree the path to which from Kefa's home contains at most m consecutive vertices with cats. Examples Input 4 1 1 1 0 0 1 2 1 3 1 4 Output 2 Input 7 1 1 0 1 1 0 0 0 1 2 1 3 2 4 2 5 3 6 3 7 Output 2 Note Let us remind you that a tree is a connected graph on n vertices and n - 1 edge. A rooted tree is a tree with a special vertex called root. In a rooted tree among any two vertices connected by an edge, one vertex is a parent (the one closer to the root), and the other one is a child. A vertex is called a leaf, if it has no children. Note to the first sample test: <image> The vertices containing cats are marked red. The restaurants are at vertices 2, 3, 4. Kefa can't go only to the restaurant located at vertex 2. Note to the second sample test: <image> The restaurants are located at vertices 4, 5, 6, 7. Kefa can't go to restaurants 6, 7. The input will be give 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 Xellos was doing a practice course in university, he once had to measure the intensity of an effect that slowly approached equilibrium. A good way to determine the equilibrium intensity would be choosing a sufficiently large number of consecutive data points that seems as constant as possible and taking their average. Of course, with the usual sizes of data, it's nothing challenging — but why not make a similar programming contest problem while we're at it? You're given a sequence of n data points a1, ..., an. There aren't any big jumps between consecutive data points — for each 1 ≤ i < n, it's guaranteed that \|ai + 1 - ai\| ≤ 1. A range [l, r] of data points is said to be almost constant if the difference between the largest and the smallest value in that range is at most 1. Formally, let M be the maximum and m the minimum value of ai for l ≤ i ≤ r; the range [l, r] is almost constant if M - m ≤ 1. Find the length of the longest almost constant range. Input The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of data points. The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000). Output Print a single number — the maximum length of an almost constant range of the given sequence. Examples Input 5 1 2 3 3 2 Output 4 Input 11 5 4 5 5 6 7 8 8 8 7 6 Output 5 Note In the first sample, the longest almost constant range is [2, 5]; its length (the number of data points in it) is 4. In the second sample, there are three almost constant ranges of length 4: [1, 4], [6, 9] and [7, 10]; the only almost constant range of the maximum length 5 is [6, 10]. The input will be give 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 problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules: * Problemset of each division should be non-empty. * Each problem should be used in exactly one division (yes, it is unusual requirement). * Each problem used in division 1 should be harder than any problem used in division 2. * If two problems are similar, they should be used in different divisions. Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other. Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k. Input The first line of the input contains two integers n and m (2 ≤ n ≤ 100 000, 0 ≤ m ≤ 100 000) — the number of problems prepared for the round and the number of pairs of similar problems, respectively. Each of the following m lines contains a pair of similar problems ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi). It's guaranteed, that no pair of problems meets twice in the input. Output Print one integer — the number of ways to split problems in two divisions. Examples Input 5 2 1 4 5 2 Output 2 Input 3 3 1 2 2 3 1 3 Output 0 Input 3 2 3 1 3 2 Output 1 Note In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2. In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules. Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. The input will be give 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. Efim just received his grade for the last test. He studies in a special school and his grade can be equal to any positive decimal fraction. First he got disappointed, as he expected a way more pleasant result. Then, he developed a tricky plan. Each second, he can ask his teacher to round the grade at any place after the decimal point (also, he can ask to round to the nearest integer). There are t seconds left till the end of the break, so Efim has to act fast. Help him find what is the maximum grade he can get in no more than t seconds. Note, that he can choose to not use all t seconds. Moreover, he can even choose to not round the grade at all. In this problem, classic rounding rules are used: while rounding number to the n-th digit one has to take a look at the digit n + 1. If it is less than 5 than the n-th digit remain unchanged while all subsequent digits are replaced with 0. Otherwise, if the n + 1 digit is greater or equal to 5, the digit at the position n is increased by 1 (this might also change some other digits, if this one was equal to 9) and all subsequent digits are replaced with 0. At the end, all trailing zeroes are thrown away. For example, if the number 1.14 is rounded to the first decimal place, the result is 1.1, while if we round 1.5 to the nearest integer, the result is 2. Rounding number 1.299996121 in the fifth decimal place will result in number 1.3. Input The first line of the input contains two integers n and t (1 ≤ n ≤ 200 000, 1 ≤ t ≤ 109) — the length of Efim's grade and the number of seconds till the end of the break respectively. The second line contains the grade itself. It's guaranteed that the grade is a positive number, containing at least one digit after the decimal points, and it's representation doesn't finish with 0. Output Print the maximum grade that Efim can get in t seconds. Do not print trailing zeroes. Examples Input 6 1 10.245 Output 10.25 Input 6 2 10.245 Output 10.3 Input 3 100 9.2 Output 9.2 Note In the first two samples Efim initially has grade 10.245. During the first second Efim can obtain grade 10.25, and then 10.3 during the next second. Note, that the answer 10.30 will be considered incorrect. In the third sample the optimal strategy is to not perform any rounding at all. The input will be give 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 girl Alyona is in a shop to buy some copybooks for school. She study four subjects so she wants to have equal number of copybooks for each of the subjects. There are three types of copybook's packs in the shop: it is possible to buy one copybook for a rubles, a pack of two copybooks for b rubles, and a pack of three copybooks for c rubles. Alyona already has n copybooks. What is the minimum amount of rubles she should pay to buy such number of copybooks k that n + k is divisible by 4? There are infinitely many packs of any type in the shop. Alyona can buy packs of different type in the same purchase. Input The only line contains 4 integers n, a, b, c (1 ≤ n, a, b, c ≤ 109). Output Print the minimum amount of rubles she should pay to buy such number of copybooks k that n + k is divisible by 4. Examples Input 1 1 3 4 Output 3 Input 6 2 1 1 Output 1 Input 4 4 4 4 Output 0 Input 999999999 1000000000 1000000000 1000000000 Output 1000000000 Note In the first example Alyona can buy 3 packs of 1 copybook for 3a = 3 rubles in total. After that she will have 4 copybooks which she can split between the subjects equally. In the second example Alyuna can buy a pack of 2 copybooks for b = 1 ruble. She will have 8 copybooks in total. In the third example Alyona can split the copybooks she already has between the 4 subject equally, so she doesn't need to buy anything. In the fourth example Alyona should buy one pack of one copybook. The input will be give 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. Since the giant heads have appeared in the sky all humanity is in danger, so all Ricks and Mortys from all parallel universes are gathering in groups to find a solution to get rid of them. There are n parallel universes participating in this event (n Ricks and n Mortys). I. e. each of n universes has one Rick and one Morty. They're gathering in m groups. Each person can be in many groups and a group can contain an arbitrary number of members. Ricks and Mortys have registered online in these groups. So, a person can have joined a group more than once (developer of this website hadn't considered this possibility). <image> Summer from universe #1 knows that in each parallel universe (including hers) exactly one of Rick and Morty from that universe is a traitor and is loyal, but no one knows which one. She knows that we are doomed if there's a group such that every member in that group is a traitor (they will plan and destroy the world). Summer knows that if there's a possibility that world ends (there's a group where all members are traitors) she should immediately cancel this event. So she wants to know if she should cancel the event. You have to tell her yes if and only if there's at least one scenario (among all 2n possible scenarios, 2 possible scenarios for who a traitor in each universe) such that in that scenario the world will end. Input The first line of input contains two integers n and m (1 ≤ n, m ≤ 104) — number of universes and number of groups respectively. The next m lines contain the information about the groups. i-th of them first contains an integer k (number of times someone joined i-th group, k > 0) followed by k integers vi, 1, vi, 2, ..., vi, k. If vi, j is negative, it means that Rick from universe number - vi, j has joined this group and otherwise it means that Morty from universe number vi, j has joined it. Sum of k for all groups does not exceed 104. Output In a single line print the answer to Summer's question. Print "YES" if she should cancel the event and "NO" otherwise. Examples Input 4 2 1 -3 4 -2 3 2 -3 Output YES Input 5 2 5 3 -2 1 -1 5 3 -5 2 5 Output NO Input 7 2 3 -1 6 7 7 -5 4 2 4 7 -3 4 Output YES Note In the first sample testcase, 1st group only contains the Rick from universe number 3, so in case he's a traitor, then all members of this group are traitors and so Summer should cancel the event. The input will be give 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. An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme. Three distinct states i, j and k are selected, where i < j < k. After that the following process happens: 1. initially the atom is in the state i, 2. we spend Ek - Ei energy to put the atom in the state k, 3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j, 4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei, 5. the process repeats from step 1. Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy. Due to some limitations, Arkady can only choose such three states that Ek - Ei ≤ U. Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints. Input The first line contains two integers n and U (3 ≤ n ≤ 105, 1 ≤ U ≤ 109) — the number of states and the maximum possible difference between Ek and Ei. The second line contains a sequence of integers E1, E2, ..., En (1 ≤ E1 < E2... < En ≤ 109). It is guaranteed that all Ei are given in increasing order. Output If it is not possible to choose three states that satisfy all constraints, print -1. Otherwise, print one real number η — the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9. Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>. Examples Input 4 4 1 3 5 7 Output 0.5 Input 10 8 10 13 15 16 17 19 20 22 24 25 Output 0.875 Input 3 1 2 5 10 Output -1 Note In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>. In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>. The input will be give 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. <image> You have one chip and one chance to play roulette. Are you feeling lucky? Output Print your bet. Your chip must be placed entirely within some square (not on an edge or a corner shared by adjacent squares). The input will be give 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 far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there. Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this: * If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. * If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part. * If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position. Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order? Input The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data. Output If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes). Examples Input 0.0 Output 0 Input 1.49 Output 1 Input 1.50 Output 2 Input 2.71828182845904523536 Output 3 Input 3.14159265358979323846 Output 3 Input 12345678901234567890.1 Output 12345678901234567890 Input 123456789123456789.999 Output GOTO Vasilisa. The input will be give 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. Ikshu and his machine gun To celebrate his new year Ikshu went to play "beyond to beyond" (abbreviated as BOB) with his friends. BOB can be described as follows : It consists of Infinite boxes arranged one over another, Lowest box being 1. Given a list 'L' of indices, Ikshu needs to knockoff L[i]th box for 0 ≤ i<\|L\| where \|L\| denoted the size of L. A box gun is used which can knock off a box at a given index. For example : you can give command to box gun to knock off box at position 2. Command given to machine should be in increasing order. NOTE : After knocking off a particular box, all the boxes above it comes down by one unit and you can knockoff boxes in any order. You need to find the commands that Ikshu should give to his machine guns in order to knockoff all the boxes at given indices. Example: Initially boxes are 1,2,3,4,... L = [2,3] a) 2 - we give command to machine gun to knockoff second box b) 2 - we give command to machine gun to knockoff third box Note that, new position of third box is 2 after knocking off second box Constraints: 1 ≤\|L\| ≤ 100000 List L contains unique indices Input: First line of input contains an integer S, where S is the length of list 'L' of indices to be knocked off. Second Line of input contains S integers - indices which are to be knocked off Output: output in one line what are the commands given to the machine gun. SAMPLE INPUT 2 2 3 SAMPLE OUTPUT 2 2 The input will be give 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. Rahul likes to play with mathematics and geometry and when it comes for 2D geometry, he just can’t stop himself doing experiments. While working with 2D geometry, he came up with an interesting pattern of numbers as shown below. He started at the point (0, 0) and wrote all non-negative integers. They are- (0, 0) – 0 (1, 1) – 1 (2, 0) – 2 (3, 1) – 3 (2, 2) – 4 (4, 2) – 6 (3, 3) – 5 (5, 3) – 7 (4, 4) – 8 (6, 4) - 10 (5, 5) – 9 (7, 5) – 11 (6, 6) – 12 (8, 6) – 14 (7, 7) – 13 And so on. Write a program that takes the coordinates(x, y) as the inputs and gives the respective number(if any) on it as output. Input 1st line is t denoting number of test cases. Next t lines contains 2 space separated integers denoting the x and y coordinates. Output N lines each having the output as the number appearing on the given coordinate. Output “No Number” if there is none. Constraints 1 ≤ t ≤ 50 where t is the number of test cases 0 ≤ x, y ≤ 500 where x and y are the respective coordinates. SAMPLE INPUT 3 4 2 6 6 3 4 SAMPLE OUTPUT 6 12 No Number The input will be give 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. Everyone has got to know that HELL and Printf{} use cheats while playing Counter-Strike 1.6. Everyone decides to give them a punishment. They are going to be made to paint all the rooms of the ground floor of the hostel. There are a total of N rooms on the ground floor arranged in a single row side by side numbered from 1 to N. HELL has to paint all the rooms with room numbers 1 to K (both inclusive) and Printf{} has to paint all the rooms with room numbers K+1 to N (both inclusive). Both are given a total of 10 paints of distinct colours, 1 of them being White colour. They have to paint all the rooms such that atleast one of the rooms painted by each one of them is not White in colour so that the hostel ground floor has a minimum of two colourful (non-White) rooms. Given N and K, you have to report the total number of different possible appearances of the hostel ground floor ie. , total number of different ways in which all the rooms of the ground floor can be painted. Assume that there is infinite amount of paint of each colour made available to both of them. Input : The first line comprises of T denoting the number of test cases. The next T lines are such that each line consists of 2 space separated integers N and K. Output : Print a single integer , the answer to each test case on a new line. Constraints: 1 ≤ T ≤ 5 2 ≤ N ≤ 100000 1 ≤ K<N Author : Shreyans Tester : Sayan (By IIT Kgp HackerEarth Programming Club) SAMPLE INPUT 2 2 1 3 2 SAMPLE OUTPUT 81 891 The input will be give 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 a string S of length N. Initially, all characters in S are `1`s. You will perform queries Q times. In the i-th query, you are given two integers L_i, R_i and a character D_i (which is a digit). Then, you must replace all characters from the L_i-th to the R_i-th (inclusive) with D_i. After each query, read the string S as a decimal integer, and print its value modulo 998,244,353. Constraints * 1 \leq N, Q \leq 200,000 * 1 \leq L_i \leq R_i \leq N * 1 \leq D_i \leq 9 * All values in input are integers. Input Input is given from Standard Input in the following format: N Q L_1 R_1 D_1 : L_Q R_Q D_Q Output Print Q lines. In the i-th line print the value of S after the i-th query, modulo 998,244,353. Examples Input 8 5 3 6 2 1 4 7 3 8 3 2 2 2 4 5 1 Output 11222211 77772211 77333333 72333333 72311333 Input 200000 1 123 456 7 Output 641437905 The input will be give 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 start with the number 0 and you want to reach the number N. You can change the number, paying a certain amount of coins, with the following operations: * Multiply the number by 2, paying A coins. * Multiply the number by 3, paying B coins. * Multiply the number by 5, paying C coins. * Increase or decrease the number by 1, paying D coins. You can perform these operations in arbitrary order and an arbitrary number of times. What is the minimum number of coins you need to reach N? You have to solve T testcases. Constraints * 1 \le T \le 10 * 1 \le N \le 10^{18} * 1 \le A, B, C, D \le 10^9 * All numbers N, A, B, C, D are integers. Input The input is given from Standard Input. The first line of the input is T Then, T lines follow describing the T testcases. Each of the T lines has the format N A B C D Output For each testcase, print the answer on Standard Output followed by a newline. Example Input 5 11 1 2 4 8 11 1 2 2 8 32 10 8 5 4 29384293847243 454353412 332423423 934923490 1 900000000000000000 332423423 454353412 934923490 987654321 Output 20 19 26 3821859835 23441258666 The input will be give 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 is a sequence of N integers A_1, \ldots, A_N. Find the (multiplicative) inverse of the sum of the inverses of these numbers, \frac{1}{\frac{1}{A_1} + \ldots + \frac{1}{A_N}}. Constraints * 1 \leq N \leq 100 * 1 \leq A_i \leq 1000 Input Input is given from Standard Input in the following format: N A_1 A_2 \ldots A_N Output Print a decimal number (or an integer) representing the value of \frac{1}{\frac{1}{A_1} + \ldots + \frac{1}{A_N}}. Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5}. Examples Input 2 10 30 Output 7.5 Input 3 200 200 200 Output 66.66666666666667 Input 1 1000 Output 1000 The input will be give 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 buttons, one of size A and one of size B. When you press a button of size X, you get X coins and the size of that button decreases by 1. You will press a button twice. Here, you can press the same button twice, or press both buttons once. At most how many coins can you get? Constraints * All values in input are integers. * 3 \leq A, B \leq 20 Input Input is given from Standard Input in the following format: A B Output Print the maximum number of coins you can get. Examples Input 5 3 Output 9 Input 3 4 Output 7 Input 6 6 Output 12 The input will be give 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 integer N. Among the divisors of N! (= 1 \times 2 \times ... \times N), how many Shichi-Go numbers (literally "Seven-Five numbers") are there? Here, a Shichi-Go number is a positive integer that has exactly 75 divisors. Constraints * 1 \leq N \leq 100 * N is an integer. Input Input is given from Standard Input in the following format: N Output Print the number of the Shichi-Go numbers that are divisors of N!. Examples Input 9 Output 0 Input 10 Output 1 Input 100 Output 543 The input will be give 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. Snuke found a record of a tree with N vertices in ancient ruins. The findings are as follows: * The vertices of the tree were numbered 1,2,...,N, and the edges were numbered 1,2,...,N-1. * Edge i connected Vertex a_i and b_i. * The length of each edge was an integer between 1 and 10^{18} (inclusive). * The sum of the shortest distances from Vertex i to Vertex 1,...,N was s_i. From the information above, restore the length of each edge. The input guarantees that it is possible to determine the lengths of the edges consistently with the record. Furthermore, it can be proved that the length of each edge is uniquely determined in such a case. Constraints * 2 \leq N \leq 10^{5} * 1 \leq a_i,b_i \leq N * 1 \leq s_i \leq 10^{18} * The given graph is a tree. * All input values are integers. * It is possible to consistently restore the lengths of the edges. * In the restored graph, the length of each edge is an integer between 1 and 10^{18} (inclusive). Input Input is given from Standard Input in the following format: N a_1 b_1 : a_{N-1} b_{N-1} s_1 s_2 ... s_{N} Output Print N-1 lines. The i-th line must contain the length of Edge i. Examples Input 4 1 2 2 3 3 4 8 6 6 8 Output 1 2 1 Input 5 1 2 1 3 1 4 1 5 10 13 16 19 22 Output 1 2 3 4 Input 15 9 10 9 15 15 4 4 13 13 2 13 11 2 14 13 6 11 1 1 12 12 3 12 7 2 5 14 8 1154 890 2240 883 2047 2076 1590 1104 1726 1791 1091 1226 841 1000 901 Output 5 75 2 6 7 50 10 95 9 8 78 28 89 8 The input will be give 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. Snuke is playing a puzzle game. In this game, you are given a rectangular board of dimensions R × C, filled with numbers. Each integer i from 1 through N is written twice, at the coordinates (x_{i,1},y_{i,1}) and (x_{i,2},y_{i,2}). The objective is to draw a curve connecting the pair of points where the same integer is written, for every integer from 1 through N. Here, the curves may not go outside the board or cross each other. Determine whether this is possible. Constraints * 1 ≤ R,C ≤ 10^8 * 1 ≤ N ≤ 10^5 * 0 ≤ x_{i,1},x_{i,2} ≤ R(1 ≤ i ≤ N) * 0 ≤ y_{i,1},y_{i,2} ≤ C(1 ≤ i ≤ N) * All given points are distinct. * All input values are integers. Input Input is given from Standard Input in the following format: R C N x_{1,1} y_{1,1} x_{1,2} y_{1,2} : x_{N,1} y_{N,1} x_{N,2} y_{N,2} Output Print `YES` if the objective is achievable; print `NO` otherwise. Examples Input 4 2 3 0 1 3 1 1 1 4 1 2 0 2 2 Output YES Input 2 2 4 0 0 2 2 2 0 0 1 0 2 1 2 1 1 2 1 Output NO Input 5 5 7 0 0 2 4 2 3 4 5 3 5 5 2 5 5 5 4 0 3 5 1 2 2 4 4 0 5 4 1 Output YES Input 1 1 2 0 0 1 1 1 0 0 1 Output NO The input will be give 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. Snuke has a calculator. It has a display and two buttons. Initially, the display shows an integer x. Snuke wants to change this value into another integer y, by pressing the following two buttons some number of times in arbitrary order: * Button A: When pressed, the value on the display is incremented by 1. * Button B: When pressed, the sign of the value on the display is reversed. Find the minimum number of times Snuke needs to press the buttons to achieve his objective. It can be shown that the objective is always achievable regardless of the values of the integers x and y. Constraints * x and y are integers. * \|x\|, \|y\| ≤ 10^9 * x and y are different. Input The input is given from Standard Input in the following format: x y Output Print the minimum number of times Snuke needs to press the buttons to achieve his objective. Examples Input 10 20 Output 10 Input 10 -10 Output 1 Input -10 -20 Output 12 The input will be give 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 rectangular parallelepiped of size A×B×C, built with blocks of size 1×1×1. Snuke will paint each of the A×B×C blocks either red or blue, so that: * There is at least one red block and at least one blue block. * The union of all red blocks forms a rectangular parallelepiped. * The union of all blue blocks forms a rectangular parallelepiped. Snuke wants to minimize the difference between the number of red blocks and the number of blue blocks. Find the minimum possible difference. Constraints * 2≤A,B,C≤10^9 Input The input is given from Standard Input in the following format: A B C Output Print the minimum possible difference between the number of red blocks and the number of blue blocks. Examples Input 3 3 3 Output 9 Input 2 2 4 Output 0 Input 5 3 5 Output 15 The input will be give 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. Takayuki and Kazuyuki are good twins, but their behavior is exactly the opposite. For example, if Takayuki goes west, Kazuyuki goes east, and if Kazuyuki goes north, Takayuki goes south. Currently the two are in a department store and are in different locations. How can two people who move in the opposite direction meet as soon as possible? A department store is represented by a grid consisting of W horizontal x H vertical squares, and two people can move one square from north, south, east, and west per unit time. However, you cannot move outside the grid or to a square with obstacles. As shown, the position of the grid cells is represented by the coordinates (x, y). <image> Create a program that inputs the grid information and the initial positions of the two people and outputs the shortest time until the two people meet. If you can't meet, or if it takes more than 100 hours to meet, print NA. The grid information is given by the numbers in rows H and columns W, and the location information of the two people is given by the coordinates. If either Takayuki-kun or Kazuyuki-kun is out of the range of the obstacle or grid after moving, you cannot move, so the one who is out of the range of the obstacle or grid is the original place. But if you don't, you can move without returning to the original place. When two people meet, it means that they stay in the same square after moving. Even if two people pass each other, they do not meet. Input A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format: W H tx ty kx ky d11 d21 ... dW1 d12 d22 ... dW2 :: d1H d2H ... dWH The first line gives the department store sizes W, H (1 ≤ W, H ≤ 50). The second line gives Takayuki's initial position tx, ty, and the third line gives Kazuyuki's initial position kx, ky. The H line that follows gives the department store information. di, j represents the type of square (i, j), 0 for movable squares and 1 for obstacles. The number of datasets does not exceed 100. Output Outputs the shortest time on one line for each input dataset. Example Input 6 6 2 4 6 2 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 3 3 1 1 3 3 0 0 0 0 1 0 0 0 0 0 0 Output 3 NA The input will be give 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 play a game using a robot on a rectangular board covered with a square mesh (Figure D-1). The robot is initially set at the start square in the northwest corner facing the east direction. The goal of this game is to lead the robot to the goal square in the southeast corner. <image> Figure D-1: Example of a board The robot can execute the following five types of commands. "Straight": Keep the current direction of the robot, and move forward to the next square. "Right": Turn right with 90 degrees from the current direction, and move forward to the next square. "Back": Turn to the reverse direction, and move forward to the next square. "Left": Turn left with 90 degrees from the current direction, and move forward to the next square. "Halt": Stop at the current square to finish the game. Each square has one of these commands assigned as shown in Figure D-2. The robot executes the command assigned to the square where it resides, unless the player gives another command to be executed instead. Each time the player gives an explicit command, the player has to pay the cost that depends on the command type. <image> Figure D-2: Example of commands assigned to squares The robot can visit the same square several times during a game. The player loses the game when the robot goes out of the board or it executes a "Halt" command before arriving at the goal square. Your task is to write a program that calculates the minimum cost to lead the robot from the start square to the goal one. Input The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. Each dataset is formatted as follows. > w h > s(1,1) ... s(1,w) > s(2,1) ... s(2,w) > ... > s(h,1) ... s(h,w) > c0 c1 c2 c3 The integers h and w are the numbers of rows and columns of the board, respectively. You may assume 2 ≤ h ≤ 30 and 2 ≤ w ≤ 30. Each of the following h lines consists of w numbers delimited by a space. The number s(i, j) represents the command assigned to the square in the i-th row and the j-th column as follows. * 0: "Straight" * 1: "Right" * 2: "Back" * 3: "Left" * 4: "Halt" You can assume that a "Halt" command is assigned to the goal square. Note that "Halt" commands may be assigned to other squares, too. The last line of a dataset contains four integers c0, c1, c2, and c3, delimited by a space, indicating the costs that the player has to pay when the player gives "Straight", "Right", "Back", and "Left" commands respectively. The player cannot give "Halt" commands. You can assume that all the values of c0, c1, c2, and c3 are between 1 and 9, inclusive. Output For each dataset, print a line only having a decimal integer indicating the minimum cost required to lead the robot to the goal. No other characters should be on the output line. Sample Input 8 3 0 0 0 0 0 0 0 1 2 3 0 1 4 0 0 1 3 3 0 0 0 0 0 4 9 9 1 9 4 4 3 3 4 0 1 2 4 4 1 1 1 0 0 2 4 4 8 7 2 1 2 8 2 2 4 1 0 4 1 3 1 0 2 1 0 3 1 4 1 9 3 1 0 0 Output for the Sample Input 1 11 6 Example Input 8 3 0 0 0 0 0 0 0 1 2 3 0 1 4 0 0 1 3 3 0 0 0 0 0 4 9 9 1 9 4 4 3 3 4 0 1 2 4 4 1 1 1 0 0 2 4 4 8 7 2 1 2 8 2 2 4 1 0 4 1 3 1 0 2 1 0 3 1 4 1 9 3 1 0 0 Output 1 11 6 The input will be give 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. Numbers of black and white points are placed on a plane. Let's imagine that a straight line of infinite length is drawn on the plane. When the line does not meet any of the points, the line divides these points into two groups. If the division by such a line results in one group consisting only of black points and the other consisting only of white points, we say that the line "separates black and white points". Let's see examples in Figure 3. In the leftmost example, you can easily find that the black and white points can be perfectly separated by the dashed line according to their colors. In the remaining three examples, there exists no such straight line that gives such a separation. <image> Figure 3: Example planes In this problem, given a set of points with their colors and positions, you are requested to decide whether there exists a straight line that separates black and white points. Input The input is a sequence of datasets, each of which is formatted as follows. n m x1 y1 . . . xn yn xn+1 yn+1 . . . xn+m yn+m The first line contains two positive integers separated by a single space; n is the number of black points, and m is the number of white points. They are less than or equal to 100. Then n + m lines representing the coordinates of points follow. Each line contains two integers xi and yi separated by a space, where (xi , yi ) represents the x-coordinate and the y-coordinate of the i-th point. The color of the i-th point is black for 1 ≤ i ≤ n, and is white for n + 1 ≤ i ≤ n + m. All the points have integral x- and y-coordinate values between 0 and 10000 inclusive. You can also assume that no two points have the same position. The end of the input is indicated by a line containing two zeros separated by a space. Output For each dataset, output "YES" if there exists a line satisfying the condition. If not, output "NO". In either case, print it in one line for each input dataset. Example Input 3 3 100 700 200 200 600 600 500 100 500 300 800 500 3 3 100 300 400 600 400 100 600 400 500 900 300 300 3 4 300 300 500 300 400 600 100 100 200 900 500 900 800 100 1 2 300 300 100 100 500 500 1 1 100 100 200 100 2 2 0 0 500 700 1000 1400 1500 2100 2 2 0 0 1000 1000 1000 0 0 1000 3 3 0 100 4999 102 10000 103 5001 102 10000 102 0 101 3 3 100 100 200 100 100 200 0 0 400 0 0 400 3 3 2813 1640 2583 2892 2967 1916 541 3562 9298 3686 7443 7921 0 0 Output YES NO NO NO YES YES NO NO NO YES The input will be give 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. Square Route Square root English text is not available in this practice contest. Millionaire Shinada, who has decided to build a new mansion, is wondering in which city to build the new mansion. To tell the truth, Mr. Shinada is a strange person who likes squares very much, so he wants to live in a city with as many squares as possible. Mr. Shinada decided to get a list of cities with roads in a grid pattern and count the number of squares formed by the roads in each city. However, the distance between roads is not always constant, so it is difficult to count squares manually. Therefore, I would like you to write a program that counts the number of squares when given information on a grid-shaped road. Input The input is composed of multiple data sets, and each data set has the following structure. > N M > h1 > h2 > ... > hN > w1 > w2 > ... > wM Two positive integers N, M (1 ≤ N, M ≤ 1500) are given on the first line. The following N lines h1, h2, ..., hN (1 ≤ hi ≤ 1000) represent the distance between roads in the north-south direction. Where hi is the distance between the i-th road from the north and the i + 1st road from the north. Similarly, the following M lines w1, ..., wM (1 ≤ wi ≤ 1000) represent the distance between roads in the east-west direction. Where wi is the distance between the i-th road from the west and the i + 1st road from the west. The width of the road itself is narrow enough that it does not need to be considered. First dataset Figure D-1: First dataset N = M = 0 indicates the end of the input and is not included in the dataset. Output Print the number of squares on one line for each dataset. For example, the first dataset of Sample Input contains 6 squares as shown below, so the output for this dataset is 6. Squares included in the first dataset Figure D-2: Squares in the first dataset Sample Input 3 3 1 1 Four 2 3 1 1 2 Ten Ten Ten 0 0 Output for the Sample Input 6 2 Example Input 3 3 1 1 4 2 3 1 1 2 10 10 10 0 0 Output 6 2 The input will be give 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. All space-time unified dimension sugoroku tournament. You are representing the Earth in the 21st century in the tournament, which decides only one Sugoroku absolute champion out of more than 500 trillion participants. The challenge you are currently challenging is one-dimensional sugoroku with yourself as a frame. Starting from the start square at the end, roll a huge 6-sided die with 1 to 6 rolls one by one, and repeat the process by the number of rolls, a format you are familiar with. It's Sugoroku. If you stop at the goal square on the opposite end of the start square, you will reach the goal. Of course, the fewer times you roll the dice before you reach the goal, the better the result. There are squares with special effects, "○ square forward" and "○ square return", and if you stop there, you must advance or return by the specified number of squares. If the result of moving by the effect of the square stops at the effective square again, continue to move as instructed. However, this is a space-time sugoroku that cannot be captured with a straight line. Frighteningly, for example, "3 squares back" may be placed 3 squares ahead of "3 squares forward". If you stay in such a square and get stuck in an infinite loop due to the effect of the square, you have to keep going back and forth in the square forever. Fortunately, however, your body has an extraordinary "probability curve" that can turn the desired event into an entire event. With this ability, you can freely control the roll of the dice. Taking advantage of this advantage, what is the minimum number of times to roll the dice before reaching the goal when proceeding without falling into an infinite loop? Input N p1 p2 .. .. .. pN The integer N (3 ≤ N ≤ 100,000) is written on the first line of the input. This represents the number of Sugoroku squares. The squares are numbered from 1 to N. The starting square is number 1, then the number 2, 3, ..., N -1 in the order closer to the start, and the goal square is number N. If you roll the dice on the i-th square and get a j, move to the i + j-th square. However, if i + j exceeds N, it will not return by the extra number and will be considered as a goal. The following N lines contain the integer pi (-100,000 ≤ pi ≤ 100,000). The integer pi written on the 1 + i line represents the instruction written on the i-th cell. If pi> 0, it means "forward pi square", if pi <0, it means "go back -pi square", and if pi = 0, it has no effect on that square. p1 and pN are always 0. Due to the effect of the square, you will not be instructed to move before the start or after the goal. It should be assumed that the given sugoroku can reach the goal. Output Output the minimum number of dice rolls before reaching the goal. Examples Input 11 0 0 -2 0 -4 1 -1 2 0 0 0 Output 3 Input 12 0 0 7 0 2 0 0 3 -6 -2 1 0 Output 1 Input 8 0 4 -1 1 -2 -2 0 0 Output 2 The input will be give 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 robot, a wall, and a goal are installed on the board, and a program that describes the behavior pattern of the robot is given. The given program is represented by the following EBNF. Program: = {statement}; Statement: = if statement \| while statement \| action statement; if statement: = "[", condition, program, "]"; while statement: = "{", condition, program, "}"; Action statement: = "^" \| "v" \| "<" \| ">"; Condition: = ["~"], "N" \| "E" \| "S" \| "W" \| "C" \| "T"; A "program" consists of 0 or more "sentences", and if there is one or more sentences, the sentences are executed one by one in order from the first sentence. A "statement" is one of an "action statement", an "if statement", and a "while statement". The "action statement" is one of "^", "v", "<", ">", and the following actions are executed respectively. * "^": Advance * "v": Retreat * "<": Rotate 90 degrees to the left * ">": Rotate 90 degrees to the right The "if statement" is an arrangement of "[", "condition", "program", "]" in order, and is executed by the following procedure. 1. Determine if the content of the "condition" is true 2. If the judgment is true, execute the contents of the "program" and end the processing of this if statement. 3. If the judgment is false, the processing of this if statement ends. A "while statement" is an arrangement of "{", "condition", "program", and "}" in order, and is executed by the following procedure. 1. Determine if the content of the "condition" is true 2. If the judgment is true, execute the contents of "Program" and return to 1. 3. If the judgment is false, the processing of this while statement ends. The "condition" is one of "N", "E", "S", "W", "C", "T", and can be prefixed with "~". Each description represents the following boolean values. * If "~" is added at the beginning, the boolean value is reversed. * N: True if facing north, false otherwise * E: True if facing east, false otherwise * S: True if facing south, false otherwise * W: True if facing west, false otherwise * C: True if there is a wall in front of you, false otherwise * T: Always true It is assumed that the robot is initially facing north. Robots cannot pass through walls and can only move empty squares. If the program tries to perform an action that passes over a wall, the robot will not move and will stay in place. Finally, when the robot reaches the goal, it interrupts all the programs that are being executed, even if they remain, and stops the operation. At this time, I would like to know how long it will take for the robot to reach the goal. Since the robot can execute condition judgment and program loading at a very high speed, it is only the "action statement" that determines the actual operation time. Therefore, please tell me how many times this robot executes the "motion statement" before reaching the goal. It is considered that the "action statement" has been executed even if the action of the "action statement" is not actually performed when trying to execute an action that passes over the wall. Constraints * 1 ≤ H, W ≤ 50 * 1 ≤ s number of characters ≤ 1,000 * ai, j is one of ".", "#", "S", "g" * "s" and "g" appear only once each * If i = 1 or i = H or j = 1 or j = W, then ai, j = "#" (the outer circumference of the board is guaranteed to be surrounded by a wall) * The program given as s is syntactically correct Input The input is given in the following format. H W a1,1a1,2 ... a1, W a2,1a2,2 ... a2, W ::: aH, 1aH, 2 ... aH, W s H is the height of the board and W is the width of the board. Next, the state of the board viewed from directly above is given. The top, bottom, left, and right of this board correspond to north, south, west, and east, respectively. Ai and j, which represent the state of each cell, are one of the following characters. * "s": Robot (robot initial position. This square is guaranteed to have no walls) * "g": Goal * "#": Wall (Robots cannot move on the wall) * ".": An empty square The program given to the robot is input as a character string in s. Output If you can reach it, output "the number of" action statements "executed before reaching it". If you cannot reach it, output "-1". In addition, when trying to execute an action that passes over a wall, " Note that even if the action of the "action statement" is not performed, it is considered that the "action statement" has been executed (input example 1). Examples Input 5 3 ### #g# #.# #s# ### ^<^<vv Output 5 Input 5 3 g# .# s# ^<^<vv Output 5 Input 5 7 .#g..# .###.# s....# {T{~C^}<} Output 17 Input 5 7 .#g..# .###.# s....# {T{~C^}>} Output -1 The input will be give 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 A mysterious $ X $ [cm] plant grows in one place. This plant has the following mysterious properties. * Say "nobiro" to this plant and it will grow $ A $ [cm]. * Say "tidime" to this plant and it will grow $ B $ [cm]. * If you say "karero" to this plant, it will be $ 0 $ [cm]. However, this plant does not have a negative length. Specifically, when it grows from the state of $ C $ [cm] to $ D $ [cm] $ (C + D \ lt 0) $, it is a plant. Stops growing when it reaches $ 0 $ [cm]. Say one of "nobiro", "tidime", "karero" to this plant only once a day for $ N $ days. Find the length [cm] of the plant after $ N $ days. output Print the length of the plant after $ N $ days. Also print a newline at the end. Example Input 10 30 10 3 nobiro nobiro tidime Output 80 The input will be give 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 the edit distance between given two words s1 and s2. The disntace is the minimum number of single-character edits required to change one word into the other. The edits including the following operations: * insertion: Insert a character at a particular position. * deletion: Delete a character at a particular position. * substitution: Change the character at a particular position to a different character Constraints * 1 ≤ length of s1 ≤ 1000 * 1 ≤ length of s2 ≤ 1000 Input s1 s2 Two words s1 and s2 are given in the first line and the second line respectively. The words will consist of lower case characters. Output Print the edit distance in a line. Examples Input acac acm Output 2 Input icpc icpc Output 0 The input will be give 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 the union of two sets $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and $B = \\{b_0, b_1, ..., b_{m-1}\\}$. Constraints * $1 \leq n, m \leq 200,000$ * $0 \leq a_0 < a_1 < ... < a_{n-1} \leq 10^9$ * $0 \leq b_0 < b_1 < ... < b_{m-1} \leq 10^9$ Input The input is given in the following format. $n$ $a_0 \; a_1 \; ... \; a_{n-1}$ $m$ $b_0 \; b_1 \; ... \; b_{m-1}$ Elements of $A$ and $B$ are given in ascending order respectively. There are no duplicate elements in each set. Output Print elements in the union in ascending order. Print an element in a line. Example Input 3 1 5 8 2 5 9 Output 1 5 8 9 The input will be give 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. Chef has a special affection for sets of binary strings of equal length which have same numbers of 1's. Given three integers n, k and m, your task is to find the the lexicographically m^th smallest string among strings which have length n and have k 1's. If no such string exists output -1. Tips: To see what lexicographic order means . See http://en.wikipedia.org/wiki/Lexicographical_order Input Input description. The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows: The first and only line of each test case contains three space separated integers N , K and M Output For each test case output the answer on a separate line . Constraints 1 ≤ T ≤ 10 1 ≤ N ≤ 350 1 ≤ K ≤ N Example Input: 1 3 2 2 Output: 101 Explanation Example case 1. The set of strings in lexicographic order is "011", "101", and "110" Scoring Subtask 1 (41 point): 1 ≤ N ≤ 20 Subtask 2 (59 points): 1 ≤ N ≤ 350 The input will be give 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. Natasha is planning an expedition to Mars for n people. One of the important tasks is to provide food for each participant. The warehouse has m daily food packages. Each package has some food type a_i. Each participant must eat exactly one food package each day. Due to extreme loads, each participant must eat the same food type throughout the expedition. Different participants may eat different (or the same) types of food. Formally, for each participant j Natasha should select his food type b_j and each day j-th participant will eat one food package of type b_j. The values b_j for different participants may be different. What is the maximum possible number of days the expedition can last, following the requirements above? Input The first line contains two integers n and m (1 ≤ n ≤ 100, 1 ≤ m ≤ 100) — the number of the expedition participants and the number of the daily food packages available. The second line contains sequence of integers a_1, a_2, ..., a_m (1 ≤ a_i ≤ 100), where a_i is the type of i-th food package. Output Print the single integer — the number of days the expedition can last. If it is not possible to plan the expedition for even one day, print 0. Examples Input 4 10 1 5 2 1 1 1 2 5 7 2 Output 2 Input 100 1 1 Output 0 Input 2 5 5 4 3 2 1 Output 1 Input 3 9 42 42 42 42 42 42 42 42 42 Output 3 Note In the first example, Natasha can assign type 1 food to the first participant, the same type 1 to the second, type 5 to the third and type 2 to the fourth. In this case, the expedition can last for 2 days, since each participant can get two food packages of his food type (there will be used 4 packages of type 1, two packages of type 2 and two packages of type 5). In the second example, there are 100 participants and only 1 food package. In this case, the expedition can't last even 1 day. The input will be give 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 some positive integer classy if its decimal representation contains no more than 3 non-zero digits. For example, numbers 4, 200000, 10203 are classy and numbers 4231, 102306, 7277420000 are not. You are given a segment [L; R]. Count the number of classy integers x such that L ≤ x ≤ R. Each testcase contains several segments, for each of them you are required to solve the problem separately. Input The first line contains a single integer T (1 ≤ T ≤ 10^4) — the number of segments in a testcase. Each of the next T lines contains two integers L_i and R_i (1 ≤ L_i ≤ R_i ≤ 10^{18}). Output Print T lines — the i-th line should contain the number of classy integers on a segment [L_i; R_i]. Example Input 4 1 1000 1024 1024 65536 65536 999999 1000001 Output 1000 1 0 2 The input will be give 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. Student Andrey has been skipping physical education lessons for the whole term, and now he must somehow get a passing grade on this subject. Obviously, it is impossible to do this by legal means, but Andrey doesn't give up. Having obtained an empty certificate from a local hospital, he is going to use his knowledge of local doctor's handwriting to make a counterfeit certificate of illness. However, after writing most of the certificate, Andrey suddenly discovered that doctor's signature is impossible to forge. Or is it? For simplicity, the signature is represented as an n× m grid, where every cell is either filled with ink or empty. Andrey's pen can fill a 3×3 square without its central cell if it is completely contained inside the grid, as shown below. xxx x.x xxx Determine whether is it possible to forge the signature on an empty n× m grid. Input The first line of input contains two integers n and m (3 ≤ n, m ≤ 1000). Then n lines follow, each contains m characters. Each of the characters is either '.', representing an empty cell, or '#', representing an ink filled cell. Output If Andrey can forge the signature, output "YES". Otherwise output "NO". You can print each letter in any case (upper or lower). Examples Input 3 3 ### #.# ### Output YES Input 3 3 ### ### ### Output NO Input 4 3 ### ### ### ### Output YES Input 5 7 ....... .#####. .#.#.#. .#####. ....... Output YES Note In the first sample Andrey can paint the border of the square with the center in (2, 2). In the second sample the signature is impossible to forge. In the third sample Andrey can paint the borders of the squares with the centers in (2, 2) and (3, 2): 1. we have a clear paper: ... ... ... ... 2. use the pen with center at (2, 2). ### #.# ### ... 3. use the pen with center at (3, 2). ### ### ### ### In the fourth sample Andrey can paint the borders of the squares with the centers in (3, 3) and (3, 5). The input will be give 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, Olya received a magical square with the size of 2^n× 2^n. It seems to her sister that one square is boring. Therefore, she asked Olya to perform exactly k splitting operations. A Splitting operation is an operation during which Olya takes a square with side a and cuts it into 4 equal squares with side a/2. If the side of the square is equal to 1, then it is impossible to apply a splitting operation to it (see examples for better understanding). Olya is happy to fulfill her sister's request, but she also wants the condition of Olya's happiness to be satisfied after all operations. The condition of Olya's happiness will be satisfied if the following statement is fulfilled: Let the length of the side of the lower left square be equal to a, then the length of the side of the right upper square should also be equal to a. There should also be a path between them that consists only of squares with the side of length a. All consecutive squares on a path should have a common side. Obviously, as long as we have one square, these conditions are met. So Olya is ready to fulfill her sister's request only under the condition that she is satisfied too. Tell her: is it possible to perform exactly k splitting operations in a certain order so that the condition of Olya's happiness is satisfied? If it is possible, tell also the size of the side of squares of which the path from the lower left square to the upper right one will consist. Input The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of tests. Each of the following t lines contains two integers n_i and k_i (1 ≤ n_i ≤ 10^9, 1 ≤ k_i ≤ 10^{18}) — the description of the i-th test, which means that initially Olya's square has size of 2^{n_i}× 2^{n_i} and Olya's sister asks her to do exactly k_i splitting operations. Output Print t lines, where in the i-th line you should output "YES" if it is possible to perform k_i splitting operations in the i-th test in such a way that the condition of Olya's happiness is satisfied or print "NO" otherwise. If you printed "YES", then also print the log_2 of the length of the side of the squares through space, along which you can build a path from the lower left square to the upper right one. You can output each letter in any case (lower or upper). If there are multiple answers, print any. Example Input 3 1 1 2 2 2 12 Output YES 0 YES 1 NO Note In each of the illustrations, the pictures are shown in order in which Olya applied the operations. The recently-created squares are highlighted with red. In the first test, Olya can apply splitting operations in the following order: <image> Olya applies one operation on the only existing square. The condition of Olya's happiness will be met, since there is a path of squares of the same size from the lower left square to the upper right one: <image> The length of the sides of the squares on the path is 1. log_2(1) = 0. In the second test, Olya can apply splitting operations in the following order: <image> Olya applies the first operation on the only existing square. She applies the second one on the right bottom square. The condition of Olya's happiness will be met, since there is a path of squares of the same size from the lower left square to the upper right one: <image> The length of the sides of the squares on the path is 2. log_2(2) = 1. In the third test, it takes 5 operations for Olya to make the square look like this: <image> Since it requires her to perform 7 splitting operations, and it is impossible to perform them on squares with side equal to 1, then Olya cannot do anything more and the answer is "NO". The input will be give 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. Not long ago Billy came across such a problem, where there were given three natural numbers A, B and C from the range [1, N], and it was asked to check whether the equation AB = C is correct. Recently Billy studied the concept of a digital root of a number. We should remind you that a digital root d(x) of the number x is the sum s(x) of all the digits of this number, if s(x) ≤ 9, otherwise it is d(s(x)). For example, a digital root of the number 6543 is calculated as follows: d(6543) = d(6 + 5 + 4 + 3) = d(18) = 9. Billy has counted that the digital root of a product of numbers is equal to the digital root of the product of the factors' digital roots, i.e. d(xy) = d(d(x)d(y)). And the following solution to the problem came to his mind: to calculate the digital roots and check if this condition is met. However, Billy has doubts that this condition is sufficient. That's why he asks you to find out the amount of test examples for the given problem such that the algorithm proposed by Billy makes mistakes. Input The first line contains the only number N (1 ≤ N ≤ 106). Output Output one number — the amount of required A, B and C from the range [1, N]. Examples Input 4 Output 2 Input 5 Output 6 Note For the first sample the required triples are (3, 4, 3) and (4, 3, 3). The input will be give 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. Mike decided to teach programming to children in an elementary school. He knows that it is not an easy task to interest children in that age to code. That is why he decided to give each child two sweets. Mike has n sweets with sizes a_1, a_2, …, a_n. All his sweets have different sizes. That is, there is no such pair (i, j) (1 ≤ i, j ≤ n) such that i ≠ j and a_i = a_j. Since Mike has taught for many years, he knows that if he gives two sweets with sizes a_i and a_j to one child and a_k and a_p to another, where (a_i + a_j) ≠ (a_k + a_p), then a child who has a smaller sum of sizes will be upset. That is, if there are two children who have different sums of sweets, then one of them will be upset. Apparently, Mike does not want somebody to be upset. Mike wants to invite children giving each of them two sweets. Obviously, he can't give one sweet to two or more children. His goal is to invite as many children as he can. Since Mike is busy preparing to his first lecture in the elementary school, he is asking you to find the maximum number of children he can invite giving each of them two sweets in such way that nobody will be upset. Input The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of sweets Mike has. The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the sizes of the sweets. It is guaranteed that all integers are distinct. Output Print one integer — the maximum number of children Mike can invite giving each of them two sweets in such way that nobody will be upset. Examples Input 8 1 8 3 11 4 9 2 7 Output 3 Input 7 3 1 7 11 9 2 12 Output 2 Note In the first example, Mike can give 9+2=11 to one child, 8+3=11 to another one, and 7+4=11 to the third child. Therefore, Mike can invite three children. Note that it is not the only solution. In the second example, Mike can give 3+9=12 to one child and 1+11 to another one. Therefore, Mike can invite two children. Note that it is not the only solution. The input will be give 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. Linear Kingdom has exactly one tram line. It has n stops, numbered from 1 to n in the order of tram's movement. At the i-th stop ai passengers exit the tram, while bi passengers enter it. The tram is empty before it arrives at the first stop. Also, when the tram arrives at the last stop, all passengers exit so that it becomes empty. Your task is to calculate the tram's minimum capacity such that the number of people inside the tram at any time never exceeds this capacity. Note that at each stop all exiting passengers exit before any entering passenger enters the tram. Input The first line contains a single number n (2 ≤ n ≤ 1000) — the number of the tram's stops. Then n lines follow, each contains two integers ai and bi (0 ≤ ai, bi ≤ 1000) — the number of passengers that exits the tram at the i-th stop, and the number of passengers that enter the tram at the i-th stop. The stops are given from the first to the last stop in the order of tram's movement. * The number of people who exit at a given stop does not exceed the total number of people in the tram immediately before it arrives at the stop. More formally, <image>. This particularly means that a1 = 0. * At the last stop, all the passengers exit the tram and it becomes empty. More formally, <image>. * No passenger will enter the train at the last stop. That is, bn = 0. Output Print a single integer denoting the minimum possible capacity of the tram (0 is allowed). Examples Input 4 0 3 2 5 4 2 4 0 Output 6 Note For the first example, a capacity of 6 is sufficient: * At the first stop, the number of passengers inside the tram before arriving is 0. Then, 3 passengers enter the tram, and the number of passengers inside the tram becomes 3. * At the second stop, 2 passengers exit the tram (1 passenger remains inside). Then, 5 passengers enter the tram. There are 6 passengers inside the tram now. * At the third stop, 4 passengers exit the tram (2 passengers remain inside). Then, 2 passengers enter the tram. There are 4 passengers inside the tram now. * Finally, all the remaining passengers inside the tram exit the tram at the last stop. There are no passenger inside the tram now, which is in line with the constraints. Since the number of passengers inside the tram never exceeds 6, a capacity of 6 is sufficient. Furthermore it is not possible for the tram to have a capacity less than 6. Hence, 6 is the correct answer. The input will be give 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. Note that this is the first problem of the two similar problems. You can hack this problem only if you solve both problems. You are given a tree with n nodes. In the beginning, 0 is written on all edges. In one operation, you can choose any 2 distinct leaves u, v and any real number x and add x to values written on all edges on the simple path between u and v. For example, on the picture below you can see the result of applying two operations to the graph: adding 2 on the path from 7 to 6, and then adding -0.5 on the path from 4 to 5. <image> Is it true that for any configuration of real numbers written on edges, we can achieve it with a finite number of operations? Leaf is a node of a tree of degree 1. Simple path is a path that doesn't contain any node twice. Input The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes. Each of the next n-1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v. It is guaranteed that these edges form a tree. Output If there is a configuration of real numbers written on edges of the tree that we can't achieve by performing the operations, output "NO". Otherwise, output "YES". You can print each letter in any case (upper or lower). Examples Input 2 1 2 Output YES Input 3 1 2 2 3 Output NO Input 5 1 2 1 3 1 4 2 5 Output NO Input 6 1 2 1 3 1 4 2 5 2 6 Output YES Note In the first example, we can add any real x to the value written on the only edge (1, 2). <image> In the second example, one of configurations that we can't reach is 0 written on (1, 2) and 1 written on (2, 3). <image> Below you can see graphs from examples 3, 4: <image> <image> The input will be give 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 types of burgers in your restaurant — hamburgers and chicken burgers! To assemble a hamburger you need two buns and a beef patty. To assemble a chicken burger you need two buns and a chicken cutlet. You have b buns, p beef patties and f chicken cutlets in your restaurant. You can sell one hamburger for h dollars and one chicken burger for c dollars. Calculate the maximum profit you can achieve. You have to answer t independent queries. Input The first line contains one integer t (1 ≤ t ≤ 100) – the number of queries. The first line of each query contains three integers b, p and f (1 ≤ b, ~p, ~f ≤ 100) — the number of buns, beef patties and chicken cutlets in your restaurant. The second line of each query contains two integers h and c (1 ≤ h, ~c ≤ 100) — the hamburger and chicken burger prices in your restaurant. Output For each query print one integer — the maximum profit you can achieve. Example Input 3 15 2 3 5 10 7 5 2 10 12 1 100 100 100 100 Output 40 34 0 Note In first query you have to sell two hamburgers and three chicken burgers. Your income is 2 ⋅ 5 + 3 ⋅ 10 = 40. In second query you have to ell one hamburgers and two chicken burgers. Your income is 1 ⋅ 10 + 2 ⋅ 12 = 34. In third query you can not create any type of burgers because because you have only one bun. So your income is zero. The input will be give 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 constraints. The BerTV channel every day broadcasts one episode of one of the k TV shows. You know the schedule for the next n days: a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the show, the episode of which will be shown in i-th day. The subscription to the show is bought for the entire show (i.e. for all its episodes), for each show the subscription is bought separately. How many minimum subscriptions do you need to buy in order to have the opportunity to watch episodes of purchased shows d (1 ≤ d ≤ n) days in a row? In other words, you want to buy the minimum number of TV shows so that there is some segment of d consecutive days in which all episodes belong to the purchased shows. Input The first line contains an integer t (1 ≤ t ≤ 10000) — the number of test cases in the input. Then t test case descriptions follow. The first line of each test case contains three integers n, k and d (1 ≤ n ≤ 2⋅10^5, 1 ≤ k ≤ 10^6, 1 ≤ d ≤ n). The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the show that is broadcasted on the i-th day. It is guaranteed that the sum of the values of n for all test cases in the input does not exceed 2⋅10^5. Output Print t integers — the answers to the test cases in the input in the order they follow. The answer to a test case is the minimum number of TV shows for which you need to purchase a subscription so that you can watch episodes of the purchased TV shows on BerTV for d consecutive days. Please note that it is permissible that you will be able to watch more than d days in a row. Example Input 4 5 2 2 1 2 1 2 1 9 3 3 3 3 3 2 2 2 1 1 1 4 10 4 10 8 6 4 16 9 8 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 Output 2 1 4 5 Note In the first test case to have an opportunity to watch shows for two consecutive days, you need to buy a subscription on show 1 and on show 2. So the answer is two. In the second test case, you can buy a subscription to any show because for each show you can find a segment of three consecutive days, consisting only of episodes of this show. In the third test case in the unique segment of four days, you have four different shows, so you need to buy a subscription to all these four shows. In the fourth test case, you can buy subscriptions to shows 3,5,7,8,9, and you will be able to watch shows for the last eight days. The input will be give 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 two strings s and t anagrams of each other if it is possible to rearrange symbols in the string s to get a string, equal to t. Let's consider two strings s and t which are anagrams of each other. We say that t is a reducible anagram of s if there exists an integer k ≥ 2 and 2k non-empty strings s_1, t_1, s_2, t_2, ..., s_k, t_k that satisfy the following conditions: 1. If we write the strings s_1, s_2, ..., s_k in order, the resulting string will be equal to s; 2. If we write the strings t_1, t_2, ..., t_k in order, the resulting string will be equal to t; 3. For all integers i between 1 and k inclusive, s_i and t_i are anagrams of each other. If such strings don't exist, then t is said to be an irreducible anagram of s. Note that these notions are only defined when s and t are anagrams of each other. For example, consider the string s = "gamegame". Then the string t = "megamage" is a reducible anagram of s, we may choose for example s_1 = "game", s_2 = "gam", s_3 = "e" and t_1 = "mega", t_2 = "mag", t_3 = "e": <image> On the other hand, we can prove that t = "memegaga" is an irreducible anagram of s. You will be given a string s and q queries, represented by two integers 1 ≤ l ≤ r ≤ \|s\| (where \|s\| is equal to the length of the string s). For each query, you should find if the substring of s formed by characters from the l-th to the r-th has at least one irreducible anagram. Input The first line contains a string s, consisting of lowercase English characters (1 ≤ \|s\| ≤ 2 ⋅ 10^5). The second line contains a single integer q (1 ≤ q ≤ 10^5) — the number of queries. Each of the following q lines contain two integers l and r (1 ≤ l ≤ r ≤ \|s\|), representing a query for the substring of s formed by characters from the l-th to the r-th. Output For each query, print a single line containing "Yes" (without quotes) if the corresponding substring has at least one irreducible anagram, and a single line containing "No" (without quotes) otherwise. Examples Input aaaaa 3 1 1 2 4 5 5 Output Yes No Yes Input aabbbbbbc 6 1 2 2 4 2 2 1 9 5 7 3 5 Output No Yes Yes Yes No No Note In the first sample, in the first and third queries, the substring is "a", which has itself as an irreducible anagram since two or more non-empty strings cannot be put together to obtain "a". On the other hand, in the second query, the substring is "aaa", which has no irreducible anagrams: its only anagram is itself, and we may choose s_1 = "a", s_2 = "aa", t_1 = "a", t_2 = "aa" to show that it is a reducible anagram. In the second query of the second sample, the substring is "abb", which has, for example, "bba" as an irreducible anagram. The input will be give 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. Young boy Artem tries to paint a picture, and he asks his mother Medina to help him. Medina is very busy, that's why she asked for your help. Artem wants to paint an n × m board. Each cell of the board should be colored in white or black. Lets B be the number of black cells that have at least one white neighbor adjacent by the side. Let W be the number of white cells that have at least one black neighbor adjacent by the side. A coloring is called good if B = W + 1. The first coloring shown below has B=5 and W=4 (all cells have at least one neighbor with the opposite color). However, the second coloring is not good as it has B=4, W=4 (only the bottom right cell doesn't have a neighbor with the opposite color). <image> Please, help Medina to find any good coloring. It's guaranteed that under given constraints the solution always exists. If there are several solutions, output any of them. Input Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 20). Each of the next t lines contains two integers n, m (2 ≤ n,m ≤ 100) — the number of rows and the number of columns in the grid. Output For each test case print n lines, each of length m, where i-th line is the i-th row of your colored matrix (cell labeled with 'B' means that the cell is black, and 'W' means white). Do not use quotes. It's guaranteed that under given constraints the solution always exists. Example Input 2 3 2 3 3 Output BW WB BB BWB BWW BWB Note In the first testcase, B=3, W=2. In the second testcase, B=5, W=4. You can see the coloring in the statement. The input will be give 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 consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears: 1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one; 2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i. Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows: 1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0]; 2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0]; 3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0]; 4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0]; 5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5]. Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique. You have to answer t independent test cases. Input The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow. The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5). Output For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique. Example Input 6 1 2 3 4 5 6 Output 1 1 2 2 1 3 3 1 2 4 2 4 1 3 5 3 4 1 5 2 6 The input will be give 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.