Split (1)

train · 24.3k rows

question large_stringlengths 265 13.2k
Solve the programming task below in a Python markdown code block. Vasily the bear has a favorite rectangle, it has one vertex at point (0, 0), and the opposite vertex at point (x, y). Of course, the sides of Vasya's favorite rectangle are parallel to the coordinate axes. Vasya also loves triangles, if the triangles have one vertex at point B = (0, 0). That's why today he asks you to find two points A = (x_1, y_1) and C = (x_2, y_2), such that the following conditions hold: the coordinates of points: x_1, x_2, y_1, y_2 are integers. Besides, the following inequation holds: x_1 < x_2; the triangle formed by point A, B and C is rectangular and isosceles ($\angle A B C$ is right); all points of the favorite rectangle are located inside or on the border of triangle ABC; the area of triangle ABC is as small as possible. Help the bear, find the required points. It is not so hard to proof that these points are unique. -----Input----- The first line contains two integers x, y ( - 10^9 ≤ x, y ≤ 10^9, x ≠ 0, y ≠ 0). -----Output----- Print in the single line four integers x_1, y_1, x_2, y_2 — the coordinates of the required points. -----Examples----- Input 10 5 Output 0 15 15 0 Input -10 5 Output -15 0 0 15 -----Note----- [Image] Figure to the first sample 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. Berland, 2016. The exchange rate of currency you all know against the burle has increased so much that to simplify the calculations, its fractional part was neglected and the exchange rate is now assumed to be an integer. Reliable sources have informed the financier Anton of some information about the exchange rate of currency you all know against the burle for tomorrow. Now Anton knows that tomorrow the exchange rate will be an even number, which can be obtained from the present rate by swapping exactly two distinct digits in it. Of all the possible values that meet these conditions, the exchange rate for tomorrow will be the maximum possible. It is guaranteed that today the exchange rate is an odd positive integer n. Help Anton to determine the exchange rate of currency you all know for tomorrow! -----Input----- The first line contains an odd positive integer n — the exchange rate of currency you all know for today. The length of number n's representation is within range from 2 to 10^5, inclusive. The representation of n doesn't contain any leading zeroes. -----Output----- If the information about tomorrow's exchange rate is inconsistent, that is, there is no integer that meets the condition, print - 1. Otherwise, print the exchange rate of currency you all know against the burle for tomorrow. This should be the maximum possible number of those that are even and that are obtained from today's exchange rate by swapping exactly two digits. Exchange rate representation should not contain leading zeroes. -----Examples----- Input 527 Output 572 Input 4573 Output 3574 Input 1357997531 Output -1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A popular game in a certain country, Pachimon Creature, has been remade and released in Japan. If you love games, after playing this game many times, you've come to think about how you can clear it the fastest. However, no matter how much you think about it, you didn't know the fastest way to capture it, so you decided to create a program that asks how quickly you can clear the game. The details of the game are as follows. The game is set in a world where many creatures called Pachimon creatures (hereinafter referred to as Pachikuri) exist. Each pachikuri has one of five attributes: fire, ice, wood, soil, and water. At the beginning of the game, the main character of the game chooses one pachikuri with his favorite attributes as an adventure partner. The purpose of the game is to aim for the goal with the pachikuri, defeat the rivals in the goal and become the pachikuri master. However, in order to defeat a rival, you cannot win without the pachikuri of all attributes, so you have to catch the pachikuri of all attributes on the way. Attributes are the key to catching pachikuri. A fire-type crackle can catch an ice-type crackle, and similarly, an ice-type crackle can catch a wood-type, a wood-type can catch a soil-type, a soil-type can catch a water-type, and a water-type can catch a fire-type. The relationship between the attributes is shown in the figure below. <image> The figure below shows an example of a map where the game is played. <image> The main character starts from the starting point "S" with a pachikuri and aims at the goal point "G" while moving one square at a time. On the way, if you catch the pachikuri of four attributes other than the first pachikuri you have and move to the square that is the goal point, the game will end. The main character can move from the current square to the next square that shares the side, and counts it as one move. When the main character moves to a square with a pachikuri, if he has a pachikuri with an attribute that can catch that pachikuri, he has caught that pachikuri. You can move to all the squares as many times as you like, regardless of whether you can catch the pachikuri in that square. Enter the size of the map (number of columns in the horizontal direction, number of rows in the vertical direction) and the initial state of the map, and start to catch the pachikuri attribute selected at the beginning and the pachikuri of the other four attributes. Create a program that outputs the minimum number of movements from the point to the goal point. 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 c11c12 ... c1W c21c22 ... c2W :: cH1cH2 ... cHW The first row gives the number of horizontal columns W and the number of vertical rows H (2 ≤ W, H ≤ 1000) of the map. The following line H is given the information on line i of the map. The state of each cell is given to the input map. "S" is the starting point of the main character, "G" is the goal point, "1" "2" "3" "4" "5" is the attribute of the pachikuri there (1: fire attribute, 2: ice) Attribute, 3: Tree attribute, 4: Earth attribute, 5: Water attribute), ". (Period)" represents an empty cell, respectively. The number of pachikuri for each attribute should be 0 or more and 1000 or less. The number of datasets does not exceed 140. Also, for 80% of the dataset, W and H do not exceed 100. Output For each input data set, the attribute of the first selected Pachikuri and the minimum number of movements are output on one line. No matter how you select the first pachikuri, if you cannot catch the pachikuri of those four attributes no matter what route you move, output NA. Also, if there are multiple ways to select the first pachikuri so that the minimum number of movements is the same, output the one with the smaller attribute number. Example Input 6 6 S.1..4 3..5.. ..4.1. 4....5 .2.32. 5.1..G 3 2 ... S.G 0 0 Output 2 10 NA 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. Igor is a post-graduate student of chemistry faculty in Berland State University (BerSU). He needs to conduct a complicated experiment to write his thesis, but laboratory of BerSU doesn't contain all the materials required for this experiment. Fortunately, chemical laws allow material transformations (yes, chemistry in Berland differs from ours). But the rules of transformation are a bit strange. Berland chemists are aware of n materials, numbered in the order they were discovered. Each material can be transformed into some other material (or vice versa). Formally, for each i (2 ≤ i ≤ n) there exist two numbers x_{i} and k_{i} that denote a possible transformation: k_{i} kilograms of material x_{i} can be transformed into 1 kilogram of material i, and 1 kilogram of material i can be transformed into 1 kilogram of material x_{i}. Chemical processing equipment in BerSU allows only such transformation that the amount of resulting material is always an integer number of kilograms. For each i (1 ≤ i ≤ n) Igor knows that the experiment requires a_{i} kilograms of material i, and the laboratory contains b_{i} kilograms of this material. Is it possible to conduct an experiment after transforming some materials (or none)? -----Input----- The first line contains one integer number n (1 ≤ n ≤ 10^5) — the number of materials discovered by Berland chemists. The second line contains n integer numbers b_1, b_2... b_{n} (1 ≤ b_{i} ≤ 10^12) — supplies of BerSU laboratory. The third line contains n integer numbers a_1, a_2... a_{n} (1 ≤ a_{i} ≤ 10^12) — the amounts required for the experiment. Then n - 1 lines follow. j-th of them contains two numbers x_{j} + 1 and k_{j} + 1 that denote transformation of (j + 1)-th material (1 ≤ x_{j} + 1 ≤ j, 1 ≤ k_{j} + 1 ≤ 10^9). -----Output----- Print YES if it is possible to conduct an experiment. Otherwise print NO. -----Examples----- Input 3 1 2 3 3 2 1 1 1 1 1 Output YES Input 3 3 2 1 1 2 3 1 1 1 2 Output NO Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Hongcow is ruler of the world. As ruler of the world, he wants to make it easier for people to travel by road within their own countries. The world can be modeled as an undirected graph with n nodes and m edges. k of the nodes are home to the governments of the k countries that make up the world. There is at most one edge connecting any two nodes and no edge connects a node to itself. Furthermore, for any two nodes corresponding to governments, there is no path between those two nodes. Any graph that satisfies all of these conditions is stable. Hongcow wants to add as many edges as possible to the graph while keeping it stable. Determine the maximum number of edges Hongcow can add. -----Input----- The first line of input will contain three integers n, m and k (1 ≤ n ≤ 1 000, 0 ≤ m ≤ 100 000, 1 ≤ k ≤ n) — the number of vertices and edges in the graph, and the number of vertices that are homes of the government. The next line of input will contain k integers c_1, c_2, ..., c_{k} (1 ≤ c_{i} ≤ n). These integers will be pairwise distinct and denote the nodes that are home to the governments in this world. The following m lines of input will contain two integers u_{i} and v_{i} (1 ≤ u_{i}, v_{i} ≤ n). This denotes an undirected edge between nodes u_{i} and v_{i}. It is guaranteed that the graph described by the input is stable. -----Output----- Output a single integer, the maximum number of edges Hongcow can add to the graph while keeping it stable. -----Examples----- Input 4 1 2 1 3 1 2 Output 2 Input 3 3 1 2 1 2 1 3 2 3 Output 0 -----Note----- For the first sample test, the graph looks like this: [Image] Vertices 1 and 3 are special. The optimal solution is to connect vertex 4 to vertices 1 and 2. This adds a total of 2 edges. We cannot add any more edges, since vertices 1 and 3 cannot have any path between them. For the second sample test, the graph looks like this: $\infty$ We cannot add any more edges to this graph. Note that we are not allowed to add self-loops, and the graph must be simple. 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 already know that Valery's favorite sport is biathlon. Due to your help, he learned to shoot without missing, and his skills are unmatched at the shooting range. But now a smaller task is to be performed, he should learn to complete the path fastest. The track's map is represented by a rectangle n × m in size divided into squares. Each square is marked with a lowercase Latin letter (which means the type of the plot), with the exception of the starting square (it is marked with a capital Latin letters S) and the terminating square (it is marked with a capital Latin letter T). The time of movement from one square to another is equal to 1 minute. The time of movement within the cell can be neglected. We can move from the cell only to side-adjacent ones, but it is forbidden to go beyond the map edges. Also the following restriction is imposed on the path: it is not allowed to visit more than k different types of squares (squares of one type can be visited an infinite number of times). Squares marked with S and T have no type, so they are not counted. But S must be visited exactly once — at the very beginning, and T must be visited exactly once — at the very end. Your task is to find the path from the square S to the square T that takes minimum time. Among all shortest paths you should choose the lexicographically minimal one. When comparing paths you should lexicographically represent them as a sequence of characters, that is, of plot types. Input The first input line contains three integers n, m and k (1 ≤ n, m ≤ 50, n·m ≥ 2, 1 ≤ k ≤ 4). Then n lines contain the map. Each line has the length of exactly m characters and consists of lowercase Latin letters and characters S and T. It is guaranteed that the map contains exactly one character S and exactly one character T. Pretest 12 is one of the maximal tests for this problem. Output If there is a path that satisfies the condition, print it as a sequence of letters — the plot types. Otherwise, print "-1" (without quotes). You shouldn't print the character S in the beginning and T in the end. Note that this sequence may be empty. This case is present in pretests. You can just print nothing or print one "End of line"-character. Both will be accepted. Examples Input 5 3 2 Sba ccc aac ccc abT Output bcccc Input 3 4 1 Sxyy yxxx yyyT Output xxxx Input 1 3 3 TyS Output y Input 1 4 1 SxyT Output -1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi is taking exams on N subjects. The score on each subject will be an integer between 0 and K (inclusive). He has already taken exams on N-1 subjects and scored A_i points on the i-th subject. His goal is to achieve the average score of M points or above on the N subjects. Print the minimum number of points Takahashi needs on the final subject to achieve his goal. If the goal is unachievable, print -1 instead. -----Constraints----- - 2 \leq N \leq 100 - 1 \leq K \leq 100 - 1 \leq M \leq K - 0 \leq A_i \leq K - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: N K M A_1 A_2 ... A_{N-1} -----Output----- Print the minimum number of points required on the final subject, or -1. -----Sample Input----- 5 10 7 8 10 3 6 -----Sample Output----- 8 If he scores 8 points on the final subject, his average score will be (8+10+3+6+8)/5 = 7 points, which meets the goal. 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 If you bring an empty bottle of $ a $ milk, you can exchange it for a new bottle of $ b $ milk. How many bottles of milk can Mr. Kawabayashi, who initially has a bottle of $ x $ milk, drink? Output the remainder after dividing by $ 1000000007 $. Constraints The input satisfies the following conditions. * $ 1 \ leq a \ leq 10 ^ {15} $ * $ 0 \ leq b \ lt a $ * $ 0 \ leq x \ leq 10 ^ {15} $ Input The input is given in the following format. $ a $ $ b $ $ x $ Three integers $ a $, $ b $, $ x $ are given, separated by spaces. Output Print the answer on one line. Examples Input 3 1 5 Output 7 Input 3 2 5 Output 11 Input 82 69 64 Output 64 Input 316250877917604 316250877917599 681260158257385 Output 62687552 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. Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer. In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario. <image> Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins. Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game. Input The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game. The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set. The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set 1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2. Output In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end. Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end. Examples Input 5 2 3 2 3 1 2 3 Output Lose Win Win Loop Loop Win Win Win Input 8 4 6 2 3 4 2 3 6 Output Win Win Win Win Win Win Win Lose Win Lose Lose Win Lose Lose 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 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. Your job is to write function last_digits(n,d) which return the last `d` digits of an integer `n` as a list. `n` will be from 0 to 10^10 Examples: `last_digits(1,1) --> [1]` `last_digits(1234,2) --> [3,4]` `last_digits(637547,6) --> [6,3,7,5,4,7]` Special cases: If `d` > the number of digits, just return the number's digits as a list. If `d` <= 0, then return an empty list. This is the first kata I have made, so please report any issues. Write your solution by modifying this code: ```python def solution(n,d): ``` Your solution should implemented in the function "solution". The i 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. Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works. <image> As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works. Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit. The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan. <image> Input A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format: n cube1 cube2 :: cuben The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format. c1 c2 c3 c4 c5 c6 The color arrangement ci of the work is given, separated by blanks. The number of datasets does not exceed 100. Output For each dataset, output how many more works are needed to exhibit in one line. Example Input 3 Cyan Yellow Red Magenta Green Blue Cyan Yellow Red Magenta Green Blue Red Yellow Magenta Blue Green Cyan 4 Red Magenta Blue Green Yellow Cyan Red Yellow Magenta Blue Green Cyan Magenta Green Red Cyan Yellow Blue Cyan Green Yellow Blue Magenta Red 0 Output 1 1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money. The manager of logging factory wants them to go to the jungle and cut n trees with heights a_1, a_2, ..., a_{n}. They bought a chain saw from a shop. Each time they use the chain saw on the tree number i, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is i (the tree that have height a_{i} in the beginning), then the cost of charging the chain saw would be b_{i}. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each i < j, a_{i} < a_{j} and b_{i} > b_{j} and also b_{n} = 0 and a_1 = 1. Kalila and Dimna want to cut all the trees completely, with minimum cost. They want you to help them! Will you? -----Input----- The first line of input contains an integer n (1 ≤ n ≤ 10^5). The second line of input contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9). The third line of input contains n integers b_1, b_2, ..., b_{n} (0 ≤ b_{i} ≤ 10^9). It's guaranteed that a_1 = 1, b_{n} = 0, a_1 < a_2 < ... < a_{n} and b_1 > b_2 > ... > b_{n}. -----Output----- The only line of output must contain the minimum cost of cutting all the trees completely. Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. -----Examples----- Input 5 1 2 3 4 5 5 4 3 2 0 Output 25 Input 6 1 2 3 10 20 30 6 5 4 3 2 0 Output 138 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. #Unflatten a list (Easy) There are several katas like "Flatten a list". These katas are done by so many warriors, that the count of available list to flattin goes down! So you have to build a method, that creates new arrays, that can be flattened! #Shorter: You have to unflatten a list/an array. You get an array of integers and have to unflatten it by these rules: ``` - You start at the first number. - If this number x is smaller than 3, take this number x direct for the new array and continue with the next number. - If this number x is greater than 2, take the next x numbers (inclusive this number) as a sub-array in the new array. Continue with the next number AFTER this taken numbers. - If there are too few numbers to take by number, take the last available numbers. ``` The given array will always contain numbers. There will only be numbers > 0. Example: ``` [1,4,5,2,1,2,4,5,2,6,2,3,3] -> [1,[4,5,2,1],2,[4,5,2,6],2,[3,3]] Steps: 1. The 1 is added directly to the new array. 2. The next number is 4. So the next 4 numbers (4,5,2,1) are added as sub-array in the new array. 3. The 2 is added directly to the new array. 4. The next number is 4. So the next 4 numbers (4,5,2,6) are added as sub-array in the new array. 5. The 2 is added directly to the new array. 6. The next number is 3. So the next 3 numbers would be taken. There are only 2, so take these (3,3) as sub-array in the new array. ``` There is a harder version of this kata! Unflatten a list (Harder than easy) Have fun coding it and please don't forget to vote and rank this kata! :-) I have created other katas. Have a look if you like coding and challenges. Write your solution by modifying this code: ```python def unflatten(flat_array): ``` Your solution should implemented in the function "unflatten". The i 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 equation: Ax2 + Bx + C = 0. Your task is to find the number of distinct roots of the equation and print all of them in ascending order. Input The first line contains three integer numbers A, B and C ( - 105 ≤ A, B, C ≤ 105). Any coefficient may be equal to 0. Output In case of infinite root count print the only integer -1. In case of no roots print the only integer 0. In other cases print the number of root on the first line and the roots on the following lines in the ascending order. Print roots with at least 5 digits after the decimal point. Examples Input 1 -5 6 Output 2 2.0000000000 3.0000000000 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. Implement a class/function, which should parse time expressed as `HH:MM:SS`, or `null/nil/None` otherwise. Any extra characters, or minutes/seconds higher than 59 make the input invalid, and so should return `null/nil/None`. Write your solution by modifying this code: ```python def to_seconds(time): ``` Your solution should implemented in the function "to_seconds". The i Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. People in Silverland use square coins. Not only they have square shapes but also their values are square numbers. Coins with values of all square numbers up to 289 (= 172), i.e., 1-credit coins, 4-credit coins, 9-credit coins, ..., and 289-credit coins, are available in Silverland. There are four combinations of coins to pay ten credits: * ten 1-credit coins, * one 4-credit coin and six 1-credit coins, * two 4-credit coins and two 1-credit coins, and * one 9-credit coin and one 1-credit coin. Your mission is to count the number of ways to pay a given amount using coins of Silverland. Input The input consists of lines each containing an integer meaning an amount to be paid, followed by a line containing a zero. You may assume that all the amounts are positive and less than 300. Output For each of the given amount, one line containing a single integer representing the number of combinations of coins should be output. No other characters should appear in the output. Example Input 2 10 30 0 Output 1 4 27 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. Game "Minesweeper 1D" is played on a line of squares, the line's height is 1 square, the line's width is n squares. Some of the squares contain bombs. If a square doesn't contain a bomb, then it contains a number from 0 to 2 — the total number of bombs in adjacent squares. For example, the correct field to play looks like that: 0012*101. The cells that are marked with "" contain bombs. Note that on the correct field the numbers represent the number of bombs in adjacent cells. For example, field 2 is not correct, because cell with value 2 must have two adjacent cells with bombs. Valera wants to make a correct field to play "Minesweeper 1D". He has already painted a squared field with width of n cells, put several bombs on the field and wrote numbers into some cells. Now he wonders how many ways to fill the remaining cells with bombs and numbers are there if we should get a correct field in the end. -----Input----- The first line contains sequence of characters without spaces s_1s_2... s_{n} (1 ≤ n ≤ 10^6), containing only characters "", "?" and digits "0", "1" or "2". If character s_{i} equals "", then the i-th cell of the field contains a bomb. If character s_{i} equals "?", then Valera hasn't yet decided what to put in the i-th cell. Character s_{i}, that is equal to a digit, represents the digit written in the i-th square. -----Output----- Print a single integer — the number of ways Valera can fill the empty cells and get a correct field. As the answer can be rather large, print it modulo 1000000007 (10^9 + 7). -----Examples----- Input ?01??? Output 4 Input ? Output 2 Input 12 Output 0 Input 1 Output 0 -----Note----- In the first test sample you can get the following correct fields: 0011, 001**, 0012, 00110. 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. Trouble came from the overseas lands: a three-headed dragon Gorynych arrived. The dragon settled at point C and began to terrorize the residents of the surrounding villages. A brave hero decided to put an end to the dragon. He moved from point A to fight with Gorynych. The hero rode from point A along a straight road and met point B on his way. The hero knows that in this land for every pair of roads it is true that they are either parallel to each other, or lie on a straight line, or are perpendicular to each other. He also knows well that points B and C are connected by a road. So the hero must either turn 90 degrees to the left or continue riding straight ahead or turn 90 degrees to the right. But he forgot where the point C is located. Fortunately, a Brave Falcon flew right by. It can see all three points from the sky. The hero asked him what way to go to get to the dragon's lair. If you have not got it, you are the falcon. Help the hero and tell him how to get him to point C: turn left, go straight or turn right. At this moment the hero is believed to stand at point B, turning his back to point A. Input The first input line contains two space-separated integers xa, ya (\|xa\|, \|ya\| ≤ 109) — the coordinates of point A. The second line contains the coordinates of point B in the same form, the third line contains the coordinates of point C. It is guaranteed that all points are pairwise different. It is also guaranteed that either point B lies on segment AC, or angle ABC is right. Output Print a single line. If a hero must turn left, print "LEFT" (without the quotes); If he must go straight ahead, print "TOWARDS" (without the quotes); if he should turn right, print "RIGHT" (without the quotes). Examples Input 0 0 0 1 1 1 Output RIGHT Input -1 -1 -3 -3 -4 -4 Output TOWARDS Input -4 -6 -3 -7 -2 -6 Output LEFT Note The picture to the first sample: <image> The red color shows points A, B and C. The blue arrow shows the hero's direction. The green color shows the hero's trajectory. The picture to the second sample: <image> Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands: * Include a person to the chat ('Add' command). * Remove a person from the chat ('Remove' command). * Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command). Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands. Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message. As Polycarp has no time, he is asking for your help in solving this problem. Input Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following: * +<name> for 'Add' command. * -<name> for 'Remove' command. * <sender_name>:<message_text> for 'Send' command. <name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line. It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc. All names are case-sensitive. Output Print a single number — answer to the problem. Examples Input +Mike Mike:hello +Kate +Dmitry -Dmitry Kate:hi -Kate Output 9 Input +Mike -Mike +Mike Mike:Hi I am here -Mike +Kate -Kate Output 14 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. #It's show time! Archers have gathered from all around the world to participate in the Arrow Function Faire. But the faire will only start if there are archers signed and if they all have enough arrows in their quivers - at least 5 is the requirement! Are all the archers ready? #Reference https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions #Argument `archers` is an array of integers, in which each element corresponds to the number of arrows each archer has. #Return Your function must return `true` if the requirements are met or `false` otherwise. #Examples `archersReady([1, 2, 3, 4, 5, 6, 7, 8])` returns `false` because there are archers with not enough arrows. `archersReady([5, 6, 7, 8])` returns `true`. Write your solution by modifying this code: ```python def archers_ready(archers): ``` Your solution should implemented in the function "archers_ready". The i 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. Following from the previous kata and taking into account how cool psionic powers are compare to the Vance spell system (really, the idea of slots to dumb down the game sucks, not to mention that D&D became a smash hit among geeks, so...), your task in this kata is to create a function that returns how many power points you get as a psion [because psions are the coolest, they allow for a lot of indepth tactic playing and adjusting for psychic warriors or wilders or other non-core classes would be just an obnoxious core]. Consider both [the psion power points/days table](http://www.dandwiki.com/wiki/SRD:Psion#Making_a_Psion) and [bonus power points](http://www.d20pfsrd.com/psionics-unleashed/classes/#Table_Ability_Modifiers_and_Bonus_Power_Points) to figure out the correct reply, returned as an integer; the usual interpretation is that bonus power points stop increasing after level 20, but for the scope of this kata, we will pretend they keep increasing as they did before. To compute the total, you will be provided, both as non-negative integers: * class level (assume they are all psion levels and remember the base power points/day halts after level 20) * manifesting attribute score (Intelligence, to be more precise) to determine the total, provided the score is high enough for the character to manifest at least one power. Some examples: ```python psion_power_points(1,0) == 0 psion_power_points(1,10) == 0 psion_power_points(1,11) == 2 psion_power_points(1,20) == 4 psion_power_points(21,30) == 448 ``` Note: I didn't explain things in detail and just pointed out to the table on purpose, as my goal is also to train the pattern recognition skills of whoever is going to take this challenges, so do not complain about a summary description. Thanks :) In the same series: * [D&D Character generator #1: attribute modifiers and spells](https://www.codewars.com/kata/d-and-d-character-generator-number-1-attribute-modifiers-and-spells/) * [D&D Character generator #2: psion power points](https://www.codewars.com/kata/d-and-d-character-generator-number-2-psion-power-points/) * [D&D Character generator #3: carrying capacity](https://www.codewars.com/kata/d-and-d-character-generator-number-3-carrying-capacity/) Write your solution by modifying this code: ```python def psion_power_points(level,score): ``` Your solution should implemented in the function "psion_power_points". The i 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 analyzes a string called abracadabra. This string is constructed using the following algorithm: * On the first step the string consists of a single character "a". * On the k-th step Polycarpus concatenates two copies of the string obtained on the (k - 1)-th step, while inserting the k-th character of the alphabet between them. Polycarpus uses the alphabet that consists of lowercase Latin letters and digits (a total of 36 characters). The alphabet characters are numbered like this: the 1-st character is "a", the 2-nd — "b", ..., the 26-th — "z", the 27-th — "0", the 28-th — "1", ..., the 36-th — "9". Let's have a closer look at the algorithm. On the second step Polycarpus will concatenate two strings "a" and insert the character "b" between them, resulting in "aba" string. The third step will transform it into "abacaba", and the fourth one - into "abacabadabacaba". Thus, the string constructed on the k-th step will consist of 2k - 1 characters. Polycarpus wrote down the string he got after 30 steps of the given algorithm and chose two non-empty substrings of it. Your task is to find the length of the longest common substring of the two substrings selected by Polycarpus. A substring s[i... j] (1 ≤ i ≤ j ≤ \|s\|) of string s = s1s2... s\|s\| is a string sisi + 1... sj. For example, substring s[2...4] of string s = "abacaba" equals "bac". The string is its own substring. The longest common substring of two strings s and t is the longest string that is a substring of both s and t. For example, the longest common substring of "contest" and "systemtesting" is string "test". There can be several common substrings of maximum length. Input The input consists of a single line containing four integers l1, r1, l2, r2 (1 ≤ li ≤ ri ≤ 109, i = 1, 2). The numbers are separated by single spaces. li and ri give the indices of the first and the last characters of the i-th chosen substring, correspondingly (i = 1, 2). The characters of string abracadabra are numbered starting from 1. Output Print a single number — the length of the longest common substring of the given strings. If there are no common substrings, print 0. Examples Input 3 6 1 4 Output 2 Input 1 1 4 4 Output 0 Note In the first sample the first substring is "acab", the second one is "abac". These two substrings have two longest common substrings "ac" and "ab", but we are only interested in their length — 2. In the second sample the first substring is "a", the second one is "c". These two substrings don't have any common characters, so the length of their longest common substring is 0. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. For the multiset of positive integers $s=\{s_1,s_2,\dots,s_k\}$, define the Greatest Common Divisor (GCD) and Least Common Multiple (LCM) of $s$ as follow: $\gcd(s)$ is the maximum positive integer $x$, such that all integers in $s$ are divisible on $x$. $\textrm{lcm}(s)$ is the minimum positive integer $x$, that divisible on all integers from $s$. For example, $\gcd(\{8,12\})=4,\gcd(\{12,18,6\})=6$ and $\textrm{lcm}(\{4,6\})=12$. Note that for any positive integer $x$, $\gcd(\{x\})=\textrm{lcm}(\{x\})=x$. Orac has a sequence $a$ with length $n$. He come up with the multiset $t=\{\textrm{lcm}(\{a_i,a_j\})\ \|\ i<j\}$, and asked you to find the value of $\gcd(t)$ for him. In other words, you need to calculate the GCD of LCMs of all pairs of elements in the given sequence. -----Input----- The first line contains one integer $n\ (2\le n\le 100\,000)$. The second line contains $n$ integers, $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 200\,000$). -----Output----- Print one integer: $\gcd(\{\textrm{lcm}(\{a_i,a_j\})\ \|\ i<j\})$. -----Examples----- Input 2 1 1 Output 1 Input 4 10 24 40 80 Output 40 Input 10 540 648 810 648 720 540 594 864 972 648 Output 54 -----Note----- For the first example, $t=\{\textrm{lcm}(\{1,1\})\}=\{1\}$, so $\gcd(t)=1$. For the second example, $t=\{120,40,80,120,240,80\}$, and it's not hard to see that $\gcd(t)=40$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A sequence of positive integers is called great for a positive integer $x$, if we can split it into pairs in such a way that in each pair the first number multiplied by $x$ is equal to the second number. More formally, a sequence $a$ of size $n$ is great for a positive integer $x$, if $n$ is even and there exists a permutation $p$ of size $n$, such that for each $i$ ($1 \le i \le \frac{n}{2}$) $a_{p_{2i-1}} \cdot x = a_{p_{2i}}$. Sam has a sequence $a$ and a positive integer $x$. Help him to make the sequence great: find the minimum possible number of positive integers that should be added to the sequence $a$ to make it great for the number $x$. -----Input----- Each test contains multiple test cases. The first line contains a single integer $t$ ($1 \le t \le 20000$) — the number of test cases. Description of the test cases follows. The first line of each test case contains two integers $n$, $x$ ($1 \le n \le 2 \cdot 10^5$, $2 \le x \le 10^6$). The next line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$). It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$. -----Output----- For each test case print a single integer — the minimum number of integers that can be added to the end of $a$ to make it a great sequence for the number $x$. -----Examples----- Input 4 4 4 1 16 4 4 6 2 1 2 2 2 4 7 5 3 5 2 3 5 15 9 10 10 10 10 20 1 100 200 2000 3 Output 0 2 3 3 -----Note----- In the first test case, Sam got lucky and the sequence is already great for the number $4$ because you can divide it into such pairs: $(1, 4)$, $(4, 16)$. Thus we can add $0$ numbers. In the second test case, you can add numbers $1$ and $14$ to the sequence, then you can divide all $8$ integers into such pairs: $(1, 2)$, $(1, 2)$, $(2, 4)$, $(7, 14)$. It is impossible to add less than $2$ integers to fix the sequence. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given two integers $n$ and $k$. You should create an array of $n$ positive integers $a_1, a_2, \dots, a_n$ such that the sum $(a_1 + a_2 + \dots + a_n)$ is divisible by $k$ and maximum element in $a$ is minimum possible. What is the minimum possible maximum element in $a$? -----Input----- The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases. The first and only line of each test case contains two integers $n$ and $k$ ($1 \le n \le 10^9$; $1 \le k \le 10^9$). -----Output----- For each test case, print one integer — the minimum possible maximum element in array $a$ such that the sum $(a_1 + \dots + a_n)$ is divisible by $k$. -----Examples----- Input 4 1 5 4 3 8 8 8 17 Output 5 2 1 3 -----Note----- In the first test case $n = 1$, so the array consists of one element $a_1$ and if we make $a_1 = 5$ it will be divisible by $k = 5$ and the minimum possible. In the second test case, we can create array $a = [1, 2, 1, 2]$. The sum is divisible by $k = 3$ and the maximum is equal to $2$. In the third test case, we can create array $a = [1, 1, 1, 1, 1, 1, 1, 1]$. The sum is divisible by $k = 8$ and the maximum is equal to $1$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. A substring of some string is called the most frequent, if the number of its occurrences is not less than number of occurrences of any other substring. You are given a set of strings. A string (not necessarily from this set) is called good if all elements of the set are the most frequent substrings of this string. Restore the non-empty good string with minimum length. If several such strings exist, restore lexicographically minimum string. If there are no good strings, print "NO" (without quotes). A substring of a string is a contiguous subsequence of letters in the string. For example, "ab", "c", "abc" are substrings of string "abc", while "ac" is not a substring of that string. The number of occurrences of a substring in a string is the number of starting positions in the string where the substring occurs. These occurrences could overlap. String a is lexicographically smaller than string b, if a is a prefix of b, or a has a smaller letter at the first position where a and b differ. -----Input----- The first line contains integer n (1 ≤ n ≤ 10^5) — the number of strings in the set. Each of the next n lines contains a non-empty string consisting of lowercase English letters. It is guaranteed that the strings are distinct. The total length of the strings doesn't exceed 10^5. -----Output----- Print the non-empty good string with minimum length. If several good strings exist, print lexicographically minimum among them. Print "NO" (without quotes) if there are no good strings. -----Examples----- Input 4 mail ai lru cf Output cfmailru Input 3 kek preceq cheburek Output NO -----Note----- One can show that in the first sample only two good strings with minimum length exist: "cfmailru" and "mailrucf". The first string is lexicographically minimum. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vova had a pretty weird sleeping schedule. There are $h$ hours in a day. Vova will sleep exactly $n$ times. The $i$-th time he will sleep exactly after $a_i$ hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is $0$). Each time Vova sleeps exactly one day (in other words, $h$ hours). Vova thinks that the $i$-th sleeping time is good if he starts to sleep between hours $l$ and $r$ inclusive. Vova can control himself and before the $i$-th time can choose between two options: go to sleep after $a_i$ hours or after $a_i - 1$ hours. Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally. -----Input----- The first line of the input contains four integers $n, h, l$ and $r$ ($1 \le n \le 2000, 3 \le h \le 2000, 0 \le l \le r < h$) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time. The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i < h$), where $a_i$ is the number of hours after which Vova goes to sleep the $i$-th time. -----Output----- Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally. -----Example----- Input 7 24 21 23 16 17 14 20 20 11 22 Output 3 -----Note----- The maximum number of good times in the example is $3$. The story starts from $t=0$. Then Vova goes to sleep after $a_1 - 1$ hours, now the time is $15$. This time is not good. Then Vova goes to sleep after $a_2 - 1$ hours, now the time is $15 + 16 = 7$. This time is also not good. Then Vova goes to sleep after $a_3$ hours, now the time is $7 + 14 = 21$. This time is good. Then Vova goes to sleep after $a_4 - 1$ hours, now the time is $21 + 19 = 16$. This time is not good. Then Vova goes to sleep after $a_5$ hours, now the time is $16 + 20 = 12$. This time is not good. Then Vova goes to sleep after $a_6$ hours, now the time is $12 + 11 = 23$. This time is good. Then Vova goes to sleep after $a_7$ hours, now the time is $23 + 22 = 21$. This time is also good. 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 dive into one of the most interesting areas of magic — writing spells. Learning this exciting but challenging science is very troublesome, so now you will not learn the magic words, but only get to know the basic rules of writing spells. Each spell consists of several lines. The line, whose first non-space character is character "#" is an amplifying line and it is responsible for spell power. The remaining lines are common, and determine the effect of the spell. You came across the text of some spell. Spell was too long, so you cannot understand its meaning. So you want to make it as short as possible without changing the meaning. The only way to shorten a spell that you know is the removal of some spaces and line breaks. We know that when it comes to texts of spells, the spaces carry meaning only in the amplifying lines, so we should remove all spaces in other lines. Newlines also do not matter, unless any of the two separated lines is amplifying. Thus, if two consecutive lines are not amplifying, they need to be joined into one (i.e. we should concatenate the second line to the first one). Removing spaces in amplifying lines and concatenating the amplifying lines to anything is forbidden. Note that empty lines must be processed just like all the others: they must be joined to the adjacent non-amplifying lines, or preserved in the output, if they are surrounded with amplifying lines on both sides (i.e. the line above it, if there is one, is amplifying, and the line below it, if there is one, is amplifying too). For now those are the only instructions for removing unnecessary characters that you have to follow (oh yes, a newline is a character, too). The input contains the text of the spell, which should be reduced. Remove the extra characters and print the result to the output. Input The input contains multiple lines. All characters in the lines have codes from 32 to 127 (inclusive). Please note that the lines may begin with or end with one or more spaces. The size of the input does not exceed 1048576 ( = 220) bytes. Newlines are included in this size. In the Windows operating system used on the testing computer, a newline is a sequence of characters with codes #13#10. It is guaranteed that after each line of input there is a newline. In particular, the input ends with a newline. Note that the newline is the end of the line, and not the beginning of the next one. It is guaranteed that the input contains at least one character other than a newline. It is recommended to organize the input-output line by line, in this case the newlines will be processed correctly by the language means. Output Print the text of the spell where all extra characters are deleted. Please note that each output line should be followed by a newline. Please be careful: your answers will be validated by comparing them to the jury's answer byte-by-byte. So, all spaces and newlines matter. Examples Input # include <cstdio> using namespace std; int main ( ){ puts("Hello # World"); # # } Output # include <cstdio> usingnamespacestd;intmain(){puts("Hello#World");# # } Input # # Output # # Note In the first sample the amplifying lines are lines 1 and 7. So, lines 2 to 6 are concatenated to each other, all spaces are deleted from them. In the second sample the amplifying lines are lines 1 and 3. So, no lines are concatenated to each other. 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. Complete the solution so that it takes the object (JavaScript/CoffeeScript) or hash (ruby) passed in and generates a human readable string from its key/value pairs. The format should be "KEY = VALUE". Each key/value pair should be separated by a comma except for the last pair. Example: ```python solution({"a": 1, "b": '2'}) # should return "a = 1,b = 2" ``` Write your solution by modifying this code: ```python def solution(pairs): ``` Your solution should implemented in the function "solution". The i Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. For every string, after every occurrence of `'and'` and `'but'`, insert the substring `'apparently'` directly after the occurrence. If input does not contain 'and' or 'but', return the original string. If a blank string, return `''`. If substring `'apparently'` is already directly after an `'and'` and/or `'but'`, do not add another. (Do not add duplicates). # Examples: Input 1 'It was great and I've never been on live television before but sometimes I don't watch this.' Output 1 'It was great and apparently I've never been on live television before but apparently sometimes I don't watch this.' Input 2 'but apparently' Output 2 'but apparently' (no changes because `'apparently'` is already directly after `'but'` and there should not be a duplicate.) An occurrence of `'and'` and/or `'but'` only counts when it is at least one space separated. For example `'andd'` and `'bbut'` do not count as occurrences, whereas `'b but'` and `'and d'` does count. reference that may help: https://www.youtube.com/watch?v=rz5TGN7eUcM Write your solution by modifying this code: ```python def apparently(string): ``` Your solution should implemented in the function "apparently". The i 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. Curry making As the ACM-ICPC domestic qualifying is approaching, you who wanted to put more effort into practice decided to participate in a competitive programming camp held at a friend's house. Participants decided to prepare their own meals. On the first night of the training camp, the participants finished the day's practice and began preparing dinner. Not only in competitive programming, but also in self-catering, you are often said to be a "professional", and you have spared time because you have finished making the menu for your charge in a blink of an eye. Therefore, I decided to help other people make curry. Now, there is a curry made by mixing R0 [g] roux with W0 [L] water. There is one type of roux used this time, and each roux is R [g]. Ru has a sufficient stockpile. When you use this roux, you think that the curry with a concentration of C [g / L] is the most delicious, so add some roux and water to this curry appropriately to make the concentration C [g / L]. I want to. Here, the concentration of curry in which roux R0 [g] is dissolved in water W0 [L] is R0 / W0 [g / L], and X roux of R [g] and water Y [L] are added to this curry. ] Is added, the concentration becomes (R0 + XR) / (W0 + Y) [g / L]. Although there are a lot of roux, you thought that it was not good to use too much, so you decided to make a curry with a concentration of C [g / L] by reducing the number of roux to be added as much as possible. When making a curry with a concentration of C [g / L] by properly adding either roux, water, or both to a curry with a concentration of R0 / W0 [g / L], the number of roux X to be added Find the minimum value. However, please note the following points regarding the curry making this time. * Number of roux to be added The value of X must be an integer greater than or equal to 0. In other words, it is not possible to add only 1/3 of the roux. * The value of the volume Y of water to be added can be a real number greater than or equal to 0, and does not have to be an integer. * In some cases, it is possible to make curry with a concentration of C without adding either roux, water, or both. * Since a sufficient amount of roux and water is secured, it is good that the situation that the curry with concentration C cannot be made due to lack of roux and water does not occur. Input The input consists of multiple datasets. Each dataset consists of one line and is expressed in the following format. > R0 W0 C R Here, R0, W0, C, and R are the mass of roux already dissolved in the curry that is being made [g], the volume of water contained in the curry [L], and the concentration of the curry you want to make [g / L]. , Represents the mass [g] per roux. All of these values are integers between 1 and 100. The end of the input is indicated by a line of four zeros separated by blanks. Output For each dataset, one line is the minimum number of roux that needs to be added to make a curry with a concentration of C from a fake curry that is a mixture of W0 [L] water and R0 [g] roux. To output. Do not output the amount of water to add. Note that due to input constraints, the minimum number of roux that is the answer for each dataset is guaranteed to be within the range represented by a 32-bit signed integer. Sample Input 10 5 3 4 2 5 2 3 91 13 7 62 10 1 3 5 20 100 2 20 2 14 7 1 0 0 0 0 Output for Sample Input 2 3 0 0 9 96 Example Input 10 5 3 4 2 5 2 3 91 13 7 62 10 1 3 5 20 100 2 20 2 14 7 1 0 0 0 0 Output 2 3 0 0 9 96 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 remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal. The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal. Determine if it is possible for the islanders to arrange the statues in the desired order. Input The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands. The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct. The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct. Output Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise. Examples Input 3 1 0 2 2 0 1 Output YES Input 2 1 0 0 1 Output YES Input 4 1 2 3 0 0 3 2 1 Output NO Note In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3. In the second sample, the islanders can simply move statue 1 from island 1 to island 2. In the third sample, no sequence of movements results in the desired position. 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 set of n points in 5-dimensional space. The points are labeled from 1 to n. No two points coincide. We will call point a bad if there are different points b and c, not equal to a, from the given set such that angle between vectors $\vec{ab}$ and $\vec{ac}$ is acute (i.e. strictly less than $90^{\circ}$). Otherwise, the point is called good. The angle between vectors $\vec{x}$ and $\vec{y}$ in 5-dimensional space is defined as $\operatorname{arccos}(\frac{\vec{x} \cdot \vec{y}}{\|\vec{x}\|\|\vec{y}\|})$, where $\vec{x} \cdot \vec{y} = x_{1} y_{1} + x_{2} y_{2} + x_{3} y_{3} + x_{4} y_{4} + x_{5} y_{5}$ is the scalar product and $\|\vec{x}\|= \sqrt{\vec{x} \cdot \vec{x}}$ is length of $\vec{x}$. Given the list of points, print the indices of the good points in ascending order. -----Input----- The first line of input contains a single integer n (1 ≤ n ≤ 10^3) — the number of points. The next n lines of input contain five integers a_{i}, b_{i}, c_{i}, d_{i}, e_{i} (\|a_{i}\|, \|b_{i}\|, \|c_{i}\|, \|d_{i}\|, \|e_{i}\| ≤ 10^3) — the coordinates of the i-th point. All points are distinct. -----Output----- First, print a single integer k — the number of good points. Then, print k integers, each on their own line — the indices of the good points in ascending order. -----Examples----- Input 6 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 Output 1 1 Input 3 0 0 1 2 0 0 0 9 2 0 0 0 5 9 0 Output 0 -----Note----- In the first sample, the first point forms exactly a $90^{\circ}$ angle with all other pairs of points, so it is good. In the second sample, along the cd plane, we can see the points look as follows: [Image] We can see that all angles here are acute, so no points are good. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Task Dudka has `n` details. He must keep exactly 3 of them. To do this, he performs the following operations until he has only 3 details left: ``` He numbers them. He keeps those with either odd or even numbers and throws the others away.``` Dudka wants to know how many ways there are to get exactly 3 details. Your task is to help him calculate it. # Example For `n = 6`, the output should be `2`. ``` Dudka has 6 details, numbered 1 2 3 4 5 6. He can keep either details with numbers 1, 3, 5, or with numbers 2, 4, 6. Both options leave him with 3 details, so the answer is 2.``` For `n = 7`, the output should be `1`. ``` Dudka has 7 details, numbered 1 2 3 4 5 6 7. He can keep either details 1 3 5 7, or details 2 4 6. If he keeps details 1 3 5 7 , he won't be able to get 3 details in the future, because at the next step he will number them 1 2 3 4 and will have to keep either details 1 3, or 2 4, only two details anyway. That's why he must keep details 2 4 6 at the first step, so the answer is 1.``` # Input/Output - `[input]` integer `n` `3 ≤ n ≤ 10^9` - `[output]` an integer The number of ways to get exactly 3 details. Write your solution by modifying this code: ```python def three_details(n): ``` Your solution should implemented in the function "three_details". The i 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. Nick is interested in prime numbers. Once he read about Goldbach problem. It states that every even integer greater than 2 can be expressed as the sum of two primes. That got Nick's attention and he decided to invent a problem of his own and call it Noldbach problem. Since Nick is interested only in prime numbers, Noldbach problem states that at least k prime numbers from 2 to n inclusively can be expressed as the sum of three integer numbers: two neighboring prime numbers and 1. For example, 19 = 7 + 11 + 1, or 13 = 5 + 7 + 1. Two prime numbers are called neighboring if there are no other prime numbers between them. You are to help Nick, and find out if he is right or wrong. Input The first line of the input contains two integers n (2 ≤ n ≤ 1000) and k (0 ≤ k ≤ 1000). Output Output YES if at least k prime numbers from 2 to n inclusively can be expressed as it was described above. Otherwise output NO. Examples Input 27 2 Output YES Input 45 7 Output NO Note In the first sample the answer is YES since at least two numbers can be expressed as it was described (for example, 13 and 19). In the second sample the answer is NO since it is impossible to express 7 prime numbers from 2 to 45 in the desired form. 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 sum of two permutations p and q of numbers 0, 1, ..., (n - 1) as permutation <image>, where Perm(x) is the x-th lexicographically permutation of numbers 0, 1, ..., (n - 1) (counting from zero), and Ord(p) is the number of permutation p in the lexicographical order. For example, Perm(0) = (0, 1, ..., n - 2, n - 1), Perm(n! - 1) = (n - 1, n - 2, ..., 1, 0) Misha has two permutations, p and q. Your task is to find their sum. Permutation a = (a0, a1, ..., an - 1) is called to be lexicographically smaller than permutation b = (b0, b1, ..., bn - 1), if for some k following conditions hold: a0 = b0, a1 = b1, ..., ak - 1 = bk - 1, ak < bk. Input The first line contains an integer n (1 ≤ n ≤ 200 000). The second line contains n distinct integers from 0 to n - 1, separated by a space, forming permutation p. The third line contains n distinct integers from 0 to n - 1, separated by spaces, forming permutation q. Output Print n distinct integers from 0 to n - 1, forming the sum of the given permutations. Separate the numbers by spaces. Examples Input 2 0 1 0 1 Output 0 1 Input 2 0 1 1 0 Output 1 0 Input 3 1 2 0 2 1 0 Output 1 0 2 Note Permutations of numbers from 0 to 1 in the lexicographical order: (0, 1), (1, 0). In the first sample Ord(p) = 0 and Ord(q) = 0, so the answer is <image>. In the second sample Ord(p) = 0 and Ord(q) = 1, so the answer is <image>. Permutations of numbers from 0 to 2 in the lexicographical order: (0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0). In the third sample Ord(p) = 3 and Ord(q) = 5, so the answer is <image>. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya came up with his own weather forecasting method. He knows the information about the average air temperature for each of the last n days. Assume that the average air temperature for each day is integral. Vasya believes that if the average temperatures over the last n days form an arithmetic progression, where the first term equals to the average temperature on the first day, the second term equals to the average temperature on the second day and so on, then the average temperature of the next (n + 1)-th day will be equal to the next term of the arithmetic progression. Otherwise, according to Vasya's method, the temperature of the (n + 1)-th day will be equal to the temperature of the n-th day. Your task is to help Vasya predict the average temperature for tomorrow, i. e. for the (n + 1)-th day. -----Input----- The first line contains a single integer n (2 ≤ n ≤ 100) — the number of days for which the average air temperature is known. The second line contains a sequence of integers t_1, t_2, ..., t_{n} ( - 1000 ≤ t_{i} ≤ 1000) — where t_{i} is the average temperature in the i-th day. -----Output----- Print the average air temperature in the (n + 1)-th day, which Vasya predicts according to his method. Note that the absolute value of the predicted temperature can exceed 1000. -----Examples----- Input 5 10 5 0 -5 -10 Output -15 Input 4 1 1 1 1 Output 1 Input 3 5 1 -5 Output -5 Input 2 900 1000 Output 1100 -----Note----- In the first example the sequence of the average temperatures is an arithmetic progression where the first term is 10 and each following terms decreases by 5. So the predicted average temperature for the sixth day is - 10 - 5 = - 15. In the second example the sequence of the average temperatures is an arithmetic progression where the first term is 1 and each following terms equals to the previous one. So the predicted average temperature in the fifth day is 1. In the third example the average temperatures do not form an arithmetic progression, so the average temperature of the fourth day equals to the temperature of the third day and equals to - 5. In the fourth example the sequence of the average temperatures is an arithmetic progression where the first term is 900 and each the following terms increase by 100. So predicted average temperature in the third day is 1000 + 100 = 1100. 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 X and Little Z are good friends. They always chat online. But both of them have schedules. Little Z has fixed schedule. He always online at any moment of time between a_1 and b_1, between a_2 and b_2, ..., between a_{p} and b_{p} (all borders inclusive). But the schedule of Little X is quite strange, it depends on the time when he gets up. If he gets up at time 0, he will be online at any moment of time between c_1 and d_1, between c_2 and d_2, ..., between c_{q} and d_{q} (all borders inclusive). But if he gets up at time t, these segments will be shifted by t. They become [c_{i} + t, d_{i} + t] (for all i). If at a moment of time, both Little X and Little Z are online simultaneosly, they can chat online happily. You know that Little X can get up at an integer moment of time between l and r (both borders inclusive). Also you know that Little X wants to get up at the moment of time, that is suitable for chatting with Little Z (they must have at least one common moment of time in schedules). How many integer moments of time from the segment [l, r] suit for that? -----Input----- The first line contains four space-separated integers p, q, l, r (1 ≤ p, q ≤ 50; 0 ≤ l ≤ r ≤ 1000). Each of the next p lines contains two space-separated integers a_{i}, b_{i} (0 ≤ a_{i} < b_{i} ≤ 1000). Each of the next q lines contains two space-separated integers c_{j}, d_{j} (0 ≤ c_{j} < d_{j} ≤ 1000). It's guaranteed that b_{i} < a_{i} + 1 and d_{j} < c_{j} + 1 for all valid i and j. -----Output----- Output a single integer — the number of moments of time from the segment [l, r] which suit for online conversation. -----Examples----- Input 1 1 0 4 2 3 0 1 Output 3 Input 2 3 0 20 15 17 23 26 1 4 7 11 15 17 Output 20 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given three strings $s$, $t$ and $p$ consisting of lowercase Latin letters. You may perform any number (possibly, zero) operations on these strings. During each operation you choose any character from $p$, erase it from $p$ and insert it into string $s$ (you may insert this character anywhere you want: in the beginning of $s$, in the end or between any two consecutive characters). For example, if $p$ is aba, and $s$ is de, then the following outcomes are possible (the character we erase from $p$ and insert into $s$ is highlighted): aba $\rightarrow$ ba, de $\rightarrow$ ade; aba $\rightarrow$ ba, de $\rightarrow$ dae; aba $\rightarrow$ ba, de $\rightarrow$ dea; aba $\rightarrow$ aa, de $\rightarrow$ bde; aba $\rightarrow$ aa, de $\rightarrow$ dbe; aba $\rightarrow$ aa, de $\rightarrow$ deb; aba $\rightarrow$ ab, de $\rightarrow$ ade; aba $\rightarrow$ ab, de $\rightarrow$ dae; aba $\rightarrow$ ab, de $\rightarrow$ dea; Your goal is to perform several (maybe zero) operations so that $s$ becomes equal to $t$. Please determine whether it is possible. Note that you have to answer $q$ independent queries. -----Input----- The first line contains one integer $q$ ($1 \le q \le 100$) — the number of queries. Each query is represented by three consecutive lines. The first line of each query contains the string $s$ ($1 \le \|s\| \le 100$) consisting of lowercase Latin letters. The second line of each query contains the string $t$ ($1 \le \|t\| \le 100$) consisting of lowercase Latin letters. The third line of each query contains the string $p$ ($1 \le \|p\| \le 100$) consisting of lowercase Latin letters. -----Output----- For each query print YES if it is possible to make $s$ equal to $t$, and NO otherwise. You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer). -----Example----- Input 4 ab acxb cax a aaaa aaabbcc a aaaa aabbcc ab baaa aaaaa Output YES YES NO NO -----Note----- In the first test case there is the following sequence of operation: $s = $ ab, $t = $ acxb, $p = $ cax; $s = $ acb, $t = $ acxb, $p = $ ax; $s = $ acxb, $t = $ acxb, $p = $ a. In the second test case there is the following sequence of operation: $s = $ a, $t = $ aaaa, $p = $ aaabbcc; $s = $ aa, $t = $ aaaa, $p = $ aabbcc; $s = $ aaa, $t = $ aaaa, $p = $ abbcc; $s = $ aaaa, $t = $ aaaa, $p = $ bbcc. 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. Alice got a new doll these days. It can even walk! Alice has built a maze for the doll and wants to test it. The maze is a grid with n rows and m columns. There are k obstacles, the i-th of them is on the cell (x_i, y_i), which means the cell in the intersection of the x_i-th row and the y_i-th column. However, the doll is clumsy in some ways. It can only walk straight or turn right at most once in the same cell (including the start cell). It cannot get into a cell with an obstacle or get out of the maze. More formally, there exist 4 directions, in which the doll can look: 1. The doll looks in the direction along the row from the first cell to the last. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x, y + 1); 2. The doll looks in the direction along the column from the first cell to the last. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x + 1, y); 3. The doll looks in the direction along the row from the last cell to first. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x, y - 1); 4. The doll looks in the direction along the column from the last cell to the first. While moving looking in this direction the doll will move from the cell (x, y) into the cell (x - 1, y). . Standing in some cell the doll can move into the cell in the direction it looks or it can turn right once. Turning right once, the doll switches it's direction by the following rules: 1 → 2, 2 → 3, 3 → 4, 4 → 1. Standing in one cell, the doll can make at most one turn right. Now Alice is controlling the doll's moves. She puts the doll in of the cell (1, 1) (the upper-left cell of the maze). Initially, the doll looks to the direction 1, so along the row from the first cell to the last. She wants to let the doll walk across all the cells without obstacles exactly once and end in any place. Can it be achieved? Input The first line contains three integers n, m and k, separated by spaces (1 ≤ n,m ≤ 10^5, 0 ≤ k ≤ 10^5) — the size of the maze and the number of obstacles. Next k lines describes the obstacles, the i-th line contains two integer numbers x_i and y_i, separated by spaces (1 ≤ x_i ≤ n,1 ≤ y_i ≤ m), which describes the position of the i-th obstacle. It is guaranteed that no two obstacles are in the same cell and no obstacle is in cell (1, 1). Output Print 'Yes' (without quotes) if the doll can walk across all the cells without obstacles exactly once by the rules, described in the statement. If it is impossible to walk across the maze by these rules print 'No' (without quotes). Examples Input 3 3 2 2 2 2 1 Output Yes Input 3 3 2 3 1 2 2 Output No Input 3 3 8 1 2 1 3 2 1 2 2 2 3 3 1 3 2 3 3 Output Yes Note Here is the picture of maze described in the first example: <image> In the first example, the doll can walk in this way: * The doll is in the cell (1, 1), looks to the direction 1. Move straight; * The doll is in the cell (1, 2), looks to the direction 1. Move straight; * The doll is in the cell (1, 3), looks to the direction 1. Turn right; * The doll is in the cell (1, 3), looks to the direction 2. Move straight; * The doll is in the cell (2, 3), looks to the direction 2. Move straight; * The doll is in the cell (3, 3), looks to the direction 2. Turn right; * The doll is in the cell (3, 3), looks to the direction 3. Move straight; * The doll is in the cell (3, 2), looks to the direction 3. Move straight; * The doll is in the cell (3, 1), looks to the direction 3. The goal is achieved, all cells of the maze without obstacles passed exactly once. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vova plans to go to the conference by train. Initially, the train is at the point $1$ and the destination point of the path is the point $L$. The speed of the train is $1$ length unit per minute (i.e. at the first minute the train is at the point $1$, at the second minute — at the point $2$ and so on). There are lanterns on the path. They are placed at the points with coordinates divisible by $v$ (i.e. the first lantern is at the point $v$, the second is at the point $2v$ and so on). There is also exactly one standing train which occupies all the points from $l$ to $r$ inclusive. Vova can see the lantern at the point $p$ if $p$ is divisible by $v$ and there is no standing train at this position ($p \not\in [l; r]$). Thus, if the point with the lantern is one of the points covered by the standing train, Vova can't see this lantern. Your problem is to say the number of lanterns Vova will see during the path. Vova plans to go to $t$ different conferences, so you should answer $t$ independent queries. -----Input----- The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of queries. Then $t$ lines follow. The $i$-th line contains four integers $L_i, v_i, l_i, r_i$ ($1 \le L, v \le 10^9$, $1 \le l \le r \le L$) — destination point of the $i$-th path, the period of the lantern appearance and the segment occupied by the standing train. -----Output----- Print $t$ lines. The $i$-th line should contain one integer — the answer for the $i$-th query. -----Example----- Input 4 10 2 3 7 100 51 51 51 1234 1 100 199 1000000000 1 1 1000000000 Output 3 0 1134 0 -----Note----- For the first example query, the answer is $3$. There are lanterns at positions $2$, $4$, $6$, $8$ and $10$, but Vova didn't see the lanterns at positions $4$ and $6$ because of the standing train. For the second example query, the answer is $0$ because the only lantern is at the point $51$ and there is also a standing train at this point. For the third example query, the answer is $1134$ because there are $1234$ lanterns, but Vova didn't see the lanterns from the position $100$ to the position $199$ inclusive. For the fourth example query, the answer is $0$ because the standing train covers the whole path. 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 got lost in a very big desert. The desert can be represented as a n × n square matrix, where each cell is a zone of the desert. The cell (i, j) represents the cell at row i and column j (1 ≤ i, j ≤ n). Iahub can go from one cell (i, j) only down or right, that is to cells (i + 1, j) or (i, j + 1). Also, there are m cells that are occupied by volcanoes, which Iahub cannot enter. Iahub is initially at cell (1, 1) and he needs to travel to cell (n, n). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (n, n). -----Input----- The first line contains two integers n (1 ≤ n ≤ 10^9) and m (1 ≤ m ≤ 10^5). Each of the next m lines contains a pair of integers, x and y (1 ≤ x, y ≤ n), representing the coordinates of the volcanoes. Consider matrix rows are numbered from 1 to n from top to bottom, and matrix columns are numbered from 1 to n from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location. -----Output----- Print one integer, the minimum time in which Iahub can arrive at cell (n, n). If no solution exists (there is no path to the final cell), print -1. -----Examples----- Input 4 2 1 3 1 4 Output 6 Input 7 8 1 6 2 6 3 5 3 6 4 3 5 1 5 2 5 3 Output 12 Input 2 2 1 2 2 1 Output -1 -----Note----- Consider the first sample. A possible road is: (1, 1) → (1, 2) → (2, 2) → (2, 3) → (3, 3) → (3, 4) → (4, 4). Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Write a program to determine if two numbers are coprime. A pair of numbers are coprime if their greatest shared factor is 1. For example: ``` 20 and 27 Factors of 20: 1, 2, 4, 5, 10, 20 Factors of 27: 1, 3, 9, 27 Greatest shared factor: 1 20 and 27 are coprime``` An example of two numbers that are not coprime: ``` 12 and 39 Factors of 12: 1, 2, 3, 4, 6, 12 Factors of 39: 1, 3, 13, 39 Greatest shared factor: 3 12 and 39 are not coprime``` If the two inputs are coprime, your program should return true. If they are not coprime, your program should return false. The inputs will always be two positive integers between 2 and 99. Write your solution by modifying this code: ```python def are_coprime(n, m): ``` Your solution should implemented in the function "are_coprime". The i Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. This Kata is intended as a small challenge for my students All Star Code Challenge #19 You work for an ad agency and your boss, Bob, loves a catchy slogan. He's always jumbling together "buzz" words until he gets one he likes. You're looking to impress Boss Bob with a function that can do his job for him. Create a function called sloganMaker() that accepts an array of string "buzz" words. The function returns an array of all possible UNIQUE string permutations of the buzz words (concatonated and separated by spaces). Your boss is not very bright, so anticipate him using the same "buzz" word more than once, by accident. The function should ignore these duplicate string inputs. ``` sloganMaker(["super", "hot", "guacamole"]); //[ 'super hot guacamole', // 'super guacamole hot', // 'hot super guacamole', // 'hot guacamole super', // 'guacamole super hot', // 'guacamole hot super' ] sloganMaker(["cool", "pizza", "cool"]); // => [ 'cool pizza', 'pizza cool' ] ``` Note: There should be NO duplicate strings in the output array The input array MAY contain duplicate strings, which should STILL result in an output array with all unique strings An empty string is valid input ```if-not:python,crystal The order of the permutations in the output array does not matter ``` ```if:python,crystal The order of the output array must match those rules: 1. Generate the permutations in lexicographic order of the original array. 2. keep only the first occurence of a permutation, when duplicates are found. ``` Write your solution by modifying this code: ```python def slogan_maker(array): ``` Your solution should implemented in the function "slogan_maker". The i 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. Three poles stand evenly spaced along a line. Their heights are a, b and c meters, from left to right. We will call the arrangement of the poles beautiful if the tops of the poles lie on the same line, that is, b-a = c-b. Determine whether the arrangement of the poles is beautiful. -----Constraints----- - 1 \leq a,b,c \leq 100 - a, b and c are integers. -----Input----- Input is given from Standard Input in the following format: a b c -----Output----- Print YES if the arrangement of the poles is beautiful; print NO otherwise. -----Sample Input----- 2 4 6 -----Sample Output----- YES Since 4-2 = 6-4, this arrangement of poles is beautiful. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Task Let's call `product(x)` the product of x's digits. Given an array of integers a, calculate `product(x)` for each x in a, and return the number of distinct results you get. # Example For `a = [2, 8, 121, 42, 222, 23]`, the output should be `3`. Here are the products of the array's elements: ``` 2: product(2) = 2; 8: product(8) = 8; 121: product(121) = 1 * 2 * 1 = 2; 42: product(42) = 4 * 2 = 8; 222: product(222) = 2 * 2 * 2 = 8; 23: product(23) = 2 * 3 = 6.``` As you can see, there are only `3` different products: `2, 6 and 8.` # Input/Output - `[input]` integer array `a` Constraints: `1 ≤ a.length ≤ 10000,` `1 ≤ a[i] ≤ 1000000000.` - `[output]` an integer The number of different digit products in `a`. Write your solution by modifying this code: ```python def unique_digit_products(a): ``` Your solution should implemented in the function "unique_digit_products". The i 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 a lowercase string that has alphabetic characters only and no spaces, return the highest value of consonant substrings. Consonants are any letters of the alphabet except `"aeiou"`. We shall assign the following values: `a = 1, b = 2, c = 3, .... z = 26`. For example, for the word "zodiacs", let's cross out the vowels. We get: "z ~~o~~ d ~~ia~~ cs" For C: do not mutate input. More examples in test cases. Good luck! If you like this Kata, please try: [Word values](https://www.codewars.com/kata/598d91785d4ce3ec4f000018) [Vowel-consonant lexicon](https://www.codewars.com/kata/59cf8bed1a68b75ffb000026) Write your solution by modifying this code: ```python def solve(s): ``` Your solution should implemented in the function "solve". The i Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. You are given two integers $x$ and $y$. You can perform two types of operations: Pay $a$ dollars and increase or decrease any of these integers by $1$. For example, if $x = 0$ and $y = 7$ there are four possible outcomes after this operation: $x = 0$, $y = 6$; $x = 0$, $y = 8$; $x = -1$, $y = 7$; $x = 1$, $y = 7$. Pay $b$ dollars and increase or decrease both integers by $1$. For example, if $x = 0$ and $y = 7$ there are two possible outcomes after this operation: $x = -1$, $y = 6$; $x = 1$, $y = 8$. Your goal is to make both given integers equal zero simultaneously, i.e. $x = y = 0$. There are no other requirements. In particular, it is possible to move from $x=1$, $y=0$ to $x=y=0$. Calculate the minimum amount of dollars you have to spend on it. -----Input----- The first line contains one integer $t$ ($1 \le t \le 100$) — the number of testcases. The first line of each test case contains two integers $x$ and $y$ ($0 \le x, y \le 10^9$). The second line of each test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^9$). -----Output----- For each test case print one integer — the minimum amount of dollars you have to spend. -----Example----- Input 2 1 3 391 555 0 0 9 4 Output 1337 0 -----Note----- In the first test case you can perform the following sequence of operations: first, second, first. This way you spend $391 + 555 + 391 = 1337$ dollars. In the second test case both integers are equal to zero initially, so you dont' have to spend money. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Vasya came up with a password to register for EatForces — a string s. The password in EatForces should be a string, consisting of lowercase and uppercase Latin letters and digits. But since EatForces takes care of the security of its users, user passwords must contain at least one digit, at least one uppercase Latin letter and at least one lowercase Latin letter. For example, the passwords "abaCABA12", "Z7q" and "3R24m" are valid, and the passwords "qwerty", "qwerty12345" and "Password" are not. A substring of string s is a string x = s_l s_{l + 1} ... s_{l + len - 1} (1 ≤ l ≤ \|s\|, 0 ≤ len ≤ \|s\| - l + 1). len is the length of the substring. Note that the empty string is also considered a substring of s, it has the length 0. Vasya's password, however, may come too weak for the security settings of EatForces. He likes his password, so he wants to replace some its substring with another string of the same length in order to satisfy the above conditions. This operation should be performed exactly once, and the chosen string should have the minimal possible length. Note that the length of s should not change after the replacement of the substring, and the string itself should contain only lowercase and uppercase Latin letters and digits. Input The first line contains a single integer T (1 ≤ T ≤ 100) — the number of testcases. Each of the next T lines contains the initial password s~(3 ≤ \|s\| ≤ 100), consisting of lowercase and uppercase Latin letters and digits. Only T = 1 is allowed for hacks. Output For each testcase print a renewed password, which corresponds to given conditions. The length of the replaced substring is calculated as following: write down all the changed positions. If there are none, then the length is 0. Otherwise the length is the difference between the first and the last changed position plus one. For example, the length of the changed substring between the passwords "abcdef" → "a7cdEf" is 4, because the changed positions are 2 and 5, thus (5 - 2) + 1 = 4. It is guaranteed that such a password always exists. If there are several suitable passwords — output any of them. Example Input 2 abcDCE htQw27 Output abcD4E htQw27 Note In the first example Vasya's password lacks a digit, he replaces substring "C" with "4" and gets password "abcD4E". That means, he changed the substring of length 1. In the second example Vasya's password is ok from the beginning, and nothing has to be changed. That is the same as replacing the empty substring with another empty substring (length 0). Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. We start with a string $s$ consisting only of the digits $1$, $2$, or $3$. The length of $s$ is denoted by $\|s\|$. For each $i$ from $1$ to $\|s\|$, the $i$-th character of $s$ is denoted by $s_i$. There is one cursor. The cursor's location $\ell$ is denoted by an integer in $\{0, \ldots, \|s\|\}$, with the following meaning: If $\ell = 0$, then the cursor is located before the first character of $s$. If $\ell = \|s\|$, then the cursor is located right after the last character of $s$. If $0 < \ell < \|s\|$, then the cursor is located between $s_\ell$ and $s_{\ell+1}$. We denote by $s_\text{left}$ the string to the left of the cursor and $s_\text{right}$ the string to the right of the cursor. We also have a string $c$, which we call our clipboard, which starts out as empty. There are three types of actions: The Move action. Move the cursor one step to the right. This increments $\ell$ once. The Cut action. Set $c \leftarrow s_\text{right}$, then set $s \leftarrow s_\text{left}$. The Paste action. Append the value of $c$ to the end of the string $s$. Note that this doesn't modify $c$. The cursor initially starts at $\ell = 0$. Then, we perform the following procedure: Perform the Move action once. Perform the Cut action once. Perform the Paste action $s_\ell$ times. If $\ell = x$, stop. Otherwise, return to step 1. You're given the initial string $s$ and the integer $x$. What is the length of $s$ when the procedure stops? Since this value may be very large, only find it modulo $10^9 + 7$. It is guaranteed that $\ell \le \|s\|$ at any time. -----Input----- The first line of input contains a single integer $t$ ($1 \le t \le 1000$) denoting the number of test cases. The next lines contain descriptions of the test cases. The first line of each test case contains a single integer $x$ ($1 \le x \le 10^6$). The second line of each test case consists of the initial string $s$ ($1 \le \|s\| \le 500$). It is guaranteed, that $s$ consists of the characters "1", "2", "3". It is guaranteed that the sum of $x$ in a single file is at most $10^6$. It is guaranteed that in each test case before the procedure will stop it will be true that $\ell \le \|s\|$ at any time. -----Output----- For each test case, output a single line containing a single integer denoting the answer for that test case modulo $10^9 + 7$. -----Example----- Input 4 5 231 7 2323 6 333 24 133321333 Output 25 1438 1101 686531475 -----Note----- Let's illustrate what happens with the first test case. Initially, we have $s = $ 231. Initially, $\ell = 0$ and $c = \varepsilon$ (the empty string). The following things happen if we follow the procedure above: Step 1, Move once: we get $\ell = 1$. Step 2, Cut once: we get $s = $ 2 and $c = $ 31. Step 3, Paste $s_\ell = $ 2 times: we get $s = $ 23131. Step 4: $\ell = 1 \not= x = 5$, so we return to step 1. Step 1, Move once: we get $\ell = 2$. Step 2, Cut once: we get $s = $ 23 and $c = $ 131. Step 3, Paste $s_\ell = $ 3 times: we get $s = $ 23131131131. Step 4: $\ell = 2 \not= x = 5$, so we return to step 1. Step 1, Move once: we get $\ell = 3$. Step 2, Cut once: we get $s = $ 231 and $c = $ 31131131. Step 3, Paste $s_\ell = $ 1 time: we get $s = $ 23131131131. Step 4: $\ell = 3 \not= x = 5$, so we return to step 1. Step 1, Move once: we get $\ell = 4$. Step 2, Cut once: we get $s = $ 2313 and $c = $ 1131131. Step 3, Paste $s_\ell = $ 3 times: we get $s = $ 2313113113111311311131131. Step 4: $\ell = 4 \not= x = 5$, so we return to step 1. Step 1, Move once: we get $\ell = 5$. Step 2, Cut once: we get $s = $ 23131 and $c = $ 13113111311311131131. Step 3, Paste $s_\ell = $ 1 times: we get $s = $ 2313113113111311311131131. Step 4: $\ell = 5 = x$, so we stop. At the end of the procedure, $s$ has length $25$. 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 regex to validate a 24 hours time string. See examples to figure out what you should check for: Accepted: 01:00 - 1:00 Not accepted: 24:00 You should check for correct length and no spaces. Write your solution by modifying this code: ```python def validate_time(time): ``` Your solution should implemented in the function "validate_time". The i 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 2 numbers is `n` and `k`. You need to find the number of integers between 1 and n (inclusive) that contains exactly `k` non-zero digit. Example1 ` almost_everywhere_zero(100, 1) return 19` by following condition we have 19 numbers that have k = 1 digits( not count zero ) ` [1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100]` Example2 ` almost_everywhere_zero(11, 2) return 1` we have only `11` that has 2 digits(ten not count because zero is not count) ` 11` constrains `1≤n<pow(10,100)` `1≤k≤100` Write your solution by modifying this code: ```python def almost_everywhere_zero(n, k): ``` Your solution should implemented in the function "almost_everywhere_zero". The i 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 write all the positive integer numbers one after another from $1$ without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536... Your task is to print the $k$-th digit of this sequence. -----Input----- The first and only line contains integer $k$ ($1 \le k \le 10^{12}$) — the position to process ($1$-based index). -----Output----- Print the $k$-th digit of the resulting infinite sequence. -----Examples----- Input 7 Output 7 Input 21 Output 5 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. So you've found a meeting room - phew! You arrive there ready to present, and find that someone has taken one or more of the chairs!! You need to find some quick.... check all the other meeting rooms to see if all of the chairs are in use. Your meeting room can take up to 8 chairs. `need` will tell you how many have been taken. You need to find that many. ```if-not:java Find the spare chairs from the array of meeting rooms. Each meeting room array will have the number of occupants as a string. Each occupant is represented by 'X'. The room array will also have an integer telling you how many chairs there are in the room. ``` ```if:java Find the spare chairs from the array of meeting rooms. ~~~java public class Room { public final String occupants; // number of occupants, each occupant is represented by 'X' public final int chairs; // number of chairs in the room } ~~~ ``` You should return an array of integers that shows how many chairs you take from each room in order, up until you have the required amount. ```if-not:java example: [['XXX', 3], ['XXXXX', 6], ['XXXXXX', 9], ['XXX',2]] when you need 4 chairs: ``` ```if:java example: `[Room("XXX", 3), Room("XXXXX", 6), Room("XXXXXX", 9), Room("XXX",2)]` when you need 4 chairs: ``` result -- > `[0, 1, 3]` (no chairs free in room 0, take 1 from room 1, take 3 from room 2. No need to consider room 4 as you have your 4 chairs already. If you need no chairs, return `'Game On'`. If there aren't enough spare chairs available, return `'Not enough!'` More in this series: The Office I - Outed The Office II - Boredeom Score The Office III - Broken Photocopier The Office IV - Find a Meeting Room Write your solution by modifying this code: ```python def meeting(rooms, number): ``` Your solution should implemented in the function "meeting". The i 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. Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they are not under its influence. He has names of n people who possessed the diary in order. You need to tell, for each person, if he/she possessed the diary at some point before or not. Formally, for a name s_{i} in the i-th line, output "YES" (without quotes) if there exists an index j such that s_{i} = s_{j} and j < i, otherwise, output "NO" (without quotes). -----Input----- First line of input contains an integer n (1 ≤ n ≤ 100) — the number of names in the list. Next n lines each contain a string s_{i}, consisting of lowercase English letters. The length of each string is between 1 and 100. -----Output----- Output n lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not. You can print each letter in any case (upper or lower). -----Examples----- Input 6 tom lucius ginny harry ginny harry Output NO NO NO NO YES YES Input 3 a a a Output NO YES YES -----Note----- In test case 1, for i = 5 there exists j = 3 such that s_{i} = s_{j} and j < i, which means that answer for i = 5 is "YES". Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Step up and down Kazuki, commonly known as Kerr, who attends JAG University, was invited by your friend this summer to participate in the ICPC (International Collegiate Potchari Contest). ICPC is a sports contest and requires a high degree of athletic ability. However, Mr. Kerr was always in front of the computer, and he was so lacking in exercise that he was tired even if he moved a little. Therefore, Kerr decided to start an easy-to-start exercise, "stepping up and down," as the first step to achieve good results with ICPC. As the name suggests, stepping up and down is a simple exercise that simply repeats going up and down between the step and the floor. However, in stepping up and down, the effect cannot be obtained unless the feet are raised and lowered correctly. Correct ascent and descent is the movement of the foot that satisfies either of the following two types. * From the state where both feet are on the floor, the left foot and the right foot are raised on the stepping stone, and both feet are on the stepping stone. Either the left foot or the right foot may be raised first. * From the state where both feet are on the platform, the left foot and the right foot are lowered to the floor, and both feet are on the floor. Either the left foot or the right foot may be lowered first. As can be seen from the above, raising and lowering only one leg continuously from the state of being on the floor or stepping stone does not result in correct raising and lowering. In the stepping up / down movement, when any of the above correct up / down movements is satisfied, it is counted as one time, and the larger the count number, the more effective the effect can be obtained. Note that even if you don't go back and forth between the floor and the platform, it counts as one only one way. You want your teammate, Kerr, to be as strong as possible. So you decided to write a program and check if Kerr was skipping the step up and down. Since the information of the foot that Kerr moved by going up and down the platform is given, find the number of times that he went up and down correctly. However, it is assumed that both feet are on the floor before going up and down the platform. Input The input consists of multiple data sets, and the number of data sets contained in one input is 150 or less. The format of each data set is as follows. > $ n $ > $ f_1 $ $ f_2 $ ... $ f_n $ In the first line, the integer $ n $ ($ 1 \ le n \ le 100 $) representing the number of times the foot is moved is given. In the second line, $ f_i $, which is a character string representing the movement of the foot, is given in chronological order by $ n $, separated by spaces. $ f_i $ is one of the following four types of character strings. * "lu": Raise your left foot to the platform. * "ru": Raise your right foot to the platform. * "ld": Lower your left foot to the floor. * "rd": Lower your right foot to the floor. It can be assumed that no action is input that lowers the foot on the floor or raises the foot on the platform. The line where $ n $ is 0 indicates the end of input. Do not process this data. Output For each dataset, output the number of correct steps up and down in one line. Note that if you do not output a line break at the end of each line, or if you output unnecessary characters, it will be judged as an incorrect answer. Sample Input Four lu ru ld rd Four lu ld lu ru 1 lu Ten ru lu ld rd ru rd ru lu lu rd ld 0 Output for Sample Input 2 1 0 Four Example Input 4 lu ru ld rd 4 lu ld lu ru 1 lu 10 ru lu ld rd ru rd ru lu rd ld 0 Output 2 1 0 4 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Professor Tsukuba invented a mysterious jewelry box that can be opened with a special gold key whose shape is very strange. It is composed of gold bars joined at their ends. Each gold bar has the same length and is placed parallel to one of the three orthogonal axes in a three dimensional space, i.e., x-axis, y-axis and z-axis. The locking mechanism of the jewelry box is truly mysterious, but the shape of the key is known. To identify the key of the jewelry box, he gave a way to describe its shape. The description indicates a list of connected paths that completely defines the shape of the key: the gold bars of the key are arranged along the paths and joined at their ends. Except for the first path, each path must start from an end point of a gold bar on a previously defined path. Each path is represented by a sequence of elements, each of which is one of six symbols (+x, -x, +y, -y, +z and -z) or a positive integer. Each symbol indicates the direction from an end point to the other end point of a gold bar along the path. Since each gold bar is parallel to one of the three orthogonal axes, the 6 symbols are enough to indicate the direction. Note that a description of a path has direction but the gold bars themselves have no direction. An end point of a gold bar can have a label, which is a positive integer. The labeled point may be referred to as the beginnings of other paths. In a key description, the first occurrence of a positive integer defines a label of a point and each subsequent occurrence of the same positive integer indicates the beginning of a new path at the point. An example of a key composed of 13 gold bars is depicted in Figure 1. <image> The following sequence of lines 19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +z 2 +y is a description of the key in Figure 1. Note that newlines have the same role as space characters in the description, so that `"19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +z 2 +y"` has the same meaning. The meaning of this description is quite simple. The first integer "19" means the number of the following elements in this description. Each element is one of the 6 symbols or a positive integer. The integer "1" at the head of the second line is a label attached to the starting point of the first path. Without loss of generality, it can be assumed that the starting point of the first path is the origin, i.e., (0,0,0), and that the length of each gold bar is 1. The next element "+x" indicates that the first gold bar is parallel to the x-axis, so that the other end point of the gold bar is at (1,0,0). These two elements "1" and "+x" indicates the first path consisting of only one gold bar. The third element of the second line in the description is the positive integer "1", meaning that the point with the label "1", i.e., the origin (0,0,0) is the beginning of a new path. The following elements "+y", "+z", "3", and "+z" indicate the second path consisting of three gold bars. Note that this "3" is its first occurrence so that the point with coordinates (0,1,1) is labeled "3". The head of the third line "3" indicates the beginning of the third path and so on. Consequently, there are four paths by which the shape of the key in Figure 1 is completely defined. Note that there are various descriptions of the same key since there are various sets of paths that cover the shape of the key. For example, the following sequence of lines 19 1 +x 1 +y +z 3 +y -z +x +y -z -x +z 2 +y 3 +z 2 +z is another description of the key in Figure 1, since the gold bars are placed in the same way. Furthermore, the key may be turned 90-degrees around x-axis, y-axis or z-axis several times and may be moved parallelly. Since any combinations of rotations and parallel moves don't change the shape of the key, a description of a rotated and moved key also represent the same shape of the original key. For example, a sequence 17 +y 1 +y -z +x 1 +z +y +x +z +y -x -y 2 -y 2 +z is a description of a key in Figure 2 that represents the same key as in Figure 1. Indeed, they are congruent under a rotation around x-axis and a parallel move. <image> Your job is to write a program to judge whether or not the given two descriptions define the same key. Note that paths may make a cycle. For example, `"4 +x +y -x -y"` and `"6 1 +x 1 +y +x -y"` are valid descriptions. However, two or more gold bars must not be placed at the same position. For example, key descriptions `"2 +x -x"` and `"7 1 +x 1 +y +x -y -x"` are invalid. Input An input data is a list of pairs of key descriptions followed by a zero that indicates the end of the input. For p pairs of key descriptions, the input is given in the following format. key-description1-a key-description1-b key-description2-a key-description2-b ... key-descriptionp-a key-descriptionp-b 0 Each key description (key-description) has the following format. n` ` e1 ` ` e2 ` ` ... ` ` ek ` ` ... ` ` en The positive integer n indicates the number of the following elements e1, ..., en . They are separated by one or more space characters and/or newlines. Each element ek is one of the six symbols (`+x`, `-x`, `+y`, `-y`, `+z` and `-z`) or a positive integer. You can assume that each label is a positive integer that is less than 51, the number of elements in a single key description is less than 301, and the number of characters in a line is less than 80. You can also assume that the given key descriptions are valid and contain at least one gold bar. Output The number of output lines should be equal to that of pairs of key descriptions given in the input. In each line, you should output one of two words "SAME", when the two key descriptions represent the same key, and "DIFFERENT", when they are different. Note that the letters should be in upper case. Examples Input 19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +z 2 +y 19 1 +x 1 +y +z 3 +y -z +x +y -z -x +z 2 +y 3 +z 2 +z 19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +y 2 +z 18 1 -y 1 +y -z +x 1 +z +y +x +z +y -x -y 2 -y 2 +z 3 +x +y +z 3 +y +z -x 0 Output SAME SAME DIFFERENT Input 19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +z 2 +y 19 1 +x 1 +y +z 3 +y -z +x +y -z -x +z 2 +y 3 +z 2 +z 19 1 +x 1 +y +z 3 +z 3 +y -z +x +y -z -x +z 2 +y 2 +z 18 1 -y 1 +y -z +x 1 +z +y +x +z +y -x -y 2 -y 2 +z 3 +x +y +z 3 +y +z -x 0 Output SAME SAME DIFFERENT 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 star is a figure of the following type: an asterisk character '' in the center of the figure and four rays (to the left, right, top, bottom) of the same positive length. The size of a star is the length of its rays. The size of a star must be a positive number (i.e. rays of length $0$ are not allowed). Let's consider empty cells are denoted by '.', then the following figures are stars: [Image] The leftmost figure is a star of size $1$, the middle figure is a star of size $2$ and the rightmost figure is a star of size $3$. You are given a rectangular grid of size $n \times m$ consisting only of asterisks '' and periods (dots) '.'. Rows are numbered from $1$ to $n$, columns are numbered from $1$ to $m$. Your task is to draw this grid using any number of stars or find out that it is impossible. Stars can intersect, overlap or even coincide with each other. The number of stars in the output can't exceed $n \cdot m$. Each star should be completely inside the grid. You can use stars of same and arbitrary sizes. In this problem, you do not need to minimize the number of stars. Just find any way to draw the given grid with at most $n \cdot m$ stars. -----Input----- The first line of the input contains two integers $n$ and $m$ ($3 \le n, m \le 100$) — the sizes of the given grid. The next $n$ lines contains $m$ characters each, the $i$-th line describes the $i$-th row of the grid. It is guaranteed that grid consists of characters '' and '.' only. -----Output----- If it is impossible to draw the given grid using stars only, print "-1". Otherwise in the first line print one integer $k$ ($0 \le k \le n \cdot m$) — the number of stars needed to draw the given grid. The next $k$ lines should contain three integers each — $x_j$, $y_j$ and $s_j$, where $x_j$ is the row index of the central star character, $y_j$ is the column index of the central star character and $s_j$ is the size of the star. Each star should be completely inside the grid. -----Examples----- Input 6 8 ....... ...... ..*. ...... ....... ........ Output 3 3 4 1 3 5 2 3 5 1 Input 5 5 .... **. . ... ..... Output 3 2 2 1 3 3 1 3 4 1 Input 5 5 .... *.. .... .... ..... Output -1 Input 3 3 .* .. .* Output -1 -----Note----- In the first example the output 2 3 4 1 3 5 2 is also correct. 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 permutation of length $n$. Recall that the permutation is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2, 3, 1, 5, 4]$ is a permutation, but $[1, 2, 2]$ is not a permutation ($2$ appears twice in the array) and $[1, 3, 4]$ is also not a permutation ($n=3$ but there is $4$ in the array). You can perform at most $n-1$ operations with the given permutation (it is possible that you don't perform any operations at all). The $i$-th operation allows you to swap elements of the given permutation on positions $i$ and $i+1$. Each operation can be performed at most once. The operations can be performed in arbitrary order. Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order. You can see the definition of the lexicographical order in the notes section. You have to answer $q$ independent test cases. For example, let's consider the permutation $[5, 4, 1, 3, 2]$. The minimum possible permutation we can obtain is $[1, 5, 2, 4, 3]$ and we can do it in the following way: perform the second operation (swap the second and the third elements) and obtain the permutation $[5, 1, 4, 3, 2]$; perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation $[5, 1, 4, 2, 3]$; perform the third operation (swap the third and the fourth elements) and obtain the permutation $[5, 1, 2, 4, 3]$. perform the first operation (swap the first and the second elements) and obtain the permutation $[1, 5, 2, 4, 3]$; Another example is $[1, 2, 4, 3]$. The minimum possible permutation we can obtain is $[1, 2, 3, 4]$ by performing the third operation (swap the third and the fourth elements). -----Input----- The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of test cases. Then $q$ test cases follow. The first line of the test case contains one integer $n$ ($1 \le n \le 100$) — the number of elements in the permutation. The second line of the test case contains $n$ distinct integers from $1$ to $n$ — the given permutation. -----Output----- For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order. -----Example----- Input 4 5 5 4 1 3 2 4 1 2 4 3 1 1 4 4 3 2 1 Output 1 5 2 4 3 1 2 3 4 1 1 4 3 2 -----Note----- Recall that the permutation $p$ of length $n$ is lexicographically less than the permutation $q$ of length $n$ if there is such index $i \le n$ that for all $j$ from $1$ to $i - 1$ the condition $p_j = q_j$ is satisfied, and $p_i < q_i$. For example: $p = [1, 3, 5, 2, 4]$ is less than $q = [1, 3, 5, 4, 2]$ (such $i=4$ exists, that $p_i < q_i$ and for each $j < i$ holds $p_j = q_j$), $p = [1, 2]$ is less than $q = [2, 1]$ (such $i=1$ exists, that $p_i < q_i$ and for each $j < i$ holds $p_j = q_j$). 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 men and N women, both numbered 1, 2, \ldots, N. For each i, j (1 \leq i, j \leq N), the compatibility of Man i and Woman j is given as an integer a_{i, j}. If a_{i, j} = 1, Man i and Woman j are compatible; if a_{i, j} = 0, they are not. Taro is trying to make N pairs, each consisting of a man and a woman who are compatible. Here, each man and each woman must belong to exactly one pair. Find the number of ways in which Taro can make N pairs, modulo 10^9 + 7. Constraints * All values in input are integers. * 1 \leq N \leq 21 * a_{i, j} is 0 or 1. Input Input is given from Standard Input in the following format: N a_{1, 1} \ldots a_{1, N} : a_{N, 1} \ldots a_{N, N} Output Print the number of ways in which Taro can make N pairs, modulo 10^9 + 7. Examples Input 3 0 1 1 1 0 1 1 1 1 Output 3 Input 4 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 Output 1 Input 1 0 Output 0 Input 21 0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 1 0 0 1 1 1 1 0 0 1 0 0 0 1 0 0 0 0 1 1 1 0 1 1 0 0 0 1 1 1 1 0 1 1 0 0 1 0 0 1 1 0 0 0 1 1 0 1 1 0 1 1 0 1 0 1 0 0 1 0 0 0 0 0 1 1 0 1 1 0 0 1 0 1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 1 1 1 1 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 0 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 1 1 0 0 0 1 0 1 1 0 1 1 0 0 1 1 0 0 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 1 1 0 1 1 0 1 1 1 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0 1 1 0 1 0 1 1 1 1 1 1 1 0 0 0 0 1 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 0 1 1 0 1 0 1 0 0 1 0 0 1 1 0 1 0 1 1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1 1 0 0 1 0 0 0 1 0 0 1 1 0 1 0 1 0 1 1 0 0 1 1 0 1 0 0 0 0 1 1 1 0 1 0 1 1 1 0 1 1 0 0 1 1 0 1 1 0 1 1 0 0 1 1 0 1 1 0 1 1 1 1 1 0 1 0 1 0 0 1 1 0 1 1 1 1 1 0 1 0 1 1 0 0 0 0 0 Output 102515160 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Takahashi is a member of a programming competition site, ButCoder. Each member of ButCoder is assigned two values: Inner Rating and Displayed Rating. The Displayed Rating of a member is equal to their Inner Rating if the member has participated in 10 or more contests. Otherwise, the Displayed Rating will be their Inner Rating minus 100 \times (10 - K) when the member has participated in K contests. Takahashi has participated in N contests, and his Displayed Rating is R. Find his Inner Rating. -----Constraints----- - All values in input are integers. - 1 \leq N \leq 100 - 0 \leq R \leq 4111 -----Input----- Input is given from Standard Input in the following format: N R -----Output----- Print his Inner Rating. -----Sample Input----- 2 2919 -----Sample Output----- 3719 Takahashi has participated in 2 contests, which is less than 10, so his Displayed Rating is his Inner Rating minus 100 \times (10 - 2) = 800. Thus, Takahashi's Inner Rating is 2919 + 800 = 3719. 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 GPA is an abbreviation for "Galaxy Point of Aizu" and takes real numbers from 0 to 4. GPA rock-paper-scissors is a game played by two people. After each player gives a signal of "rock-paper-scissors, pon (hoi)" to each other's favorite move, goo, choki, or par, the person with the higher GPA becomes the winner, and the person with the lower GPA becomes the loser. If they are the same, it will be a draw. Since the GPA data of N people is given, output the points won in each round-robin battle. However, the points won will be 3 when winning, 1 when drawing, and 0 when losing. Round-robin is a system in which all participants play against participants other than themselves exactly once. Constraints The input satisfies the following conditions. * 2 ≤ N ≤ 105 * N is an integer * 0.000 ≤ ai ≤ 4.000 (1 ≤ i ≤ N) * ai is a real number (1 ≤ i ≤ N) * Each GPA is given up to 3 decimal places Input The input is given in the following format. N a1 a2 ... aN The first line is given the number of people N to play GPA rock-paper-scissors. The following N lines are given the data ai of the i-th person's GPA in one line. Output Output the points of the i-th person on the i-line on one line. (1 ≤ i ≤ N) Examples Input 3 1.000 3.000 3.000 Output 0 4 4 Input 3 1.000 2.000 3.000 Output 0 3 6 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. We have an integer sequence A of length N, where A_1 = X, A_{i+1} = A_i + D (1 \leq i < N ) holds. Takahashi will take some (possibly all or none) of the elements in this sequence, and Aoki will take all of the others. Let S and T be the sum of the numbers taken by Takahashi and Aoki, respectively. How many possible values of S - T are there? -----Constraints----- - -10^8 \leq X, D \leq 10^8 - 1 \leq N \leq 2 \times 10^5 - All values in input are integers. -----Input----- Input is given from Standard Input in the following format: N X D -----Output----- Print the number of possible values of S - T. -----Sample Input----- 3 4 2 -----Sample Output----- 8 A is (4, 6, 8). There are eight ways for (Takahashi, Aoki) to take the elements: ((), (4, 6, 8)), ((4), (6, 8)), ((6), (4, 8)), ((8), (4, 6))), ((4, 6), (8))), ((4, 8), (6))), ((6, 8), (4))), and ((4, 6, 8), ()). The values of S - T in these ways are -18, -10, -6, -2, 2, 6, 10, and 18, respectively, so there are eight possible values of S - T. 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 the given string $s$ in the easy version is initially a palindrome, this condition is not always true for the hard version. A palindrome is a string that reads the same left to right and right to left. For example, "101101" is a palindrome, while "0101" is not. Alice and Bob are playing a game on a string $s$ of length $n$ consisting of the characters '0' and '1'. Both players take alternate turns with Alice going first. In each turn, the player can perform one of the following operations: Choose any $i$ ($1 \le i \le n$), where $s[i] =$ '0' and change $s[i]$ to '1'. Pay 1 dollar. Reverse the whole string, pay 0 dollars. This operation is only allowed if the string is currently not a palindrome, and the last operation was not reverse. That is, if Alice reverses the string, then Bob can't reverse in the next move, and vice versa. Reversing a string means reordering its letters from the last to the first. For example, "01001" becomes "10010" after reversing. The game ends when every character of string becomes '1'. The player who spends minimum dollars till this point wins the game and it is a draw if both spend equal dollars. If both players play optimally, output whether Alice wins, Bob wins, or if it is a draw. -----Input----- The first line contains a single integer $t$ ($1 \le t \le 10^3$). Then $t$ test cases follow. The first line of each test case contains a single integer $n$ ($1 \le n \le 10^3$). The second line of each test case contains the string $s$ of length $n$, consisting of the characters '0' and '1'. It is guaranteed that the string $s$ contains at least one '0'. Note that there is no limit on the sum of $n$ over test cases. -----Output----- For each test case print a single word in a new line: "ALICE", if Alice will win the game, "BOB", if Bob will win the game, "DRAW", if the game ends in a draw. -----Examples----- Input 3 3 110 2 00 4 1010 Output ALICE BOB ALICE -----Note----- In the first test case of example, in the $1$-st move, Alice will use the $2$-nd operation to reverse the string, since doing the $1$-st operation will result in her loss anyway. This also forces Bob to use the $1$-st operation. in the $2$-nd move, Bob has to perform the $1$-st operation, since the $2$-nd operation cannot be performed twice in a row. All characters of the string are '1', game over. Alice spends $0$ dollars while Bob spends $1$ dollar. Hence, Alice wins. In the second test case of example, in the $1$-st move Alice has to perform the $1$-st operation, since the string is currently a palindrome. in the $2$-nd move Bob reverses the string. in the $3$-rd move Alice again has to perform the $1$-st operation. All characters of the string are '1', game over. Alice spends $2$ dollars while Bob spends $0$ dollars. Hence, Bob wins. 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. > If you've finished this kata, you can try the [more difficult version](https://www.codewars.com/kata/5b256145a454c8a6990000b5). ## Taking a walk A promenade is a way of uniquely representing a fraction by a succession of “left or right” choices. For example, the promenade `"LRLL"` represents the fraction `4/7`. Each successive choice (`L` or `R`) changes the value of the promenade by combining the values of the promenade before the most recent left choice with the value before the most recent right choice. If the value before the most recent left choice was l/m and the value before the most recent right choice was r/s then the new value will be (l+r) / (m+s). If there has never been a left choice we use l=1 and m=0; if there has never been a right choice we use r=0 and s=1. So let's take a walk. * `""` An empty promenade has never had a left choice nor a right choice. Therefore we use (l=1 and m=0) and (r=0 and s=1). So the value of `""` is (1+0) / (0+1) = 1/1. * `"L"`. Before the most recent left choice we have `""`, which equals 1/1. There still has never been a right choice, so (r=0 and s=1). So the value of `"L"` is (1+0)/(1+1) = 1/2 * `"LR"` = 2/3 as we use the values of `""` (before the left choice) and `"L"` (before the right choice) * `"LRL"` = 3/5 as we use the values of `"LR"` and `"L"` * `"LRLL"` = 4/7 as we use the values of `"LRL"` and `"L"` Fractions are allowed to have a larger than b. ## Your task Implement the `promenade` function, which takes an promenade as input (represented as a string), and returns the corresponding fraction (represented as a tuple, containing the numerator and the denominator). ```Python promenade("") == (1,1) promenade("LR") == (2,3) promenade("LRLL") == (4,7) ``` ```Java Return the Fraction as an int-Array: promenade("") == [1,1] promenade("LR") == [2,3] promenade("LRLL") == [4,7] ``` adapted from the 2016 British Informatics Olympiad Write your solution by modifying this code: ```python def promenade(choices): ``` Your solution should implemented in the function "promenade". The i 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 this exercise, you will have to create a function named tiyFizzBuzz. This function will take on a string parameter and will return that string with some characters replaced, depending on the value: - If a letter is a upper case consonants, replace that character with "Iron". - If a letter is a lower case consonants or a non-alpha character, do nothing to that character - If a letter is a upper case vowel, replace that character with "Iron Yard". - If a letter is a lower case vowel, replace that character with "Yard". Ready? Write your solution by modifying this code: ```python def tiy_fizz_buzz(string): ``` Your solution should implemented in the function "tiy_fizz_buzz". The i 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 string $s=s_1s_2\dots s_n$ of length $n$, which only contains digits $1$, $2$, ..., $9$. A substring $s[l \dots r]$ of $s$ is a string $s_l s_{l + 1} s_{l + 2} \ldots s_r$. A substring $s[l \dots r]$ of $s$ is called even if the number represented by it is even. Find the number of even substrings of $s$. Note, that even if some substrings are equal as strings, but have different $l$ and $r$, they are counted as different substrings. -----Input----- The first line contains an integer $n$ ($1 \le n \le 65000$) — the length of the string $s$. The second line contains a string $s$ of length $n$. The string $s$ consists only of digits $1$, $2$, ..., $9$. -----Output----- Print the number of even substrings of $s$. -----Examples----- Input 4 1234 Output 6 Input 4 2244 Output 10 -----Note----- In the first example, the $[l, r]$ pairs corresponding to even substrings are: $s[1 \dots 2]$ $s[2 \dots 2]$ $s[1 \dots 4]$ $s[2 \dots 4]$ $s[3 \dots 4]$ $s[4 \dots 4]$ In the second example, all $10$ substrings of $s$ are even substrings. Note, that while substrings $s[1 \dots 1]$ and $s[2 \dots 2]$ both define the substring "2", they are still counted as different substrings. 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 Jessie has a lot of recipes with her (N). She often remembered the starting few characters of the recipe and forgot the rest. As all the great chefs do, Jessie also numbered the recipes depending on the priority. So, given the list of recipes along with their priorities answer Jessie’s queries. Jessie’s queries are as follows: She gives you the first few characters of a recipe; you have to print the complete recipe with the highest priority. Note: Every recipe has a unique priority -----Input----- First line contains an integer N - the number of recipes. Followed by N strings Si along with an integer each Vi. Si stands for the recipe and Vi for the priority. It is followed by an integer Q - the number of queries. Followed by Q strings Qi. Each string Si, Qi contain only lowercase Latin alphabets ('a' - 'z') and '-'. -----Output----- Q – lines, each contain the answer for each of the query. If for a query no recipe matches print "NO". (Without quotes) Constraints: 0 <= N <= 1000 0 <= Q <= 1000 -10^9 <= Vi <= 10^9 1 <= \|Si\| <= 1000 (length of Si) 1 <= \|Qi\| <= 1000 (length of Qi) -----Example----- Input: 4 flour-with-eggs 100 chicken-ham -10 flour-without-eggs 200 fish-with-pepper 1100 6 f flour-with flour-with- c fl chik Output: fish-with-pepper flour-without-eggs flour-with-eggs chicken-ham flour-without-eggs NO Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. # Hey You ! Sort these integers for me ... By name ... Do it now ! --- ## Input * Range is ```0```-```999``` * There may be duplicates * The array may be empty ## Example * Input: 1, 2, 3, 4 * Equivalent names: "one", "two", "three", "four" * Sorted by name: "four", "one", "three", "two" * Output: 4, 1, 3, 2 ## Notes * Don't pack words together: * e.g. 99 may be "ninety nine" or "ninety-nine"; but not "ninetynine" * e.g 101 may be "one hundred one" or "one hundred and one"; but not "onehundredone" * Don't fret about formatting rules, because if rules are consistently applied it has no effect anyway: * e.g. "one hundred one", "one hundred two"; is same order as "one hundred and one", "one hundred and two" * e.g. "ninety eight", "ninety nine"; is same order as "ninety-eight", "ninety-nine" ```if:c * For `C` code the input array may be NULL. The return value is freed if non-NULL. ``` Write your solution by modifying this code: ```python def sort_by_name(arr): ``` Your solution should implemented in the function "sort_by_name". The i 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. Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$. What is the minimum number of bills Allen could receive after withdrawing his entire balance? -----Input----- The first and only line of input contains a single integer $n$ ($1 \le n \le 10^9$). -----Output----- Output the minimum number of bills that Allen could receive. -----Examples----- Input 125 Output 3 Input 43 Output 5 Input 1000000000 Output 10000000 -----Note----- In the first sample case, Allen can withdraw this with a $100$ dollar bill, a $20$ dollar bill, and a $5$ dollar bill. There is no way for Allen to receive $125$ dollars in one or two bills. In the second sample case, Allen can withdraw two $20$ dollar bills and three $1$ dollar bills. In the third sample case, Allen can withdraw $100000000$ (ten million!) $100$ dollar bills. 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 studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers a, b, c on the blackboard. The task was to insert signs of operations '+' and '', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets: 1+23=7 1(2+3)=5 123=6 (1+2)3=9 Note that you can insert operation signs only between a and b, and between b and c, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2. It's easy to see that the maximum value that you can obtain is 9. Your task is: given a, b and c print the maximum value that you can get. -----Input----- The input contains three integers a, b and c, each on a single line (1 ≤ a, b, c ≤ 10). -----Output----- Print the maximum value of the expression that you can obtain. -----Examples----- Input 1 2 3 Output 9 Input 2 10 3 Output 60 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. Complete the solution so that it returns the number of times the search_text is found within the full_text. Usage example: Write your solution by modifying this code: ```python def solution(full_text, search_text): ``` Your solution should implemented in the function "solution". The i 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. Manao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different. There are n teams taking part in the national championship. The championship consists of n·(n - 1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number. You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question. -----Input----- The first line contains an integer n (2 ≤ n ≤ 30). Each of the following n lines contains a pair of distinct space-separated integers h_{i}, a_{i} (1 ≤ h_{i}, a_{i} ≤ 100) — the colors of the i-th team's home and guest uniforms, respectively. -----Output----- In a single line print the number of games where the host team is going to play in the guest uniform. -----Examples----- Input 3 1 2 2 4 3 4 Output 1 Input 4 100 42 42 100 5 42 100 5 Output 5 Input 2 1 2 1 2 Output 0 -----Note----- In the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2. In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first). 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. Cirno has a DAG (Directed Acyclic Graph) with $n$ nodes and $m$ edges. The graph has exactly one node that has no out edges. The $i$-th node has an integer $a_i$ on it. Every second the following happens: Let $S$ be the set of nodes $x$ that have $a_x > 0$. For all $x \in S$, $1$ is subtracted from $a_x$, and then for each node $y$, such that there is an edge from $x$ to $y$, $1$ is added to $a_y$. Find the first moment of time when all $a_i$ become $0$. Since the answer can be very large, output it modulo $998\,244\,353$. -----Input----- The first line contains a single integer $t$ ($1 \leq t \leq 1000$) — the number of test cases. Description of test cases follows. The first line of each test case contains two integers $n, m$ ($1 \leq n, m \leq 1000$) — the number of vertices and edges in the graph. The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \leq a_i \leq 10^9$) — the integer on vertices. Each line of the following $m$ lines contains two integers $x, y$ ($1 \leq x, y \leq n$), represent a directed edge from $x$ to $y$. It is guaranteed that the graph is a DAG with no multi-edges, and there is exactly one node that has no out edges. It is guaranteed that both sum of $n$ and sum of $m$ over all test cases are less than or equal to $10000$. -----Output----- For each test case, print an integer in a separate line — the first moment of time when all $a_i$ become $0$, modulo $998\,244\,353$. -----Examples----- Input 5 3 2 1 1 1 1 2 2 3 5 5 1 0 0 0 0 1 2 2 3 3 4 4 5 1 5 10 11 998244353 0 0 0 998244353 0 0 0 0 0 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 1 3 7 9 5 6 1293 1145 9961 9961 1919 1 2 2 3 3 4 5 4 1 4 2 4 6 9 10 10 10 10 10 10 1 2 1 3 2 3 4 3 6 3 3 5 6 5 6 1 6 2 Output 3 5 4 28010 110 -----Note----- In the first test case: At time $0$, the values of the nodes are $[1, 1, 1]$. At time $1$, the values of the nodes are $[0, 1, 1]$. At time $2$, the values of the nodes are $[0, 0, 1]$. At time $3$, the values of the nodes are $[0, 0, 0]$. So the answer is $3$. In the second test case: At time $0$, the values of the nodes are $[1, 0, 0, 0, 0]$. At time $1$, the values of the nodes are $[0, 1, 0, 0, 1]$. At time $2$, the values of the nodes are $[0, 0, 1, 0, 0]$. At time $3$, the values of the nodes are $[0, 0, 0, 1, 0]$. At time $4$, the values of the nodes are $[0, 0, 0, 0, 1]$. At time $5$, the values of the nodes are $[0, 0, 0, 0, 0]$. So the answer is $5$. In the third test case: The first moment of time when all $a_i$ become $0$ is $6\cdot 998244353 + 4$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. AquaMoon has n friends. They stand in a row from left to right, and the i-th friend from the left wears a T-shirt with a number a_i written on it. Each friend has a direction (left or right). In the beginning, the direction of each friend is right. AquaMoon can make some operations on friends. On each operation, AquaMoon can choose two adjacent friends and swap their positions. After each operation, the direction of both chosen friends will also be flipped: left to right and vice versa. AquaMoon hopes that after some operations, the numbers written on the T-shirt of n friends in the row, read from left to right, become non-decreasing. Also she wants, that all friends will have a direction of right at the end. Please find if it is possible. Input The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 50) — the number of test cases. The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of Aquamoon's friends. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the numbers, written on the T-shirts. It is guaranteed that the sum of n for all test cases does not exceed 10^5. Output For each test case, if there exists a possible sequence of operations, print "YES" (without quotes); otherwise, print "NO" (without quotes). You can print each letter in any case (upper or lower). Example Input 3 4 4 3 2 5 4 3 3 2 2 5 1 2 3 5 4 Output YES YES NO Note The possible list of operations in the first test case: 1. Swap a_1 and a_2. The resulting sequence is 3, 4, 2, 5. The directions are: left, left, right, right. 2. Swap a_2 and a_3. The resulting sequence is 3, 2, 4, 5. The directions are: left, left, right, right. 3. Swap a_1 and a_2. The resulting sequence is 2, 3, 4, 5. The directions are: right, right, right, right. 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. Here you have to do some mathematical operations on a "dirty string". This kata checks some basics, it's not too difficult. __So what to do?__ Input: String which consists of two positive numbers (doubles) and exactly one operator like `+, -, * or /` always between these numbers. The string is dirty, which means that there are different characters inside too, not only numbers and the operator. You have to combine all digits left and right, perhaps with "." inside (doubles), and to calculate the result which has to be rounded to an integer and converted to a string at the end. ### Easy example: ``` Input: "gdfgdf234dg54gf23oP42" Output: "54929268" (because 234542342=54929268) ``` First there are some static tests, later on random tests too... ### Hope you have fun! :-) Write your solution by modifying this code: ```python def calculate_string(st): ``` Your solution should implemented in the function "calculate_string". The i 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 are in charge of quality control at a machine manufacturing plant. This machine requires a power supply, a motor, and a cable as parts. The manufacturing plant has a power supply, b motors, and c cables, numbered from 1 to a, a + 1 to a + b, and a + b + 1 to a + b + c, respectively. attached. The trouble is that some parts may be out of order. I want to know which parts are out of order and which parts are normal in the factory. Therefore, the factory inspected the parts by the following method. Bring the power supply, motor, and cable one by one, connect them, and try to operate them. At this time, if all three parts are normal, it operates correctly and is recognized as "passed". If any of the three parts is out of order, it will not operate properly and will be recognized as "failed". (Since the machines made in the factory are so precise, it does not happen that the broken parts are mixed and operate correctly by accident.) You will be given a list of test results. Each line in the list of test results shows the numbers of the power supply, motor, and cable used for the test, and whether the test passed or failed. Given a list of inspection results, all parts are either faulty or normal from the inspection results, some are definitely faulty, some are definitely normal. Create a program to classify parts that are not decided. input The input consists of multiple datasets. The format of each data set is as follows. The input ends on a line containing three zeros. Three integers are written on the first line, separated by blanks, and represent the number of power supplies a, the number of motors b, and the number of cables c in order. One integer is written on the second line, and the number of tests N included in the list of test results is written. The next N lines represent a list of test results. On each line, four integers i, j, k, r are written with one blank as a delimiter, and the result of inspection by connecting the power supply i, the motor j, and the cable k is "pass" (r = 1). (When) or "Fail" (when r = 0). a, b, c, N satisfy 1 ≤ a, b, c ≤ 100, 1 ≤ N ≤ 1000. The number of datasets does not exceed 5. output Output in the following format for each data set. The output of each dataset consists of lines a + b + c. Line i (1 ≤ i ≤ a + b + c): * If the inspection result shows that the part i is out of order, 0 is output. * If the inspection result shows that the part i is normal, 1 is output. * Output 2 if the inspection result does not determine whether part i is defective or normal. Examples Input 2 2 2 4 2 4 5 0 2 3 6 0 1 4 5 0 2 3 5 1 0 0 0 Output 2 1 1 0 1 0 Input None Output None Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. n people are standing on a coordinate axis in points with positive integer coordinates strictly less than 10^6. For each person we know in which direction (left or right) he is facing, and his maximum speed. You can put a bomb in some point with non-negative integer coordinate, and blow it up. At this moment all people will start running with their maximum speed in the direction they are facing. Also, two strange rays will start propagating from the bomb with speed s: one to the right, and one to the left. Of course, the speed s is strictly greater than people's maximum speed. The rays are strange because if at any moment the position and the direction of movement of some ray and some person coincide, then the speed of the person immediately increases by the speed of the ray. You need to place the bomb is such a point that the minimum time moment in which there is a person that has run through point 0, and there is a person that has run through point 10^6, is as small as possible. In other words, find the minimum time moment t such that there is a point you can place the bomb to so that at time moment t some person has run through 0, and some person has run through point 10^6. -----Input----- The first line contains two integers n and s (2 ≤ n ≤ 10^5, 2 ≤ s ≤ 10^6) — the number of people and the rays' speed. The next n lines contain the description of people. The i-th of these lines contains three integers x_{i}, v_{i} and t_{i} (0 < x_{i} < 10^6, 1 ≤ v_{i} < s, 1 ≤ t_{i} ≤ 2) — the coordinate of the i-th person on the line, his maximum speed and the direction he will run to (1 is to the left, i.e. in the direction of coordinate decrease, 2 is to the right, i.e. in the direction of coordinate increase), respectively. It is guaranteed that the points 0 and 10^6 will be reached independently of the bomb's position. -----Output----- Print the minimum time needed for both points 0 and 10^6 to be reached. Your answer is considered correct if its absolute or relative error doesn't exceed 10^{ - 6}. Namely, if your answer is a, and the jury's answer is b, then your answer is accepted, if $\frac{\|a - b\|}{\operatorname{max}(1,\|b\|)} \leq 10^{-6}$. -----Examples----- Input 2 999 400000 1 2 500000 1 1 Output 500000.000000000000000000000000000000 Input 2 1000 400000 500 1 600000 500 2 Output 400.000000000000000000000000000000 -----Note----- In the first example, it is optimal to place the bomb at a point with a coordinate of 400000. Then at time 0, the speed of the first person becomes 1000 and he reaches the point 10^6 at the time 600. The bomb will not affect on the second person, and he will reach the 0 point at the time 500000. In the second example, it is optimal to place the bomb at the point 500000. The rays will catch up with both people at the time 200. At this time moment, the first is at the point with a coordinate of 300000, and the second is at the point with a coordinate of 700000. Their speed will become 1500 and at the time 400 they will simultaneously run through points 0 and 10^6. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Read problems statements in Mandarin and Russian. Translations in Vietnamese to be uploaded soon. You have a matrix of size N * N with rows numbered through 1 to N from top to bottom and columns through 1 to N from left to right. It contains all values from 1 to N^{2}, i.e. each value from 1 to N^{2} occurs exactly once in the matrix. Now, you start from the cell containing value 1, and from there visit the cell with value 2, and then from there visit the cell with value 3, and so on till you have visited cell containing the number N^{2}. In a single step, you can move from a cell to one of its adjacent cells. Two cells are said to be adjacent to each other if they share an edge between them. Find out minimum number of steps required. For example, if matrix is 1 3 2 4 You start from cell containing value 1 (i.e. (1,1)) and you want to visit cell with value 2 (i.e. (2,1)). Now, from cell (2,1) you have to visit cell (1,2), which can be done is 2 steps (First we go from (2, 1) to (1, 1) and then to (1, 2), total 2 steps). Finally you move to cell where value 4 is present in 1 step. So, total number of steps required is 4. ------ Input ------ The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows. The first line of each test case contains a single integer N denoting the size of matrix. Each of the next N lines contain N integers denoting the values in the rows of the matrix. ------ Output ------ For each test case, output in a single line the required answer. ------ Constraints ------ $1 ≤ T ≤ 5$ $1 ≤ N ≤ 500$ ------ Subtasks ------ $ Subtask 1 (30 points) : 1 ≤ N ≤ 20$ $ Subtask 2 (70 points) : Original constraints$ ----- Sample Input 1 ------ 2 2 1 3 2 4 3 1 7 9 2 4 8 3 6 5 ----- Sample Output 1 ------ 4 12 ----- explanation 1 ------ Example case 1. Explained in the statement. Example case 2. This is the sequence of cells visited: (1,1) to (2,1) to (3,1) to (2,2) to (3,3) to (3,2) to (1,2) to (2,3) to (1,3). Warning: Large input files, use scanf instead of cin in C/C++. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. This is the easy version of the problem. The difference is the constraints on $n$, $m$ and $t$. You can make hacks only if all versions of the problem are solved. Alice and Bob are given the numbers $n$, $m$ and $k$, and play a game as follows: The game has a score that Alice tries to maximize, and Bob tries to minimize. The score is initially $0$. The game consists of $n$ turns. Each turn, Alice picks a real number from $0$ to $k$ (inclusive) which Bob either adds to or subtracts from the score of the game. But throughout the game, Bob has to choose to add at least $m$ out of the $n$ turns. Bob gets to know which number Alice picked before deciding whether to add or subtract the number from the score, and Alice gets to know whether Bob added or subtracted the number for the previous turn before picking the number for the current turn (except on the first turn since there was no previous turn). If Alice and Bob play optimally, what will the final score of the game be? -----Input----- The first line of the input contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases. The description of test cases follows. Each test case consists of a single line containing the three integers, $n$, $m$, and $k$ ($1 \le m \le n \le 2000, 0 \le k < 10^9 + 7$) — the number of turns, how many of those turns Bob has to add, and the biggest number Alice can choose, respectively. It is guaranteed that the sum of $n$ over all test cases does not exceed $2000$. -----Output----- For each test case output a single integer number — the score of the optimal game modulo $10^9 + 7$. Formally, let $M = 10^9 + 7$. It can be shown that the answer can be expressed as an irreducible fraction $\frac{p}{q}$, where $p$ and $q$ are integers and $q \not \equiv 0 \pmod{M}$. Output the integer equal to $p \cdot q^{-1} mod M$. In other words, output such an integer $x$ that $0 \le x < M$ and $x \cdot q \equiv p \pmod{M}$. -----Examples----- Input 7 3 3 2 2 1 10 6 3 10 6 4 10 100 1 1 4 4 0 69 4 20 Output 6 5 375000012 500000026 958557139 0 49735962 -----Note----- In the first test case, the entire game has $3$ turns, and since $m = 3$, Bob has to add in each of them. Therefore Alice should pick the biggest number she can, which is $k = 2$, every turn. In the third test case, Alice has a strategy to guarantee a score of $\frac{75}{8} \equiv 375000012 \pmod{10^9 + 7}$. In the fourth test case, Alice has a strategy to guarantee a score of $\frac{45}{2} \equiv 500000026 \pmod{10^9 + 7}$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Given is a string S consisting of digits from 1 through 9. Find the number of pairs of integers (i,j) (1 ≤ i ≤ j ≤ \|S\|) that satisfy the following condition: Condition: In base ten, the i-th through j-th characters of S form an integer that is a multiple of 2019. -----Constraints----- - 1 ≤ \|S\| ≤ 200000 - S is a string consisting of digits from 1 through 9. -----Input----- Input is given from Standard Input in the following format: S -----Output----- Print the number of pairs of integers (i,j) (1 ≤ i ≤ j ≤ \|S\|) that satisfy the condition. -----Sample Input----- 1817181712114 -----Sample Output----- 3 Three pairs - (1,5), (5,9), and (9,13) - satisfy the condition. 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. Ashish has two strings $a$ and $b$, each of length $n$, and an integer $k$. The strings only contain lowercase English letters. He wants to convert string $a$ into string $b$ by performing some (possibly zero) operations on $a$. In one move, he can either choose an index $i$ ($1 \leq i\leq n-1$) and swap $a_i$ and $a_{i+1}$, or choose an index $i$ ($1 \leq i \leq n-k+1$) and if $a_i, a_{i+1}, \ldots, a_{i+k-1}$ are all equal to some character $c$ ($c \neq$ 'z'), replace each one with the next character $(c+1)$, that is, 'a' is replaced by 'b', 'b' is replaced by 'c' and so on. Note that he can perform any number of operations, and the operations can only be performed on string $a$. Help Ashish determine if it is possible to convert string $a$ into $b$ after performing some (possibly zero) operations on it. -----Input----- The first line contains a single integer $t$ ($1 \leq t \leq 10^5$) — the number of test cases. The description of each test case is as follows. The first line of each test case contains two integers $n$ ($2 \leq n \leq 10^6$) and $k$ ($1 \leq k \leq n$). The second line of each test case contains the string $a$ of length $n$ consisting of lowercase English letters. The third line of each test case contains the string $b$ of length $n$ consisting of lowercase English letters. It is guaranteed that the sum of values $n$ among all test cases does not exceed $10^6$. -----Output----- For each test case, print "Yes" if Ashish can convert $a$ into $b$ after some moves, else print "No". You may print the letters of the answer in any case (upper or lower). -----Examples----- Input 4 3 3 abc bcd 4 2 abba azza 2 1 zz aa 6 2 aaabba ddddcc Output No Yes No Yes -----Note----- In the first test case it can be shown that it is impossible to convert $a$ into $b$. In the second test case, "abba" $\xrightarrow{\text{inc}}$ "acca" $\xrightarrow{\text{inc}}$ $\ldots$ $\xrightarrow{\text{inc}}$ "azza". Here "swap" denotes an operation of the first type, and "inc" denotes an operation of the second type. In the fourth test case, "aaabba" $\xrightarrow{\text{swap}}$ "aaabab" $\xrightarrow{\text{swap}}$ "aaaabb" $\xrightarrow{\text{inc}}$ $\ldots$ $\xrightarrow{\text{inc}}$ "ddaabb" $\xrightarrow{\text{inc}}$ $\ldots$ $\xrightarrow{\text{inc}}$ "ddddbb" $\xrightarrow{\text{inc}}$ $\ldots$ $\xrightarrow{\text{inc}}$ "ddddcc". 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 Soccer is popular in JOI, and a league match called the JOI League is held every week. There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher. As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically. Team 1 \| Team 2 \| Team 3 \| Team 4 \| Wins \| Loss \| Draws \| Points --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- \| --- Team 1 \| --- \| 0 --1 \| 2 --1 \| 2 --2 \| 1 \| 1 \| 1 \| 4 Team 2 \| 1 --0 \| --- \| 1 --1 \| 3 --0 \| 2 \| 0 \| 1 \| 7 Team 3 \| 1 --2 \| 1 --1 \| --- \| 1 --3 \| 0 \| 2 \| 1 \| 1 Team 4 \| 2 --2 \| 0 --3 \| 3 --1 \| --- \| 1 \| 1 \| 1 \| 4 At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place. Create a program to find the ranking of each team given the results of all matches. input The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written. output The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i. Input / output example Input example 1 Four 1 2 0 1 1 3 2 1 1 4 2 2 2 3 1 1 2 4 3 0 3 4 1 3 Output example 1 2 1 Four 2 Input / output example 1 corresponds to the example in the problem statement. Input example 2 Five 1 2 1 1 3 4 3 1 5 1 1 2 2 3 0 0 4 5 2 3 1 3 0 2 5 2 2 2 4 1 4 5 3 5 4 0 2 4 0 1 Output example 2 2 Four 1 Four 3 The results of input / output example 2 are as follows. \| Wins \| Loss \| Draws \| Points --- \| --- \| --- \| --- \| --- Team 1 \| 2 \| 1 \| 1 \| 7 Team 2 \| 0 \| 1 \| 3 \| 3 Team 3 \| 3 \| 0 \| 1 \| 10 Team 4 \| 1 \| 3 \| 0 \| 3 Team 5 \| 1 \| 2 \| 1 \| 4 The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics. Example Input 4 1 2 0 1 1 3 2 1 1 4 2 2 2 3 1 1 2 4 3 0 3 4 1 3 Output 2 1 4 2 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements. Right now he has a map of some imaginary city with $n$ subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once. One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them. Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations $u$ and $v$ that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station $w$ that the original map has a tunnel between $u$ and $w$ and a tunnel between $w$ and $v$. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map. -----Input----- The first line of the input contains a single integer $n$ ($2 \leq n \leq 200\,000$) — the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following $n - 1$ lines contains two integers $u_i$ and $v_i$ ($1 \leq u_i, v_i \leq n$, $u_i \ne v_i$), meaning the station with these indices are connected with a direct tunnel. It is guaranteed that these $n$ stations and $n - 1$ tunnels form a tree. -----Output----- Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map. -----Examples----- Input 4 1 2 1 3 1 4 Output 6 Input 4 1 2 2 3 3 4 Output 7 -----Note----- In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is $6$. In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair $(1, 4)$. For these two stations the distance is $2$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The Cereal Guy's friend Serial Guy likes to watch soap operas. An episode is about to start, and he hasn't washed his plate yet. But he decided to at least put in under the tap to be filled with water. The plate can be represented by a parallelepiped k × n × m, that is, it has k layers (the first layer is the upper one), each of which is a rectangle n × m with empty squares ('.') and obstacles ('#'). The water can only be present in the empty squares. The tap is positioned above the square (x, y) of the first layer, it is guaranteed that this square is empty. Every minute a cubical unit of water falls into the plate. Find out in how many minutes the Serial Guy should unglue himself from the soap opera and turn the water off for it not to overfill the plate. That is, you should find the moment of time when the plate is absolutely full and is going to be overfilled in the next moment. Note: the water fills all the area within reach (see sample 4). Water flows in each of the 6 directions, through faces of 1 × 1 × 1 cubes. Input The first line contains three numbers k, n, m (1 ≤ k, n, m ≤ 10) which are the sizes of the plate. Then follow k rectangles consisting of n lines each containing m characters '.' or '#', which represents the "layers" of the plate in the order from the top to the bottom. The rectangles are separated by empty lines (see the samples). The last line contains x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) which are the tap's coordinates. x is the number of the line and y is the number of the column. Lines of each layer are numbered from left to right by the integers from 1 to n, columns of each layer are numbered from top to bottom by the integers from 1 to m. Output The answer should contain a single number, showing in how many minutes the plate will be filled. Examples Input 1 1 1 . 1 1 Output 1 Input 2 1 1 . # 1 1 Output 1 Input 2 2 2 .# ## .. .. 1 1 Output 5 Input 3 2 2 #. ## #. .# .. .. 1 2 Output 7 Input 3 3 3 .#. ### ##. .## ### ##. ... ... ... 1 1 Output 13 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$, consisting of $n$ integers, find: $$\max\limits_{1 \le i < j \le n} LCM(a_i,a_j),$$ where $LCM(x, y)$ is the smallest positive integer that is divisible by both $x$ and $y$. For example, $LCM(6, 8) = 24$, $LCM(4, 12) = 12$, $LCM(2, 3) = 6$. -----Input----- The first line contains an integer $n$ ($2 \le n \le 10^5$) — the number of elements in the array $a$. The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^5$) — the elements of the array $a$. -----Output----- Print one integer, the maximum value of the least common multiple of two elements in the array $a$. -----Examples----- Input 3 13 35 77 Output 1001 Input 6 1 2 4 8 16 32 Output 32 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 multiset $S$ initially consisting of $n$ distinct non-negative integers. A multiset is a set, that can contain some elements multiple times. You will perform the following operation $k$ times: Add the element $\lceil\frac{a+b}{2}\rceil$ (rounded up) into $S$, where $a = \operatorname{mex}(S)$ and $b = \max(S)$. If this number is already in the set, it is added again. Here $\operatorname{max}$ of a multiset denotes the maximum integer in the multiset, and $\operatorname{mex}$ of a multiset denotes the smallest non-negative integer that is not present in the multiset. For example: $\operatorname{mex}(\{1,4,0,2\})=3$; $\operatorname{mex}(\{2,5,1\})=0$. Your task is to calculate the number of distinct elements in $S$ after $k$ operations will be done. -----Input----- The input consists of multiple test cases. The first line contains a single integer $t$ ($1\le t\le 100$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $n$, $k$ ($1\le n\le 10^5$, $0\le k\le 10^9$) — the initial size of the multiset $S$ and how many operations you need to perform. The second line of each test case contains $n$ distinct integers $a_1,a_2,\dots,a_n$ ($0\le a_i\le 10^9$) — the numbers in the initial multiset. It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$. -----Output----- For each test case, print the number of distinct elements in $S$ after $k$ operations will be done. -----Examples----- Input 5 4 1 0 1 3 4 3 1 0 1 4 3 0 0 1 4 3 2 0 1 2 3 2 1 2 3 Output 4 4 3 5 3 -----Note----- In the first test case, $S={0,1,3,4\}$, $a=\operatorname{mex}(S)=2$, $b=\max(S)=4$, $\lceil\frac{a+b}{2}\rceil=3$. So $3$ is added into $S$, and $S$ becomes $\{0,1,3,3,4\}$. The answer is $4$. In the second test case, $S={0,1,4\}$, $a=\operatorname{mex}(S)=2$, $b=\max(S)=4$, $\lceil\frac{a+b}{2}\rceil=3$. So $3$ is added into $S$, and $S$ becomes $\{0,1,3,4\}$. The answer is $4$. Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There are H rows and W columns of white square cells. You will choose h of the rows and w of the columns, and paint all of the cells contained in those rows or columns. How many white cells will remain? It can be proved that this count does not depend on what rows and columns are chosen. -----Constraints----- - All values in input are integers. - 1 \leq H, W \leq 20 - 1 \leq h \leq H - 1 \leq w \leq W -----Input----- Input is given from Standard Input in the following format: H W h w -----Output----- Print the number of white cells that will remain. -----Sample Input----- 3 2 2 1 -----Sample Output----- 1 There are 3 rows and 2 columns of cells. When two rows and one column are chosen and painted in black, there is always one white cell that remains. 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've purchased a ready-meal from the supermarket. The packaging says that you should microwave it for 4 minutes and 20 seconds, based on a 600W microwave. Oh no, your microwave is 800W! How long should you cook this for?! ___ # Input You'll be given 4 arguments: ## 1. needed power The power of the needed microwave. Example: `"600W"` ## 2. minutes The number of minutes shown on the package. Example: `4` ## 3. seconds The number of seconds shown on the package. Example: `20` ## 4. power The power of your microwave. Example: `"800W"` ___ # Output The amount of time you should cook the meal for formatted as a string. Example: `"3 minutes 15 seconds"` Note: the result should be rounded up. ``` 59.2 sec --> 60 sec --> return "1 minute 0 seconds" ``` ___ ## All comments/feedback/translations appreciated. Write your solution by modifying this code: ```python def cooking_time(needed_power, minutes, seconds, power): ``` Your solution should implemented in the function "cooking_time". The i 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 main street of Berland is a straight line with n houses built along it (n is an even number). The houses are located at both sides of the street. The houses with odd numbers are at one side of the street and are numbered from 1 to n - 1 in the order from the beginning of the street to the end (in the picture: from left to right). The houses with even numbers are at the other side of the street and are numbered from 2 to n in the order from the end of the street to its beginning (in the picture: from right to left). The corresponding houses with even and odd numbers are strictly opposite each other, that is, house 1 is opposite house n, house 3 is opposite house n - 2, house 5 is opposite house n - 4 and so on. [Image] Vasya needs to get to house number a as quickly as possible. He starts driving from the beginning of the street and drives his car to house a. To get from the beginning of the street to houses number 1 and n, he spends exactly 1 second. He also spends exactly one second to drive the distance between two neighbouring houses. Vasya can park at any side of the road, so the distance between the beginning of the street at the houses that stand opposite one another should be considered the same. Your task is: find the minimum time Vasya needs to reach house a. -----Input----- The first line of the input contains two integers, n and a (1 ≤ a ≤ n ≤ 100 000) — the number of houses on the street and the number of the house that Vasya needs to reach, correspondingly. It is guaranteed that number n is even. -----Output----- Print a single integer — the minimum time Vasya needs to get from the beginning of the street to house a. -----Examples----- Input 4 2 Output 2 Input 8 5 Output 3 -----Note----- In the first sample there are only four houses on the street, two houses at each side. House 2 will be the last at Vasya's right. The second sample corresponds to picture with n = 8. House 5 is the one before last at Vasya's left. 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 permutation of length n is an array containing each integer from 1 to n exactly once. For example, q = [4, 5, 1, 2, 3] is a permutation. For the permutation q the square of permutation is the permutation p that p[i] = q[q[i]] for each i = 1... n. For example, the square of q = [4, 5, 1, 2, 3] is p = q^2 = [2, 3, 4, 5, 1]. This problem is about the inverse operation: given the permutation p you task is to find such permutation q that q^2 = p. If there are several such q find any of them. -----Input----- The first line contains integer n (1 ≤ n ≤ 10^6) — the number of elements in permutation p. The second line contains n distinct integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) — the elements of permutation p. -----Output----- If there is no permutation q such that q^2 = p print the number "-1". If the answer exists print it. The only line should contain n different integers q_{i} (1 ≤ q_{i} ≤ n) — the elements of the permutation q. If there are several solutions print any of them. -----Examples----- Input 4 2 1 4 3 Output 3 4 2 1 Input 4 2 1 3 4 Output -1 Input 5 2 3 4 5 1 Output 4 5 1 2 3 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. Anya has bought a new smartphone that uses Berdroid operating system. The smartphone menu has exactly n applications, each application has its own icon. The icons are located on different screens, one screen contains k icons. The icons from the first to the k-th one are located on the first screen, from the (k + 1)-th to the 2k-th ones are on the second screen and so on (the last screen may be partially empty). Initially the smartphone menu is showing the screen number 1. To launch the application with the icon located on the screen t, Anya needs to make the following gestures: first she scrolls to the required screen number t, by making t - 1 gestures (if the icon is on the screen t), and then make another gesture — press the icon of the required application exactly once to launch it. After the application is launched, the menu returns to the first screen. That is, to launch the next application you need to scroll through the menu again starting from the screen number 1. All applications are numbered from 1 to n. We know a certain order in which the icons of the applications are located in the menu at the beginning, but it changes as long as you use the operating system. Berdroid is intelligent system, so it changes the order of the icons by moving the more frequently used icons to the beginning of the list. Formally, right after an application is launched, Berdroid swaps the application icon and the icon of a preceding application (that is, the icon of an application on the position that is smaller by one in the order of menu). The preceding icon may possibly be located on the adjacent screen. The only exception is when the icon of the launched application already occupies the first place, in this case the icon arrangement doesn't change. Anya has planned the order in which she will launch applications. How many gestures should Anya make to launch the applications in the planned order? Note that one application may be launched multiple times. -----Input----- The first line of the input contains three numbers n, m, k (1 ≤ n, m, k ≤ 10^5) — the number of applications that Anya has on her smartphone, the number of applications that will be launched and the number of icons that are located on the same screen. The next line contains n integers, permutation a_1, a_2, ..., a_{n} — the initial order of icons from left to right in the menu (from the first to the last one), a_{i} — is the id of the application, whose icon goes i-th in the menu. Each integer from 1 to n occurs exactly once among a_{i}. The third line contains m integers b_1, b_2, ..., b_{m}(1 ≤ b_{i} ≤ n) — the ids of the launched applications in the planned order. One application may be launched multiple times. -----Output----- Print a single number — the number of gestures that Anya needs to make to launch all the applications in the desired order. -----Examples----- Input 8 3 3 1 2 3 4 5 6 7 8 7 8 1 Output 7 Input 5 4 2 3 1 5 2 4 4 4 4 4 Output 8 -----Note----- In the first test the initial configuration looks like (123)(456)(78), that is, the first screen contains icons of applications 1, 2, 3, the second screen contains icons 4, 5, 6, the third screen contains icons 7, 8. After application 7 is launched, we get the new arrangement of the icons — (123)(457)(68). To launch it Anya makes 3 gestures. After application 8 is launched, we get configuration (123)(457)(86). To launch it Anya makes 3 gestures. After application 1 is launched, the arrangement of icons in the menu doesn't change. To launch it Anya makes 1 gesture. In total, Anya makes 7 gestures. 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. Example Input 4 3 1000 1 2000 2 3000 3 Output 2 3 4 4 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. There is a data which provides heights (in meter) of mountains. The data is only for ten mountains. Write a program which prints heights of the top three mountains in descending order. Constraints 0 ≤ height of mountain (integer) ≤ 10,000 Input Height of mountain 1 Height of mountain 2 Height of mountain 3 . . Height of mountain 10 Output Height of the 1st mountain Height of the 2nd mountain Height of the 3rd mountain Examples Input 1819 2003 876 2840 1723 1673 3776 2848 1592 922 Output 3776 2848 2840 Input 100 200 300 400 500 600 700 800 900 900 Output 900 900 800 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. Remove the parentheses = In this kata you are given a string for example: ```python "example(unwanted thing)example" ``` Your task is to remove everything inside the parentheses as well as the parentheses themselves. The example above would return: ```python "exampleexample" ``` Other than parentheses only letters and spaces can occur in the string. Don't worry about other brackets like ```"[]"``` and ```"{}"``` as these will never appear. Write your solution by modifying this code: ```python def remove_parentheses(s): ``` Your solution should implemented in the function "remove_parentheses". The i 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 a string s, write a method (function) that will return true if its a valid single integer or floating number or false if its not. Valid examples, should return true: should return false: Write your solution by modifying this code: ```python def isDigit(string): ``` Your solution should implemented in the function "isDigit". The i 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. ATMs of a well-known bank of a small country are arranged so that they can not give any amount of money requested by the user. Due to the limited size of the bill dispenser (the device that is directly giving money from an ATM) and some peculiarities of the ATM structure, you can get at most k bills from it, and the bills may be of at most two distinct denominations. For example, if a country uses bills with denominations 10, 50, 100, 500, 1000 and 5000 burles, then at k = 20 such ATM can give sums 100 000 burles and 96 000 burles, but it cannot give sums 99 000 and 101 000 burles. Let's suppose that the country uses bills of n distinct denominations, and the ATM that you are using has an unlimited number of bills of each type. You know that during the day you will need to withdraw a certain amount of cash q times. You know that when the ATM has multiple ways to give money, it chooses the one which requires the minimum number of bills, or displays an error message if it cannot be done. Determine the result of each of the q of requests for cash withdrawal. -----Input----- The first line contains two integers n, k (1 ≤ n ≤ 5000, 1 ≤ k ≤ 20). The next line contains n space-separated integers a_{i} (1 ≤ a_{i} ≤ 10^7) — the denominations of the bills that are used in the country. Numbers a_{i} follow in the strictly increasing order. The next line contains integer q (1 ≤ q ≤ 20) — the number of requests for cash withdrawal that you will make. The next q lines contain numbers x_{i} (1 ≤ x_{i} ≤ 2·10^8) — the sums of money in burles that you are going to withdraw from the ATM. -----Output----- For each request for cash withdrawal print on a single line the minimum number of bills it can be done, or print - 1, if it is impossible to get the corresponding sum. -----Examples----- Input 6 20 10 50 100 500 1000 5000 8 4200 100000 95000 96000 99000 10100 2015 9950 Output 6 20 19 20 -1 3 -1 -1 Input 5 2 1 2 3 5 8 8 1 3 5 7 9 11 13 15 Output 1 1 1 2 2 2 2 -1 Read the inputs from stdin solve the problem and write the answer to stdout (do not directly test on the sample inputs). Enclose your code within ```python delimiters.
Solve the programming task below in a Python markdown code block. The aim of this Kata is to write a function which will reverse the case of all consecutive duplicate letters in a string. That is, any letters that occur one after the other and are identical. If the duplicate letters are lowercase then they must be set to uppercase, and if they are uppercase then they need to be changed to lowercase. Examples: ```python reverse_case("puzzles") Expected Result: "puZZles" reverse_case("massive") Expected Result: "maSSive" reverse_case("LITTLE") Expected Result: "LIttLE" reverse_case("shhh") Expected Result: "sHHH" ``` Arguments passed will include only alphabetical letters A–Z or a–z. Write your solution by modifying this code: ```python def reverse(s): ``` Your solution should implemented in the function "reverse". The i 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 simple parser that will parse and run Deadfish. Deadfish has 4 commands, each 1 character long: * `i` increments the value (initially `0`) * `d` decrements the value * `s` squares the value * `o` outputs the value into the return array Invalid characters should be ignored. ```python parse("iiisdoso") ==> [8, 64] ``` Write your solution by modifying this code: ```python def parse(data): ``` Your solution should implemented in the function "parse". The i 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.