ACM练习题编号 题目内容Z1 A + B Problem

Calculate a + b InputThe input will consist of a series of pairs of integers a and b,separated by a space, one pair of integers per line. OutputFor each pair of input integers a and b you should output the sum of a and b in one line,and with one line of output for each line in input.Sample Input1 5Sample Output6

Z2 Crashing BalloonOn every June 1st, the Children's Day, there will be a game named "crashing balloon" on TV.   The rule is very simple.  On the

ground there are 100 labeled balloons, with the numbers 1 to 100.  After the referee shouts "Let's go!" the two players, who each starts with a score of  "1", race to crash the balloons by their feet and, at the same time, multiply their scores by the numbers written on the balloons they crash.  After a minute, the little audiences are allowed to take the remaining balloons away, and each contestant reports his\her score, the product of the numbers on the balloons he\she's crashed.  The unofficial winner is the player who announced the highest score.

Inevitably, though, disputes arise, and so the official winner is not determined until the disputes are resolved.  The player who claims the lower score is entitled to challenge his\her opponent's score.  The player with the lower score is presumed to have told the truth, because if he\she were to lie about his\her score, he\she would surely come up with a bigger better lie.  The challenge is upheld if the player with the higher score has a score that cannot be achieved with balloons not crashed by the challenging player.  So, if the challenge is successful, the player claiming the lower score wins.

So, for example, if one player claims 343 points and the other claims 49, then clearly the first player is lying; the only way to score 343 is by crashing balloons labeled 7 and 49, and the only way to score 49 is by crashing a balloon labeled 49.  Since each of two

1

scores requires crashing the balloon labeled 49, the one claiming 343 points is presumed to be lying. On the other hand, if one player claims 162 points and the other claims 81, it is possible for both to be telling the truth (e.g. one

crashes balloons 2, 3 and 27, while the other crashes balloon 81), so the challenge would not be upheld. By the way, if the challenger made a mistake on calculating his/her score, then the challenge would not be upheld. For example, if

one player claims 10001 points and the other claims 10003, then clearly none of them are telling the truth. In this case, the challenge would not be upheld. Unfortunately, anyone who is willing to referee a game of crashing balloon is likely to get over-excited in the hot atmosphere that he\she could not reasonably be expected to perform the intricate calculations that refereeing requires. Hence the need for you, sober programmer, to provide a software solution. InputPairs of unequal, positive numbers, with each pair on a single line, that are claimed scores from a game of crashing balloon. OutputNumbers, one to a line, that are the winning scores, assuming that the player with the lower score always challenges the outcome. Sample Input343 493599 61062 36Sample Output4961062

3 ParencodingsLet S = s1 s2 … s2n be a well-formed string of parentheses. S can be encoded in two different ways: By an integer sequence P = p1 p2 … pn where pi is the number of left parentheses before the ith right parenthesis in S (P-

sequence). By an integer sequence W = w1 w2 … wn where for each right parenthesis, say a in S, we associate an integer which is the

number of right parentheses counting from the matched left parenthesis of a up to a. (W-sequence). Following is an example of the above encodings:S (((()()())))P-sequence 4 5 6666

2

W-sequence 1 1 1456Write a program to convert P-sequence of a well-formed string to the W-sequence of the same string.Input The first line of the input contains a single integer t (1 <= t <= 10), the number of test cases, followed by the input data for each test case. The first line of each test case is an integer n (1 <= n <= 20), and the second line is the P-sequence of a well-formed string. It contains n positive integers, separated with blanks, representing the P-sequence.Output The output consists of exactly t lines corresponding to test cases. For each test case, the output line should contain n integers describing the W-sequence of the string corresponding to its given P-sequence.Sample Input264 5 6 6 6 694 6 6 6 6 8 9 9 9Sample Output1 1 1 4 5 61 1 2 4 5 1 1 3 9

4 Currency ExchangeWhen Issac Bernand Miller takes a trip to another country, say to France, he exchanges his US dollars for French francs. The

exchange rate is a real number such that when multiplied by the number of dollars gives the number of francs. For example, if the exchange rate for US dollars to French francs is 4.81724, then 10 dollars is exchanged for 48.1724 francs. Of course, you can only get hundredth of a franc, so the actual amount you get is rounded to the nearest hundredth. (We'll round .005 up to .01.) All exchanges of money between any two countries are rounded to the nearest hundredth.

Sometimes Issac's trips take him to many countries and he exchanges money from one foreign country for that of another. When he finally arrives back home, he exchanges his money back for US dollars. This has got Issac thinking about how much if his unspent US dollars is lost (or gained!) to these exchange rartes. You'll compute how much money Issac ends up with if he exchanges it many times. You'll always start with US dollars and you'll always end with US dollars.Input

The first 5 lines of input will be the exchange rates between 5 countries, numbered 1 through 5. Line i will five the exchange rate

3

from country i to each of the 5 countries. Thus the jth entry of line i will give the exchange rate from the currency of country i to the currency of country j. the exchange rate form country i to itself will always be 1 and country 1 will be the US. Each of the next lines will indicate a trip and be of the formN c1 c2 … cn m

Where 1 <= n <= 10 and c1, …, cn are integers from 2 through 5 indicating the order in which Issac visits the countries. (A value of n = 0 indicates end of input, in which case there will be no more numbers on the line.) So, his trip will be 1 -> c1 -> c2 -> … -> cn -> 1. the real number m will be the amount of US dollars at the start of the trip.Output

Each trip will generate one line of output giving the amount of US dollars upon his return home from the trip. The amount should be fiven to the nearest cent, and should be displayed in the usual form with cents given to the right of the decimal point, as shown in the sample output. If the amount is less than one dollar, the output should have a zero in the dollars place.This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.The output format consists of N output blocks. There is a blank line between output blocks.Sample Input11 1.57556 1.10521 0.691426 7.250050.634602 1 0.701196 0.43856 4.598470.904750 1.42647 1 0.625627 6.559571.44616 2.28059 1.59840 1 10.48430.137931 0.217555 0.152449 0.0953772 13 2 4 5 20.001 3 100.006 2 3 4 2 4 3 120.030Sample Output19.9899.99120.01

4

5 To the MaxProblem

Given a two-dimensional array of positive and negative integers, a sub-rectangle is any contiguous sub-array of size 1 x 1 or greater located within the whole array. The sum of a rectangle is the sum of all the elements in that rectangle. In this problem the sub-rectangle with the largest sum is referred to as the maximal sub-rectangle.

As an example, the maximal sub-rectangle of the array:0 -2 -7 09 2 -6 2-4 1 -4 1-1 8 0 -2is in the lower left corner:9 2-4 1-1 8and has a sum of 15.

The input consists of an N x N array of integers. The input begins with a single positive integer N on a line by itself, indicating the size of the square two-dimensional array. This is followed by N 2 integers separated by whitespace (spaces and newlines). These are the N 2 integers of the array, presented in row-major order. That is, all numbers in the first row, left to right, then all numbers in the second row, left to right, etc. N may be as large as 100. The numbers in the array will be in the range [-127,127].OutputOutput the sum of the maximal sub-rectangle.ExampleInput40 -2 -7 0 9 2 -6 2-4 1 -4 1 -18 0 -2Output15

6 Palindrom Numbers

5

Statement of the Problem We say that a number is a palindrom if it is the sane when read from left to right or from right to left. For example, the number

75457 is a palindrom.Of course, the property depends on the basis in which is number is represented. The number 17 is not a palindrom in base 10, but its representation in base 2 (10001) is a palindrom.The objective of this problem is to verify if a set of given numbers are palindroms in any basis from 2 to 16.Input Format

Several integer numbers comprise the input. Each number 0 < n < 50000 is given in decimal basis in a separate line. The input ends with a zero.Output Format

Your program must print the message Number i is palindrom in basis where I is the given number, followed by the basis where the representation of the number is a palindrom. If the number is not a palindrom in any basis between 2 and 16, your program must print the message Number i is not palindrom.Sample Input17190Sample OutputNumber 17 is palindrom in basis 2 4 16Number 19 is not a palindrom

7 Monkey and BananaA group of researchers are designing an experiment to test the IQ of a monkey. They will hang a banana at the roof of a building,

and at the mean time, provide the monkey with some blocks. If the monkey is clever enough, it shall be able to reach the banana by placing one block on the top another to build a tower and climb up to get its favorite food.

The researchers have n types of blocks, and an unlimited supply of blocks of each type. Each type-i block was a rectangular solid with linear dimensions (xi, yi, zi). A block could be reoriented so that any two of its three dimensions determined the dimensions of the base and the other dimension was the height. They want to make sure that the tallest tower possible by stacking blocks can reach the roof. The problem is that, in building a tower, one block could only be placed on top of another block as long as the two base dimensions of the upper block were both strictly smaller than the corresponding base dimensions of the lower block because there has to be some space for the monkey to step on.

6

This meant, for example, that blocks oriented to have equal-sized bases couldn't be stacked. Your job is to write a program that determines the height of the tallest tower the monkey can build with a given set of blocks.

Input SpecificationThe input file will contain one or more test cases. The first line of each test case contains an integer n,representing the number of different blocks in the following data set. The maximum value for n is 30.Each of the next n lines contains three integers representing the values xi, yi and zi.Input is terminated by a value of zero (0) for n. Output SpecificationFor each test case, print one line containing the case number (they are numbered sequentially starting from 1) and the height of the tallest possible tower in the format "Case case: maximum height = height" Sample Input110 20 3026 8 105 5 571 1 12 2 23 3 34 4 45 5 56 6 67 7 7531 41 5926 53 5897 93 2384 62 6433 83 27

7

0Sample OutputCase 1: maximum height = 40Case 2: maximum height = 21Case 3: maximum height = 28Case 4: maximum height = 342

8 ShipsProbably everyone who ever attended school knows the game where two opposing players place a set of ships on a sheet of paper

and try to eliminate each other's ships by guessing their location. In our version of the game, your opponent has distributed the following seven ship patterns over a rectangular grid of squares: xx xx xx x x x xx xx xx xxx xxx xxx xxxx

Each ship pattern covers exactly four squares. The patterns may be rotated but not mirrored. All patterns are guaranteed to be placed completely within the boundaries of the rectangle and not to overlap each other, whereas touching another pattern or the border is allowed.

We assume that we are in the middle of the game and that several squares have already been uncovered. You will be given a rectangular grid of squares representing your current knowledge about the positions of your enemy's ships. Every square is marked by one of the following characters: `x' if a ship covers the square`o' if no ship covers the square`.' if the square has not yet been uncovered

Given that information, you are to decide whether you can determine all remaining `x' squares with at most one miss, i.e. whether you could uncover the `.' squares without getting more than one `o' square before you had all `x' squares uncovered. This means you are allowed to hit a `o' if then the solution becomes unique.

InputThe input contains several game situations. Every test case starts with a line containing two integers h and w. These define width

and height of the game rectangle, where 2 <= w, h <= 16. Each of the next h lines contains a string of w characters. Each of these characters is either `x', `o' or `.', depending on the state of the corresponding square.

8

A blank line separates each game from the next. The input ends with a game having w = 0 and h = 0. This game should not be processed. Output

For each test case you should first output a line containing the number of the game, followed by a line containing either `yes.' (if you can determine all `x' with at most one miss) or `no.' (if you cannot determine all `x' without at least two misses). Output a blank line after every game. Sample Input10 10.x..x.....oooooxoooooxooxxx...xxoooooo..xoooxooo..ooxxxxoo..oooooxxooxooooooxooxooooooooxxoooooooooo0 0Sample OutputGame #1yes.

9 PacketsA factory produces products packed in square packets of the same height h and of the sizes 1x1, 2x2, 3x3, 4x4, 5x5, 6x6. These

products are always delivered to customers in the square parcels of the same height h as the products have and of the size 6x6. Because of the expenses it is the interest of the factory as well as of the customer to minimize the number of parcels necessary to deliver the ordered products from the factory to the customer. A good program solving the problem of finding the minimal number of parcels necessary to deliver the given products according to an order would save a lot of money. You are asked to make such a program. Input

9

The input consists of several lines specifying orders. Each line specifies one order. Orders are described by six integers separated by one space representing successively the number of packets of individual size from the smallest size to the biggest size . The end of the input is indicated by the line containing six zeros. Output

The output contains one line for each line in the input. This line contains the minimal number of parcels into which the order from the corresponding line of the input file can be packed. There is no line in the output corresponding to the last ``null'' line of the input. Sample Input0 0 4 0 0 17 5 1 0 0 00 0 0 0 0 0Sample Output21

10 NetworkA Telephone Line Company (TLC) is establishing a new telephone cable network. They are connecting several places numbered

by integers from 1 to N. No two places have the same number. The lines are bidirectional and always connect together two places and in each place the lines end in a telephone exchange. There is one telephone exchange in each place. From each place it is possible to reach through lines every other place, however it need not be a direct connection, it can go through several exchanges. From time to time the power supply fails at a place and then the exchange does not operate. The officials from TLC realized that in such a case it can happen that besides the fact that the place with the failure is unreachable, this can also cause that some other places cannot connect to each other. In such a case we will say the place (where the failure occured) is critical. Now the officials are trying to write a program for finding the number of all such critical places. Help them. Input

The input consists of several blocks of lines. Each block describes one network. In the first line of each block there is the number of places N < 100. Each of the next at most N lines contains the number of a place followed by the numbers of some places to which there is a direct line from this place. These at most N lines completely describe the network, i.e., each direct connection of two places in the network is contained at least in one row. All numbers in one line are separated by one space. Each block ends with a line containing just 0. The last block has only one line with N = 0. OutputThe output contains for each block except the last in the input one line containing the number of critical places.

10

Sample Input55 1 2 3 4062 1 35 4 6 200Sample Output12

11 Uniform GeneratorComputer simulations often require random numbers. One way to generate pseudo-random numbers is via a function of the form

seed(x+1) = [seed(x) + STEP] % MODwhere '%' is the modulus operator. Such a function will generate pseudo-random numbers (seed) between 0 and MOD-1. One problem with functions of this form is

that they will always generate the same pattern over and over. In order to minimize this effect, selecting the STEP and MOD values carefully can result in a uniform distribution of all values between (and including) 0 and MOD-1.

For example, if STEP = 3 and MOD = 5, the function will generate the series of pseudo-random numbers 0, 3, 1, 4, 2 in a repeating cycle. In this example, all of the numbers between and including 0 and MOD-1 will be generated every MOD iterations of the function. Note that by the nature of the function to generate the same seed(x+1) every time seed(x) occurs means that if a function will generate all the numbers between 0 and MOD-1, it will generate pseudo-random numbers uniformly with every MOD iterations.

If STEP = 15 and MOD = 20, the function generates the series 0, 15, 10, 5 (or any other repeating series if the initial seed is other than 0). This is a poor selection of STEP and MOD because no initial seed will generate all of the numbers from 0 and MOD-1.

Your program will determine if choices of STEP and MOD will generate a uniform distribution of pseudo-random numbers. InputEach line of input will contain a pair of integers for STEP and MOD in that order (1 <= STEP, MOD <= 100000). Output

11

For each line of input, your program should print the STEP value right- justified in columns 1 through 10, the MOD value right-justified in columns 11 through 20 and either ``Good Choice" or ``Bad Choice" left-justified starting in column 25. The ``Good Choice" message should be printed when the selection of STEP and MOD will generate all the numbers between and including 0 and MOD-1 when MOD numbers are generated. Otherwise, your program should print the message ``Bad Choice". After each output test set, your program should print exactly one blank line. Sample Input3 515 2063923 99999Sample Output 3 5 Good Choice 15 20 Bad Choice 63923 99999 Good Choice

12 Excuses, Excuses!Judge Ito is having a problem with people subpoenaed for jury duty giving rather lame excuses in order to avoid serving. In order

to reduce the amount of time required listening to goofy excuses, Judge Ito has asked that you write a program that will search for a list of keywords in a list of excuses identifying lame excuses. Keywords can be matched in an excuse regardless of case. Input Input to your program will consist of multiple sets of data.

Line 1 of each set will contain exactly two integers. The first number (1 <= K <= 20) defines the number of keywords to be used in the search. The second number (1 <= E <= 20) defines the number of excuses in the set to be searched. Lines 2 through K+1 each contain exactly one keyword. Lines K+2 through K+1+E each contain exactly one excuse. All keywords in the keyword list will contain only contiguous lower case alphabetic characters of length L (1 <= L <= 20) and will occupy columns 1 through L in the input line.All excuses can contain any upper or lower case alphanumeric character, a space, or any of the following punctuation marks [SPMamp".,!?&] not including the square brackets and will not exceed 70 characters in length.Excuses will contain at least 1 non-space character. OutputFor each input set, you are to print the worst excuse(s) from the list.

12

The worst excuse(s) is/are defined as the excuse(s) which contains the largest number of incidences of keywords.If a keyword occurs more than once in an excuse, each occurrence is considered a separate incidence.

A keyword ``occurs" in an excuse if and only if it exists in the string in contiguous form and is delimited by the beginning or end of the line or any non-alphabetic character or a space.

For each set of input, you are to print a single line with the number of the set immediately after the string ``Excuse Set #". (See the Sample Output). The following line(s) is/are to contain the worst excuse(s) one per line exactly as read in. If there is more than one worst excuse, you may print them in any order. After each set of output, you should print a blank line. Sample Input5 3dogatehomeworkcanarydiedMy dog ate my homework.Can you believe my dog died after eating my canary... AND MY HOMEWORK?This excuse is so good that it contain 0 keywords.6 5superhighwaycrazythermonuclearbedroomwarbuildingI am having a superhighway built in my bedroom.I am actually crazy.1234567890.....,,,,,0987654321?????!!!!!!There was a thermonuclear war!I ate my dog, my canary, and my homework ... note outdated keywords?

13

Sample OutputExcuse Set #1Can you believe my dog died after eating my canary... AND MY HOMEWORK?Excuse Set #2I am having a superhighway built in my bedroom.There was a thermonuclear war!

13 M*A*S*HCorporal Klinger is a member of the 4077th Mobile Army Surgical Hospital in the Korean War; and he will do just about anything

to get out. The U.S. Army has made an offer for a lottery that will choose some number of lucky people (X) to return to the states for a recruiting tour. Klinger needs your help getting out. The lottery is run by lining up all the members of the unit at attention and eliminating members by counting off the members from 1 to N where N is a number chosen by pulling cards off of the top of a deck. Every time N is reached, that person falls out of the line, and counting begins again at 1 with the next person in line. When the end of the line has been reached (with whatever number that may be), the next card on the top of the deck will be taken, and counting starts again at 1 with the first person in the remaining line. The last X people in line get to go home.

Klinger has found a way to trade a stacked deck with the real deck just before the selection process begins. However, he will not know how many people will show up for the selection until the last minute. Your job is to write a program that will use the deck Klinger supplies and the number of people in line that he counts just before the selection process begins and tell him what position(s) in the line to get in to assure himself of a trip home. You are assured that Klinger's deck will get the job done by the time the 20th card is used. A simple example with 10 people, 2 lucky spots, and the numbers from cards 3, 5, 4, 3, 2 would show that Klinger should get in positions 1 or 8 to go home. Input For each selection, you will be given a line of 22 integers. The first integer (1 <= N <= 50) tells how many people will participate in the lottery. The second integer (1 <= X <= N) is how many lucky "home" positions will be selected. The next 20 integers are the values of the first 20 cards in the deck. Card values are interpretted to integer values between 1 and 11 inclusive. Output For each input line, you are to print the message ``Selection #A" on a line by itself where A is the number of the selection starting with 1 at the top of the input file. The next line will contain a list of ``lucky" positions that Klinger should attempt to get into. The list of ``lucky" positions is then followed by a blank line.

14

Sample Input10 2 3 5 4 3 2 9 6 10 10 6 2 6 7 3 4 7 4 5 3 247 6 11 2 7 3 4 8 5 10 7 8 3 7 4 2 3 9 10 2 5 3Sample OutputSelection #1 1 8 Selection #2 1 3 16 23 31 47

14 Perfect CubesFor hundreds of years Fermat's Last Theorem, which stated simply that for n > 2 there exist no integers a, b, c > 1 such that a^n =

b^n + c^n, has remained elusively unproven. (A recent proof is believed to be correct, though it is still undergoing scrutiny.) It is possible, however, to find integers greater than 1 that satisfy the ``perfect cube'' equation a^3 = b^3 + c^3 + d^3 (e.g. a quick calculation will show that the equation 12^3 = 6^3 + 8^3 + 10^3 is indeed true). This problem requires that you write a program to find all sets of numbers {a, b, c, d} which satisfy this equation for a <= 200. Output

The output should be listed as shown below, one perfect cube per line, in non-decreasing order of a (i.e. the lines should be sorted by their a values). The values of b, c, and d should also be listed in non-decreasing order on the line itself. There do exist several values of a which can be produced from multiple distinct sets of b, c, and d triples. In these cases, the triples with the smaller b values should be listed first. The first part of the output is shown here: Cube = 6, Triple = (3,4,5)Cube = 12, Triple = (6,8,10)Cube = 18, Triple = (2,12,16)Cube = 18, Triple = (9,12,15)Cube = 19, Triple = (3,10,18)Cube = 20, Triple = (7,14,17)Cube = 24, Triple = (12,16,20)

Note: The programmer will need to be concerned with an efficient implementation. The official time limit for this problem is 2 minutes, and it is indeed possible to write a solution to this problem which executes in under 2 minutes on a 33 MHz 80386 machine. Due to the distributed nature of the contest in this region, judges have been instructed to make the official time limit at their site the

15

greater of 2 minutes or twice the time taken by the judge's solution on the machine being used to judge this problem. 15 The Drunk Jailer

A certain prison contains a long hall of n cells, each right next to each other. Each cell has a prisoner in it, and each cell is locked. One night, the jailer gets bored and decides to play a game. For round 1 of the game, he takes a drink of whiskey, and then runs

down the hall unlocking each cell. For round 2, he takes a drink of whiskey, and then runs down the hall locking every other cell (cells 2, 4, 6, …). For round 3, he takes a drink of whiskey, and then runs down the hall. He visits every third cell (cells 3, 6, 9, …). If the cell is locked, he unlocks it; if it is unlocked, he locks it. He repeats this for n rounds, takes a final drink, and passes out.

Some number of prisoners, possibly zero, realizes that their cells are unlocked and the jailer is incapacitated. They immediately escape.

Given the number of cells, determine how many prisoners escape jail.Input

The first line of input contains a single positive integer. This is the number of lines that follow. Each of the following lines contains a single integer between 5 and 100, inclusive, which is the number of cells n.OutputFor each line, you must print out the number of prisoners that escape when the prison has n cells.Sample Input25100 Sample Output210

16 GamblersA group of n gamblers decide to play a game: At the beginning of the game each of them will cover up his wager on the table and the assitant must make sure that there are no two gamblers have put the same amount. If one has no money left, one may borrow some chips and his wager amount is considered to be negative. Assume that they all bet integer amount of money. Then when they unveil their wagers, the winner is the one who's bet is exactly the same as the sum of that of 3 other gamblers. If there are more than one winners, the one with the largest bet wins. For example, suppose Tom, Bill, John, Roger and Bush bet $2, $3, $5, $7 and $12, respectively. Then the winner is Bush with $12

16

since $2 + $3 + $7 = $12 and it's the largest bet. InputWagers of several groups of gamblers, each consisting of a line containing an integer 1 <= n <= 1000 indicating the number of gamblers in a group, followed by their amount of wagers, one per line. Each wager is a distinct integer between -536870912 and +536870911 inclusive. The last line of input contains 0. OutputFor each group, a single line containing the wager amount of the winner, or a single line containing "no solution". Sample Input52 3 5 7 1252 16 64 256 10240Output for Sample Input12no solution

Z17 Reverse TextIn most languages, text is written from left to right. However, there are other languages where text is read and written from right to

left. As a first step towards a program that automatically translates from a left-to-right language into a right-to-left language and back, you are to write a program that changes the direction of a given text. Input Specification

The input contains several test cases. The first line contains an integer specifying the number of test cases. Each test case consists of

17

a single line of text which contains at most 70 characters. However, the newline character at the end of each line is not considered to be part of the line.Output SpecificationFor each test case, print a line containing the characters of the input line in reverse order.Sample Input3Frankly, I don't think we'll make muchmoney out of this scheme.madam I'm adamSample Outputhcum ekam ll'ew kniht t'nod I ,ylknarF.emehcs siht fo tuo yenommada m'I madam

Z18 Digital RootsBackground

The digital root of a positive integer is found by summing the digits of the integer. If the resulting value is a single digit then that digit is the digital root. If the resulting value contains two or more digits, those digits are summed and the process is repeated. This is continued as long as necessary to obtain a single digit.

For example, consider the positive integer 24. Adding the 2 and the 4 yields a value of 6. Since 6 is a single digit, 6 is the digital root of 24. Now consider the positive integer 39. Adding the 3 and the 9 yields 12. Since 12 is not a single digit, the process must be repeated. Adding the 1 and the 2 yeilds 3, a single digit and also the digital root of 39.Input

The input file will contain a list of positive integers, one per line. The end of the input will be indicated by an integer value of zero.Output

For each integer in the input, output its digital root on a separate line of the output.ExampleInput24390

18

Output63

Z19 Word ReversalFor each list of words, output a line with each word reversed without changing the order of the words.

This problem contains multiple test cases!The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format

indicated in the problem description. There is a blank line between input blocks.The output format consists of N output blocks. There is a blank line between output blocks.

InputYou will be given a number of test cases. The first line contains a positive integer indicating the number of cases to follow. Each

case is given on a line containing a list of words separated by one space, and each word contains only uppercase and lowercase letters.OutputFor each test case, print the output on one line.Sample Input13I am happy todayTo be or not to beI want to win the practice contestSample OutputI ma yppah yadotoT eb ro ton ot ebI tnaw ot niw eht ecitcarp tsetnoc

Z20 A Mathematical CuriosityGiven two integers n and m, count the number of pairs of integers (a,b) such that 0 < a < b < n and (a^2+b^2 +m)/(ab) is an integer.This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.The output format consists of N output blocks. There is a blank line between output blocks.

19

InputYou will be given a number of cases in the input. Each case is specified by a line containing the integers n and m. The end of input

is indicated by a case in which n = m = 0. You may assume that 0 < n <= 100.Output

For each case, print the case number as well as the number of pairs (a,b) satisfying the given property. Print the output for each case on one line in the format as shown below.Sample Input110 120 330 40 0Sample OutputCase 1: 2Case 2: 4Case 3: 5

Z21 Niven NumbersA Niven number is a number such that the sum of its digits divides itself. For example, 111 is a Niven number because the sum of

its digits is 3, which divides 111. We can also specify a number in another base b, and a number in base b is a Niven number if the sum of its digits divides its value.

Given b (2 <= b <= 10) and a number in base b, determine whether it is a Niven number or not.This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.The output format consists of N output blocks. There is a blank line between output blocks.InputYou will be given a number of test cases. Each line of input contains the base b, followed by a string of digits representing a positive integer in that base. There are no leading zeroes. The input is terminated by a line consisting of 0 alone.OutputFor each case, print "yes" on a line if the given number is a Niven number, and "no" otherwise.

20

Sample Input110 1112 11010 1236 10008 23140Sample Outputyesyesnoyesno

Z22 PerfectionFrom the article Number Theory in the 1994 Microsoft Encarta: "If a, b, c are integers such that a = bc, a is called a multiple of b or

of c, and b or c is called a divisor or factor of a. If c is not 1/-1, b is called a proper divisor of a. Even integers, which include 0, are multiples of 2, for example, -4, 0, 2, 10; an odd integer is an integer that is not even, for example, -5, 1, 3, 9. A perfect number is a positive integer that is equal to the sum of all its positive, proper divisors; for example, 6, which equals 1 + 2 + 3, and 28, which equals 1 + 2 + 4 + 7 + 14, are perfect numbers. A positive number that is not perfect is imperfect and is deficient or abundant according to whether the sum of its positive, proper divisors is smaller or larger than the number itself. Thus, 9, with proper divisors 1, 3, is deficient; 12, with proper divisors 1, 2, 3, 4, 6, is abundant." Given a number, determine if it is perfect, abundant, or deficient. InputA list of N positive integers (none greater than 60,000), with 1 < N < 100. A 0 will mark the end of the list. Output The first line of output should read PERFECTION OUTPUT. The next N lines of output should list for each input integer whether it is perfect, deficient, or abundant, as shown in the example below. Format counts: the echoed integers should be right justified within the first 5 spaces of the output line, followed by two blank spaces, followed by the description of the integer. The final line of output

21

should read END OF OUTPUT. 解题思路：利用while语句实现输入的循环，for循环实现判断输

Sample Input 入对应于输出的哪一种，再实现输出

15 28 6 56 60000 22 496 0 //必须输入字符形式Sample Output

PERFECTION OUTPUT // 必须先单独输出   15  DEFICIENT   28  PERFECT    6  PERFECT   56  ABUNDANT60000  ABUNDANT   22  DEFICIENT  496  PERFECTEND OF OUTPUT

23 Function Run FunWe all love recursion! Don't we?Consider a three-parameter recursive function w(a, b, c):if a <= 0 or b <= 0 or c <= 0, then w(a, b, c) returns:1if a > 20 or b > 20 or c > 20, then w(a, b, c) returns:w(20, 20, 20)if a < b and b < c, then w(a, b, c) returns:w(a, b, c-1) + w(a, b-1, c-1) - w(a, b-1, c)otherwise it returns:w(a-1, b, c) + w(a-1, b-1, c) + w(a-1, b, c-1) - w(a-1, b-1, c-1)This is an easy function to implement. The problem is, if implemented directly, for moderate values of a, b and c (for example, a = 15,

22

b = 15, c = 15), the program takes hours to run because of the massive recursion.InputThe input for your program will be a series of integer triples, one per line, until the end-of-file flag of -1 -1 -1. Using the above technique, you are to calculate w(a, b, c) efficiently and print the result. For example:1 1 12 2 210 4 650 50 50-1 7 18-1 -1 -1 OutputPrint the value for w(a,b,c) for each triple, like this:w(1, 1, 1) = 2w(2, 2, 2) = 4w(10, 4, 6) = 523w(50, 50, 50) = 1048576w(-1, 7, 18) = 1

24 String MatchingIt's easy to tell if two words are identical - just check the letters. But how do you tell if two words are almost identical? And how

close is "almost"? There are lots of techniques for approximate word matching. One is to determine the best substring match, which is the number of common letters when the words are compared letter-byletter.The key to this approach is that the words can overlap in any way. For example, consider the words CAPILLARY and MARSUPIAL. One way to compare them is to overlay them: CAPILLARYMARSUPIALThere is only one common letter (A). Better is the following overlay:CAPILLARY     MARSUPIALwith two common letters (A and R), but the best is:

23

   CAPILLARYMARSUPIAL Which has three common letters (P, I and L).The approximation measure appx(word1, word2) for two words is given by:     common letters * 2-----------------------------length(word1) + length(word2)Thus, for this example, appx(CAPILLARY, MARSUPIAL) = 6 / (9 + 9) = 1/3. Obviously, for any word W appx(W, W) = 1, which is a nice property, while words with no common letters have an appx value of 0.Input:The input for your program will be a series of words, two per line, until the end-of-file flag of -1.Using the above technique, you are to calculate appx() for the pair of words on the line and print the result. For example:CAR CARTTURKEY CHICKENMONEY POVERTYROUGH PESKYA A-1The words will all be uppercase.Output:Print the value for appx() for each pair as a reduced fraction, like this:appx(CAR,CART) = 6/7appx(TURKEY,CHICKEN) = 4/13appx(MONEY,POVERTY) = 1/3appx(ROUGH,PESKY) = 0appx(A,A) = 1Fractions reducing to zero or one should have no denominator.

25 Self NumbersIn 1949 the Indian mathematician D.R. Kaprekar discovered a class of numbers called self-numbers. For any positive integer n, define d(n) to be n plus the sum of the digits of n. (The d stands for digitadition, a term coined by Kaprekar.) For example, d(75) = 75 + 7 + 5

24

= 87. Given any positive integer n as a starting point, you can construct the infinite increasing sequence of integers n, d(n), d(d(n)), d(d(d(n))), .... For example, if you start with 33, the next number is 33 + 3 + 3 = 39, the next is 39 + 3 + 9 = 51, the next is 51 + 5 + 1 = 57, and so you generate the sequence 33, 39, 51, 57, 69, 84, 96, 111, 114, 120, 123, 129, 141, ...The number n is called a generator of d(n). In the sequence above, 33 is a generator of 39, 39 is a generator of 51, 51 is a generator of 57, and so on. Some numbers have more than one generator: for example, 101 has two generators, 91 and 100. A number with no generators is a self-number. There are thirteen self-numbers less than 100: 1, 3, 5, 7, 9, 20, 31, 42, 53, 64, 75, 86, and 97. Write a program to output all positive self-numbers less than or equal 1000000 in increasing order, one per line. Sample Output135792031425364|| <-- a lot more numbers|99039914992599279938994999609971

25

99829993|||

26 DNA SortingOne measure of ``unsortedness'' in a sequence is the number of pairs of entries that are out of order with respect to each other. For instance, in the letter sequence ``DAABEC'', this measure is 5, since D is greater than four letters to its right and E is greater than one letter to its right. This measure is called the number of inversions in the sequence. The sequence ``AACEDGG'' has only one inversion (E and D)--it is nearly sorted--while the sequence ``ZWQM'' has 6 inversions (it is as unsorted as can be--exactly the reverse of sorted). You are responsible for cataloguing a sequence of DNA strings (sequences containing only the four letters A, C, G, and T). However, you want to catalog them, not in alphabetical order, but rather in order of ``sortedness'', from ``most sorted'' to ``least sorted''. All the strings are of the same length. This problem contains multiple test cases!The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.The output format consists of N output blocks. There is a blank line between output blocks.InputThe first line contains two integers: a positive integer n (0 < n <= 50) giving the length of the strings; and a positive integer m (1 < m <= 100) giving the number of strings. These are followed by m lines, each containing a string of length n. Output Output the list of input strings, arranged from ``most sorted'' to ``least sorted''. If two or more strings are equally sorted, list them in the same order they are in the input file. Sample Input 110 6AACATGAAGGTTTTGGCCAATTTGGCCAAA

26

GATCAGATTTCCCGGGGGGAATCGATGCATSample OutputCCCGGGGGGAAACATGAAGGGATCAGATTTATCGATGCATTTTTGGCCAATTTGGCCAAA

27 Inversion  Let { A1,A2,...,An } be a permutation of the set{ 1,2,..., n}. If i < j and Ai > Aj then the pair (Ai,Aj) is called an "inversion" of the permutation. For example, the permutation {3, 1, 4, 2} has three inversions: (3,1), (3,2) and (4,2).  The inversion table B1,B2,...,Bn of the permutation { A1,A2,...,An } is obtained by letting Bj be the number of elements to the left of j that are greater than j. (In other words, Bj is the number of inversions whose second component is j.) For example, the permutation:{ 5,9,1,8,2,6,4,7,3 }has the inversion table2 3 6 4 0 2 2 1 0since there are 2 numbers, 5 and 9, to the left of 1; 3 numbers, 5, 9 and 8, to the left of 2; etc.  Perhaps the most important fact about inversions is Marshall Hall's observation that an inversion table uniquely determines the corresponding permutation. So your task is to convert a permutation to its inversion table, or vise versa, to convert from an inversion table to the corresponding permutation.Input:The input consists of several test cases. Each test case contains two lines.The first line contains a single integer N ( 1 <= N <= 50) which indicates the number of elements in the permutation/invertion table. The second line begins with a single charactor either 'P', meaning that the next N integers form a permutation, or 'I', meaning that the next N integers form an inversion table. Following are N integers, separated by spaces. The input is terminated by a line contains N=0.Output:For each case of the input output a line of intergers, seperated by a single space (no space at the end of the line). If the input is a

27

permutation, your output will be the corresponding inversion table; if the input is an inversion table, your output will be the corresponding permutation.Sample Input:9P 5 9 1 8 2 6 4 7 39I 2 3 6 4 0 2 2 1 00Sample Output:2 3 6 4 0 2 2 1 05 9 1 8 2 6 4 7 3

28 DeckScenarioA single playing card can be placed on a table, carefully, so that the short edges of the card are parallel to the table's edge, and half the length of the card hangs over the edge of the table. If the card hung any further out, with its center of gravity off the table, it would fall off the table and flutter to the floor. The same reasoning applies if the card were placed on another card, rather than on a table. Two playing cards can be arranged, carefully, with short edges parallel to table edges, to extend 3/4 of a card length beyond the edge of the table. The top card hangs half a card length past the edge of the bottom card. The bottom card hangs with only 1/4 of its length past the table's edge. The center of gravity of the two cards combined lies just over the edge of the table. Three playing cards can be arranged, with short edges parallel to table edges, and each card touching at most one other card, to extend 11/12 of a card length beyond the edge of the table. The top two cards extend 3/4 of a card length beyond the edge of the bottom card, and the bottom card extends only 1/6 over the table's edge; the center of gravity of the three cards lines over the edges of the table. If you keep stacking cards so that the edges are aligned and every card has at most one card above it and one below it, how far out can 4 cards extend over the table's edge? Or 52 cards? Or 1000 cards? Or 99999?InputInput contains several nonnegative integers, one to a line. No integer exceeds 99999.OutputThe standard output will contain, on successful completion of the program, a heading: # Cards Overhang (that's two spaces between the words) and, following, a line for each input integer giving the length of the longest overhang achievable

28

with the given number of cards, measured in cardlengths, and rounded to the nearest thousandth. The length must be expressed with at least one digit before the decimal point and exactly three digits after it. The number of cards is right-justified in column 5, and the decimal points for the lengths lie in column 12.Sample Input1 2 3 4 30 Sample OutputThe line of digits is intended to guide you in proper output alignment, and is not part of the output that your solution should produce. 12345678901234567 # Cards  Overhang     1     0.500     2     0.750     3     0.917     4     1.042    30     1.997

29 IBM Minus OneYou may have heard of the book '2001 - A Space Odyssey' by Arthur C. Clarke, or the film of the same name by Stanley Kubrick. In it a spaceship is sent from Earth to Saturn. The crew is put into stasis for the long flight, only two men are awake, and the ship is controlled by the intelligent computer HAL. But during the flight HAL is acting more and more strangely, and even starts to kill the crew on board. We don't tell you how the story ends, in case you want to read the book for yourself :-)After the movie was released and became very popular, there was some discussion as to what the name 'HAL' actually meant. Some thought that it might be an abbreviation for 'Heuristic ALgorithm'. But the most popular explanation is the following: if you replace every letter in the word HAL by its successor in the alphabet, you get ... IBM.Perhaps there are even more acronyms related in this strange way! You are to write a program that may help to find this out.InputThe input starts with the integer n on a line by itself - this is the number of strings to follow. The following n lines each contain one string of at most 50 upper-case letters.

29

OutputFor each string in the input, first output the number of the string, as shown in the sample output. The print the string start is derived from the input string by replacing every time by the following letter in the alphabet, and replacing 'Z' by 'A'.Print a blank line after each test case.Sample Input2HALSWERCSample OutputString #1IBMString #2TXFSD

30 FloppiesIn this age of Internet, on-line connections, instantaneous email, etc., there are still some people who need to work with floppy disks. John is one of those. Every evening he goes home and continues what he has been doing in his office on his private UNIX system. He copies all the files he needs to floppy disks according to the following procedure: 1. Put all files in one big SHAR file.2. Compress the file.3. Uuencode it, such that it is split in nice lines of 62 characters each (including the new-line).4. Split it in files of 30,000 lines each (about 1.86Mb).5. Compress each of the files and put it on a floppy by itself.So far, this procedure always worked, since 1.86Mb of uuencoded text, after compression, will nicely fit on a 1.44Mb floppy disk.Now, given that through compression the size of the SHAR file halves and that uuencoding a compressed file adds 50% to its size (each rounded to the nearest integer number of bytes), we would like to know for a given size of the SHAR file how many floppies John needs.Input SpecificationThe input contains several test cases. Each test case consists of a single line containing one integer s (0 <= s <= 1,000,000,000), specifying the size of the SHAR file in bytes.The file ends with a file having s = 0. Do not generate output for this file.

30

Output SpecificationFor each test case, first output the number of the test case ('File #1', 'File #2', etc.), followed by a line that contains the minimal number of floppies needed for the transfer and a blank line. Adhere to the format shown below in the sample output.Sample Input1000000100000001000000000Sample OutputFile #1John needs 1 floppies.File #2John needs 5 floppies.File #3John needs 41 floppies.

31 Fake TicketsYour school organized a big party to celebrate your team brilliant win in the prestigious, worldfamous ICPC (International Collegiate Poetry Contest). Everyone in your school was invited for an evening which included cocktail, dinner and a session where your team work was read to the audience. The evening was a success - many more people than you expected showed interested in your poetry - although some critics of yours said it was food rather than words that attracted such an audience.

Whatever the reason, the next day you found out why the school hall had seemed so full: the school director confided he had discovered that several of the tickets used by the guests were fake. The real tickets were numbered sequentially from 1 to N (N <= 10000). The director suspects some people had used the school scanner and printer from the Computer Room to produce copies of the real tickets. The director gave you a pack with all tickets collected from the guests at the party's entrance, and asked you to determine how many tickets in the pack had 'clones', that is, another ticket with the same sequence number.InputThe input contains data for several test cases. Each test case has two lines. The first line contains two integers N and M which indicate respectively the number of original tickets and the number of persons attending the party (1 <= N <= 10000 and 1 <= M <= 20000). The second line of a test case contains M integers Ti representing the ticket numbers in the pack the director gave you (1 <= Ti <= N).

31

The end of input is indicated by N = M = 0.OutputFor each test case your program should print one line, containing the number of tickets in the pack that had another ticket with the same sequence number. Sample Input5 53 3 1 2 46 106 1 3 6 6 4 2 3 1 20 0Sample Output14

32 Big NumberIn many applications very large integers numbers are required. Some of these applications are using keys for secure transmission of data, encryption, etc. In this problem you are given a number, you have to determine the number of digits in the factorial of the number.InputInput consists of several lines of integer numbers. The first line contains an integer n, which is the number of cases to be tested, followed by n lines, one integer 1 <= n <= 10^7 on each line.OutputThe output contains the number of digits in the factorial of the integers appearing in the input.Sample Input21020Sample Output719

33 Lot

32

Out of N soldiers, standing in one line, it is required to choose several to send them scouting. In order to do that, the following operation is performed several times: if the line consists of more than three soldiers, then all soldiers, standing on even positions, or all soldiers, standing on odd positions, are taken away. The above is done until three or less soldiers are left in the line. They are sent scouting. Find, how many different groups of three scouts may be created this way.Note: Groups with less than three number of soldiers are not taken into consideration.0 < N <= 10 000 000InputThe input file contains the number N.Process to the end of file.OutputThe output file must contain the solution - the amount of variants.Sample Input104Sample Output20

34 StripiesOur chemical biologists have invented a new very useful form of life called stripies (in fact, they were first called in Russian - polosatiki, but the scientists had to invent an English name to apply for an international patent). The stripies are transparent amorphous amebiform creatures that live in flat colonies in a jelly-like nutrient medium. Most of the time the stripies are moving. When two of them collide a new stripie appears instead of them. Long observations made by our scientists enabled them to establish that the weight of the new stripie isn't equal to the sum of weights of two disappeared stripies that collided; nevertheless, they soon learned that when two stripies of weights m1 and m2 collide the weight of resulting stripie equals to 2*sqrt(m1*m2). Our chemical biologists are very anxious to know to what limits can decrease the total weight of a given colony of stripies.You are to write a program that will help them to answer this question. You may assume that 3 or more stipies never collide together.InputThe first line of the input file contains one integer N (1 <= N <= 100) - the number of stripies in a colony. Each of next N lines contains one integer ranging from 1 to 10000 - the weight of the corresponding stripie.Process to the end of file.

33

OutputThe output file must contain one line with the minimal possible total weight of colony with the accuracy of three decimal digits after the point.Sample Input272503723050Sample Output120.000120.000

35 GCD & LCMGiven x and y (2 <= x <= 100,000, 2 <= y <= 1,000,000), you are to count the number of p and q such that: 1) p and q are positive integers;2) GCD(p, q) = x;3) LCM(p, q) = y.Inputx and y, one line for each test.OutputNumber of pairs of p and q.Sample Input3 60Sample Output4

36 PreQueLIn some simplistic DBMS named PreQueL, the only column type allowed is CHAR(1) (a single character), and furthermore, its values are restricted to English upper-case letters ('A' to 'Z'). Table may contain up to 9 columns, numbered from 1 to 9. Tables themselves

34

are named with lower-case English letters ('a' to 'z').

The only database query possible first joins all the tables, then selects some rows according to conditions in one of two forms: either <column>=<value> or <column1>=<column2>, for example a2=A or b1=c4. All conditions must hold simultaneously, as if they were connected by 'AND' operator.You must write a PreQueL processor, which, given a tables and a set of conditions, will produce query result, i.e. those rows of a join satisfying all the conditions. Resulting rows must be sorted alphabetically.InputThe first line of input file contains of two integers - number of tables T and number of conditions D.Starting from the second line there are T tables represented with number of rows RN and number of columns CN in the first line of a table, which is followed by RN lines consisting of exactly CN characters each. D lines with conditions follow the whole set of tables.The constraints are: 1 <= T <= 26, 1 <= D <= 50, 1 <= CN <= 9, 1 <= RN <= 1000.Process to the end of file.Output Output file contains result rows, one row per line. No input query will produce more than 1000 rows. The result rows are to be sorted alphabetically.Sample Input2 23 2AXBXBY2 3ACDBCCa1=b1a2=XSample OutputAXACDBXBCC

35

37 Hamming ProblemFor each three prime numbers p1, p2 and p3, let's define Hamming sequence Hi(p1, p2, p3), i=1, ... as containing in increasing order all the natural numbers whose only prime divisors are p1, p2 or p3.For example, H(2, 3, 5) = 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, ...So H5(2, 3, 5)=6.InputIn the single line of input file there are space-separated integers p1 p2 p3 i.Process to the end of file.OutputThe output file must contain the single integer - Hi(p1, p2, p3). All numbers in input and output are less than 10^18.Sample Input7 13 19 100Sample Output26590291

38 Multiplication PuzzleThe multiplication puzzle is played with a row of cards, each containing a single positive integer. During the move player takes one card out of the row and scores the number of points equal to the product of the number on the card taken and the numbers on the cards on the left and on the right of it. It is not allowed to take out the first and the last card in the row. After the final move, only two cards are left in the row.The goal is to take cards in such order as to minimize the total number of scored points.For example, if cards in the row contain numbers 10 1 50 20 5, player might take a card with 1, then 20 and 50, scoring10*1*50 + 50*20*5 + 10*50*5 = 500+5000+2500 = 8000

If he would take the cards in the opposite order, i.e. 50, then 20, then 1, the score would be1*50*20 + 1*20*5 + 10*1*5 = 1000+100+50 = 1150.InputThe first line of the input file contains the number of cards N (3 <= N <= 100). The second line contains N integers in the range from 1 to 100, separated by spaces.Process to the end of file.Output

36

Output file must contain a single integer - the minimal score.Sample Input610 1 50 50 20 5Sample Output3650

39 Count the ColorsPainting some colored segments on a line, some previously painted segments may be covered by some the subsequent ones. Your task is counting the segments of different colors you can see at last.InputThe first line of each data set contains exactly one integer n, 1 <= n <= 8000, equal to the number of colored segments.Each of the following n lines consists of exactly 3 nonnegative integers separated by single spaces:x1 x2 cx1 and x2 indicate the left endpoint and right endpoint of the segment, c indicates the color of the segment.All the numbers are in the range [0, 8000], and they are all integers.Input may contain several data set, process to the end of file.OutputEach line of the output should contain a color index that can be seen from the top, following the count of the segments of this color, they should be printed according to the color index.If some color can't be seen, you shouldn't print it.Print a blank line after every dataset.Sample Input50 4 40 3 13 4 20 2 20 2 340 1 1

37

3 4 11 3 21 3 160 1 01 2 12 3 11 2 02 3 01 2 1Sample Output1 12 13 11 10 21 1

40 Circuit BoardOn the circuit board, there are lots of circuit paths. We know the basic constrain is that no two path cross each other, for otherwise the board will be burned.Now given a circuit diagram, your task is to lookup if there are some crossed paths. If not find, print "ok!", otherwise "burned!" in one line.A circuit path is defined as a line segment on a plane with two endpoints p1(x1,y1) and p2(x2,y2).You may assume that no two paths will cross each other at any of their endpoints.InputThe input consists of several test cases. For each case, the first line contains an integer n(<=2000), the number of paths, then followed by n lines each with four float numbers x1, y1, x2, y2. OutputIf there are two paths crossing each other, output "burned!" in one line; otherwise output "ok!" in one line.Sample Input

38

10 0 1 120 0 1 10 1 1 0Sample Outputok!burned!Author: ZHOU, Feng

41 Machined SurfacesAn imaging device furnishes digital images of two machined surfaces that eventually will be assembled in contact with each other. The roughness of this final contact is to be estimated. A digital image is composed of the two characters, "X" and " " (space). There are always 25 columns to an image, but the number of rows, N, is variable. Column one (1) will always have an "X" in it and will be part of the left surface. The left surface can extend to the right from column one (1) as contiguous X's. Similarly, column 25 will always have an "X" in it and will be part of the right surface. The right surface can extend to the left from column 25 as contiguous X's. Digital-Image View of Surfaces

Left Right XXXX XXXXX XXX XXXXXXX XXXXX XXXX XX XXXXXX . . . . . . XXXX XXXX XXX XXXXXX 1 25

In each row of the image, there can be zero or more space characters separating the left surface from the right surface. There will

39

never be more than a single blank region in any row. For each image given, you are to determine the total ``void" that will exist after the left surface has been brought into contact with the right surface. The ``void" is the total count of the spaces that remains between the left and right surfaces after theyhave been brought into contact. The two surfaces are brought into contact by displacing them strictly horizontally towards each other until a rightmost "X" of the left surface of some row is immediately to the left of the leftmost "X" of the right surface of that row. There is no rotation or twisting of these two surfaces as they are brought into contact; they remain rigid, and only move horizontally. Note: The original image may show the two surfaces already in contact, in which case no displacement enters into the contact roughness estimation. InputThe input consists of a series of digital images. Each image data set has the following format: First line - A single unsigned integer, N, with value greater than zero (0) and less than 13. The first digit of N will be the first character on a line. Next N lines - Each line has exactly 25 characters; one or more X's, then zero or more spaces, then one or more X's. The end of data is signaled by a null data set having a zero on the first line of an image data set and no further data. OutputFor each image you receive as a data set, you are to reply with the total void (count of spaces remaining after the surfaces are brought into contact). Use the default output for a single integer on a line. Sample Input(character "B" for ease of reading. The actual input file will use the ASCII-space character, not "B").4XXXXBBBBBBBBBBBBBBBBXXXXXXXXBBBBBBBBBBBBBBBXXXXXXXXXXXXBBBBBBBBBBBBBBBBXXXXXXBBBBBBBBBBBBBBBBBXXXXXX2XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX1

40

XXXXXXXXXBBBBBBBBBBBBBBXX0Sample Output400

42 Word IndexEncoding schemes are often used in situations requiring encryption or information storage/transmission economy. Here, we develop a simple encoding scheme that encodes particular types of words with five or fewer (lower case) letters as integers. Consider the English alphabet {a,b,c,...,z}. Using this alphabet, a set of valid words are to be formed that are in a strict lexicographic order. In this set of valid words, the successive letters of a word are in a strictly ascending order; that is, later letters in a valid word are always after previous letters with respect to their positions in the alphabet list {a,b,c,...,z}. For example, abc aep gwz are all valid three-letter words, whereas aab are cat are not. For each valid word associate an integer which gives the position of the word in the alphabetized list of words. That is: a -> 1b -> 2..z -> 26ab -> 27ac -> 28..az -> 51bc -> 52..

41

vwxyz -> 83681Your program is to read a series of input lines. Each input line will have a single word on it, that will be from one to five letters long. For each word read, if the word is invalid give the number 0. If the word read is valid, give the word's position index in the above alphabetical list. InputThe input consists of a series of single words, one per line. The words are at least one letter long and no more that five letters. Only the lower case alphabetic {a,b,...,z} characters will be used as input. The first letter of a word will appear as the first character on an input line. The input will be terminated by end-of-file. OutputThe output is a single integer, greater than or equal to zero (0) and less than or equal 83681. The first digit of an output value should be the first character on a line. There is one line of output for each input line. Sample InputzacatvwxyzSample Output261083681

43 The Drunk JailerA certain prison contains a long hall of n cells, each right next to each other. Each cell has a prisoner in it, and each cell is locked. One night, the jailer gets bored and decides to play a game. For round 1 of the game, he takes a drink of whiskey, and then runs down the hall unlocking each cell. For round 2, he takes a drink of whiskey, and then runs down the hall locking every other cell (cells 2, 4, 6, …). For round 3, he takes a drink of whiskey, and then runs down the hall. He visits every third cell (cells 3, 6, 9, …). If the cell is locked, he unlocks it; if it is unlocked, he locks it. He repeats this for n rounds, takes a final drink, and passes out.Some number of prisoners, possibly zero, realizes that their cells are unlocked and the jailer is incapacitated. They immediately escape.

42

Given the number of cells, determine how many prisoners escape jail.InputThe first line of input contains a single positive integer. This is the number of lines that follow. Each of the following lines contains a single integer between 5 and 100, inclusive, which is the number of cells n.OutputFor each line, you must print out the number of prisoners that escape when the prison has n cells.Sample Input25100 Sample Output210

44 Number Base ConversionWrite a program to convert numbers in one base to numbers in a second base. There are 62 different digits: { 0-9,A-Z,a-z }HINT: If you make a sequence of base conversions using the output of one conversion as the input to the next, when you get back to the original base, you should get the original number.InputThe first line of input contains a single positive integer. This is the number of lines that follow. Each of the following lines will have a (decimal) input base followed by a (decimal) output base followed by a number expressed in the input base. Both the input base and the output base will be in the range from 2 to 62. That is (in decimal) A = 10, B = 11, …, Z = 35, a = 36, b = 37, …, z = 61 (0-9 have their usual meanings).OutputThe output of the program should consist of three lines of output for each base conversion performed. The first line should be the input base in decimal followed by a space then the input number (as given expressed in the input base). The second output line should be the output base followed by a space then the input number (as expressed in the output base). The third output line is blank.Sample Input862 2 abcdefghiz

43

10 16 123456789012345678901234567890123456789016 35 3A0C92075C0DBF3B8ACBC5F96CE3F0AD235 23 333YMHOUE8JPLT7OX6K9FYCQ8A23 49 946B9AA02MI37E3D3MMJ4G7BL2F0549 61 1VbDkSIMJL3JjRgAdlUfcaWj61 5 dl9MDSWqwHjDnToKcsWE1S5 10 42104444441001414401221302402201233340311104212022133030Sample Output62 abcdefghiz2 1101110000010001011111001001011001111100100110001101001000110 123456789012345678901234567890123456789016 3A0C92075C0DBF3B8ACBC5F96CE3F0AD216 3A0C92075C0DBF3B8ACBC5F96CE3F0AD235 333YMHOUE8JPLT7OX6K9FYCQ8A35 333YMHOUE8JPLT7OX6K9FYCQ8A23 946B9AA02MI37E3D3MMJ4G7BL2F0523 946B9AA02MI37E3D3MMJ4G7BL2F0549 1VbDkSIMJL3JjRgAdlUfcaWj49 1VbDkSIMJL3JjRgAdlUfcaWj61 dl9MDSWqwHjDnToKcsWE1S61 dl9MDSWqwHjDnToKcsWE1S5 421044444410014144012213024022012333403111042120221330305 4210444444100141440122130240220123334031110421202213303010 1234567890123456789012345678901234567890

45 Unimodal Palindromic DecompositionsA sequence of positive integers is Palindromic if it reads the same forward and backward. For example: 23 11 15 1 37 37 1 15 11 231 1 2 3 4 7 7 10 7 7 4 3 2 1 1A Palindromic sequence is Unimodal Palindromic if the values do not decrease up to the middle value and then (since the sequence is palindromic) do not increase from the middle to the end For example, the first example sequence above is NOT Unimodal

44

Palindromic while the second example is.A Unimodal Palindromic sequence is a Unimodal Palindromic Decomposition of an integer N, if the sum of the integers in the sequence is N. For example, all of the Unimodal Palindromic Decompositions of the first few integers are given below:1: (1) 2: (2), (1 1)3: (3), (1 1 1)4: (4), (1 2 1), (2 2), (1 1 1 1)5: (5), (1 3 1), (1 1 1 1 1)6: (6), (1 4 1), (2 2 2), (1 1 2 1 1), (3 3), (1 2 2 1), ( 1 1 1 1 1 1)7: (7), (1 5 1), (2 3 2), (1 1 3 1 1), (1 1 1 1 1 1 1)8: (8), (1 6 1), (2 4 2), (1 1 4 1 1), (1 2 2 2 1), (1 1 1 2 1 1 1), ( 4 4), (1 3 3 1), (2 2 2 2), (1 1 2 2 1 1), (1 1 1 1 1 1 1 1)Write a program, which computes the number of Unimodal Palindromic Decompositions of an integer.InputInput consists of a sequence of positive integers, one per line ending with a 0 (zero) indicating the end.OutputFor each input value except the last, the output is a line containing the input value followed by a space, then the number of Unimodal Palindromic Decompositions of the input value. Sample Input2345678102324131213

45

920Sample Output2 23 24 45 36 77 58 1110 1723 10424 199131 5010688213 105585259092 331143

说明：建议学生利用假期时间完成上述题目中的 20——30道题。需要利用专门的作业本完成，标明题号。如果能够上机调试，整理好源

程序代码。本次作业作为开学选拔学生参赛选手的其中一个重要依据。

46