SPOJ Challenge

Archives of the Sphere Online Judge
challenge problemset
Editors:
Roman Sol
Micha Maafiejski
Adrian Kosowski
(Tjandra Satria
Gunawan)(???)
Francky
.:: Debanjan ::.
XeRoN!X
HWK
Bin Jin
[Trichromatic] XilinX
cegprakash
Devil D
Mostafa 36a2 (Al3ayesh)
Spooky
Govind Lahoti
Jimmy Tirtawangsa
ukasz Kuszner
A@k@sh Joh@ri
Vimal
Thomas Dybdahl Ahle
Michael Suchacz
Konrad Piwakowski
Gogu Marian
Yandry Perez
Jander
Jargon
legrand
Kawmia Institutes
Thanh-Vy Hua
Jared Deckard
Michael Mudge
Adam Dzedzej
Better late than never
!!!
Pawel Gawrychowski
Aditya Pande
Maxim Sukhov
Race with time
Therapist
Ruslan Sennov
Krzysztof Kluczek
Tony Beta Lambda
Duc
Last updated: 2013-08-12 14:10:38
Preface
This electronic material contains a set of algorithmic problems, forming the archives of the Sphere
Online Judge (http://www.spoj.com/), challenge problemset. The document can be accessed at the
following URLs:
in PostScript format: http://www.spoj.com/problems/challenge.ps
in Portable Document Format: http://www.spoj.com/problems/challenge.pdf
These resources are constantly updated to synchronise with the ever-changing hypertext version of the
problems, and to include newly added problems. If you have obtained this document from another
source, it is strongly recommended that you should download the current version from one of the
aforementioned URLs.
Enjoy problem-solving at the Sphere Online Judge!
Disclaimer from the Editors. Despite our best efforts, it is possible that this document contains errors or that some of the
content differs slightly from its original hypertext form. We take no responsibility for any such faults and their
consequences. We neither authorise nor approve use of this material for any purpose other than facilitating problem solving
at the Sphere Online Judge site; nor do we guarantee its fitness for any purpose whatsoever.
The layout of the problems in this document is the copyright of the Editors named on the cover (as determined by the
appropriate footers in the problem description). The content is the copyright of the respective Editor unless the copyright
holder is otherwise stated in the resource section. The document as a whole is not protected by copyright, and fragments
of it are to be regarded independently. No responsibility is taken by the Editors if use or redistribution of this document
violates either their or third party copyright laws. When referring to or citing the whole or a fragment of this document,
please state clearly the aforementioned URLs at which the document is to be found, as well as the resources from which the
problems you are referring to originally came.
Remarks concerning this document should be sent to the following e-mail address: contact@spoj.com.
Table of Contents
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
Problem KAMIL (53. Kamil)

Problem BYTEFOOD (72. Food Shortage in Byteland)
Problem SOLSTRAS (126. Solovay-Strassen Inverted)
Problem JOHNNY (127. Johnny Goes Shopping)
Problem SOLVING (155. Solving the Puzzle)
Problem PSPHERE (218. Points on a Sphere)
Problem PAWNS (219. Pawns Gone Wild)
Problem BURNCITY (222. The Burning City)
Problem HANOI (225. Nightmare in the Towers of Hanoi)
Problem BYTELE (232. Bytelandian Telecom)
Problem SANTA (240. Santa Claus and the Presents)
Problem CTQUINE (246. Plant a Christmas Tree)
Problem PIVAL (270. Digits of Pi)
Problem DCODE (273. The Modern Dress Code)
Problem MFENCE (276. Herdkeeper)
Problem ATSHELT (285. Atomic Shelters)
Problem TMBOX (289. The Turing Music Box)
Problem HWORK (294. Johnny and the Optimisation of Homework)
Problem BRIGAMI (295. Bytelandian Origami)
Problem DERAIL (298. Closing down Railway Lines)
Problem CROSSES (313. The Game of Crosses & Crosses)
Problem EVAL (314. Digits of e)
Problem BFORG (315. The Secret Fellowship of Byteland)
Problem JCROSS (316. Japan Crossword)
Problem IMGREC1 (317. Simple Image Recognition)
Problem XWORDS (321. X-Words)
Problem MGAME (326. Enjoying a Multiplayer Game)
Problem DISPLACE (353. Displace)
Problem MAMMOTH (356. Tethering the Mammoths)
Problem TFRACAL2 (525. Fractions Calculator)
Problem TSSTR (528. Shortest Superstring)
Problem RIS (755. Rectangles in a Square)
Problem TTR (758. Tetris AI)
Problem MSWP (761. Minesweeper)
Problem PRIC (919. Prime checker)
Problem SUD (1414. SuDoku Puzzle)
Problem ELC (1416. Electrification)
Problem DIP (1422. Digital Image Processing)
Problem SQRT2 (1423. Digits of SQRT(2))
Problem PT07E (1481. Yet another computer network problem)
Problem SLEXSORT (1492. Lexicographic sort)
Problem MATH2 (1558. Math II)
Problem INTER (1690. Intercept)
Problem GCD (1711. Greatest Common Divisor)
Problem BRAINF_K (1742. Brainf_ck)
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
Problem EXPR2 (2004. Analyse Simple Arithmetical Expressions)

Problem ERRORMIN (2335. Error Minimization)
Problem MAGIC2 (2471. Magic Program II)
Problem JAWB (2624. JawBreaker Game)
Problem MAR (2628. Markov Algorithm)
Problem EYES (2629. Robo Eye)
Problem CARL (2659. Carl)
Problem SPOJTEST (2824. Glenbow Museum)
Problem SELF (3099. Super Quine)
Problem NOP (3880. Nop)
Problem BFWRITE (3947. Brainf F##k Writing)
Problem PLCNUM2 (4246. Place the Numbers II)
Problem DDATE (6125. Dos Date)
Problem DBP (6173. Burned Pancakes Tower)
Problem SQDIFF (6295. Area Difference)
Problem MONS (6338. Monster)
Problem BRACKETS (6646. Fully Parenthesized Expression)
Problem DEC_BIN (6877. Terminating or Non-Terminating)
Problem CYCLE (7063. Cycles, More Cycles)
Problem REVINPUT (7105. Reverse the Input)
Problem WORDNUM (7225. Word To Number)
Problem NPRIME (7480. Nth Prime)
Problem BENDA (7958. Prisoner of Benda (Challenge))
Problem DIE_PIP (7965. The Electronic Dice)
Problem NUMWORD (8315. Number to Word)
Problem PRINTF (8405. Printf Parser)
Problem WAYS (8473. PATHS)
Problem MODULUS2 (8579. BF_MODULUS)
Problem FIBSUM (8638. Sum of Fibonacci numbers)
Problem BALLS (8672. Distributing the balls)
Problem EQCHECK (8675. Equation Check)
Problem PHIVAL (8676. Digits of Phi (Golden Ratio))
Problem PLDGTS (8733. Summing up Last digits)
Problem GRIDPNT (8950. Grid points)
Problem THREETWN (9380. Connecting three towns)
Problem HQNP2 (10295. HQNP Incomputable Hard)
Problem INDISET (11397. Find all independent nodes)
Problem FINDPROB (11410. Find New SPOJ Problems)
Problem EASYMATC (11445. EASY MATH (Challenge))
Problem AGSCHALL (11451. Aritho-geometric Series (AGS) (Challenge))
Problem FIBFUNCH (11462. Fun with Fibonacci Series (Challenge))
Problem REALROOT (11689. Real Roots)
Problem M5TILE (11719. The dojo s corridor)
Problem SUMUP (11746. Sum the Series)
Problem JH1 (11790. Size Contest!!!Reloaded!!)
Problem CSPATH (11793. Cartesian Shortest Path)
Problem MNTILE (11815. Tiling a WxH Grid With Dominoes)
93. Problem EPROBLEM (11849. A Very Easy Problem! (Challenge Mode))

94. Problem ENIGMAS (12393. Enigma Machine)
95. Problem NAKANJC (12845. Minimum knight moves Challenge)
96. Problem PELLFOUR (12874. Pell Fourth)
97. Problem MOS (12919. Man of Steel)
98. Problem WOW_SQR (12996. Wow Square)
99. Problem TSET (13016. "If Equal" in BF)
100. Problem VERCOVER (13077. Fewest possible vertices to cover a graph)
101. Problem BFBIGTHN (13083. "If Bigger than" in BF)
102. Problem GOV02 (13172. Good)
103. Problem BFMODULO (13175. "a mod b" in BF)
104. Problem FAST_BF2 (13224. The BrainFast Processing! Challenge version)
105. Problem CONQUER (13366. TWO KINGS)
106. Problem BMS1988 (13418. Fibonacci factorization)
107. Problem FIB64 (13423. 64bit-Fibonacci)
108. Problem SPPC (13872. The SPP constant challenge)
109. Problem FMORSE1 (13923. Fractionated morse cipher)
110. Problem MATEX (13929. Matrix Exponentiation)
111. Problem GOV04 (14530. Quadratic primes)
112. Problem GCD4 (14808. Discrete Math Problem (shorten))
113. Problem BFK_AUTO (15036. Automatic Brainf##k Code Generator (Shortening AI))
114. Problem SWAPSORT (15619. Optimal Swap Sort)
SPOJ Problem Set (challenge)
53. Kamil
Problem code: KAMIL
Some kids cannot pronounce all letters, some of them they sometimes pronounce correctly and
sometimes incorrectly. Kamil sometimes says T instead of K, but he never says K instead of T.
Similarly he sometimes says D instead of G. Instead of R he sometimes says L and sometimes F. Of
course it happens that he pronounces the letter correctly. Kamils father always thinks how many
words can mean the word spoken by his son (it doesnt matter if they are real English words).
Task
Write a program which
reads from standard input the words spoken by Kamil
counts how many different words can that mean
writes the outcome on standard output
Input
Ten test cases (given one under another, you have to process all!). Every test case is a single line - a
word spoken by Kamil. Only 26 capital leters are used. The length of the word is at most 20.
Output
For every testcase write an integer in a single line with a single integer, denoting the number of words
which Kamils word can mean.
Score
The score awarded to your program is the number of bytes the source code you submit. The fewer
points you score, the better. Submissions are not allowed to exceed 256 bytes.
Remark. It may turn out impossible to solve this problem in some languages.
Example
Input:
FILIPEK
[and 9 test cases more]
Output:
4
[and 9 test cases more]
Added by: Adam Dzedzej

Date:
2004-06-08
Time limit: 3s
Source limit:256B
Languages: All except: TECS
Resource: Internet Contest Pogromcy Algorytmow (Algorithm Tamers) Round I, 2003
SPOJ Problem Set (main)
72. Food Shortage in Byteland

Problem code: BYTEFOOD
Fanatics from the BBFO blew up all the food factories in the Bytelandian capital! Hurry up! There is
still some food left in shops. Some shops are located in the centre, others in the suburbs, so Johnny has
to decide which of them are worth visiting. Some shops can be very big and have plenty of food in
them, others may be so small that food dissappears from them at an alarming rate... So? Help Johnny
buy as much food as possible.
There are n open shops, each of them located at position (x i ,y i ), for i=1,...,n, where 0 <= x i ,y i <= 250.
The distances between shops are measured using the Manhattan metric (i.e. as sums of absolute values
of differences of x and y coordinates). Besides, every shop is characterized by a linear time function
describing how much food is left in the shop at the moment:
f i = max{0, a i - b i * time}
where 0 <= a i <= 1000000, 0 <= b i <= 1000, while time is the time (in minutes) that has elapsed from
the moment Johnny left the house (assume that Johnny does not live in the same place as any shop). If
Johnny decides to stay in a shop, he can buy at most b i units of food per minute. Otherwise, he can
move along the ortogonal system of streets of the city at a constant speed of unit distance per minute.
Johnny only ever changes the action he is performing at the full minute. Because his family is slowly
beginning to starve, he should be back at home not later than m minutes after he left. Since there are
thousands of starving families in the capital, Johnny cant spent more that 1 <= c i <= 10 minutes in a
shop. Moreover, he will never go into the same shop twice for fear of being lynched...
Input
The first line of input contains a single positive integer t <= 1000, the number of test cases. Each test
case begins with the number of shops in the city 1 <= n <= 1000 and the deadline 1 <= m <= 5000.
Then the following n lines consist of four integers x i y i a i b i c i each, describing the position and the
parameters of the function for food availability of the i-th shop. At the end of every test case comes a
line with two integersp q (between 0 and 250), corresponding to the x and y coordinates of the position
of Johnnys house.
All the input data are integers.
Output
Process all test cases. The correct output for the i-th test case takes the following form:
i [the number of the test case, in the input order]
s m [s is the number of the target shop and m > 0 is the number of minutes spent in it].
At the end of the series of moves you should always write a line conisting of two zeros (0 0).
All the output data should be integers.
Scoring
The score of your program is the total amount of food that Johnny bought (summed over all the
testcases in which he managed to come back home before the deadline).
Example
Input
4
2 20
0 0 100 5 5
10 0 200 10 10
5 0
2 20
0 0 180 15 10
10 0 200 20 10
5 0
4 101
0 0 1000 20 5
20 0 200 1 5
0 20 5000 200 5
20 20 300 5 10
10 10
1 15
1 0 10 1 5
5 0
Output
1
2 10
0 0
2
1 10
0 0
3
3 5
4 10
2 1
0 0
4
1 5
0 0
Score
Score = 1261
Added by: Micha Maafiejski

Date:
2004-06-09
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
126. Solovay-Strassen Inverted

Problem code: SOLSTRAS
Let us denote the set of all prime numbers by the symbol P. The Solovay-Strassen algorithm
determines whether a given positive odd integer n>2 belongs to P.
The Legendre function sig for number nin N with parameter sin N (s<n) is defined by the formula
sig(n,s)=s (n-1)/2 mod n. The symbol mod is defined in such a way as to return the result with the
smallest possible absolute value, from the range (-n/2, n/2].
The Jacobi function jac for number nin N with parameter sin N (s<n) is given as:
sig(n,s),
if nin P
k
k
jac(n,s)=cases
sig(p
,s),
product
if n= productp i ,where all p i in P
i
i=1
i=1
It is interesting to note that for given n and s, the values of sig(n,s) and jac(n,s) can be computed in
O((log 2 n) 2 ) time. For particulars consult an encyclopedia, such as MathWorld.
The deterministic version of the Solovay-Strassen primality-test algorithm is given below.
algorithm Solovay-Strassen (n)
var s;
begin
for s in {1,2,3,4,...,n} do
if sig(n,s)neq jac(n,s)
then return "n is composite (detected at attempt <s>)";
return "n is prime";
end.
Task
We are not asking you to implement the Solovay-Strassen algorithm, this would be far too easy :).
Instead, try to find values of n, for which the output of the algorithm would be "n is composite
(detected at attempt 1)", "n is composite (detected at attempt 2)", and so on. Write out as many of these
values as you can in consecutive lines, and try to keep them as small as possible.
Scoring
The score awarded to your program is the total of all points given for its individual lines.
The i-th line output by your program should contain exactly one positive odd integer n>2 of no more
than 500 decimal digits. If Solovay-Strassen(n) yields the answer "n is composite (detected at attempt
i)", you will receive i/log 10 n points for this line, if not - your program will be considered incorrect.
Output 0 if you dont want a line to be assessed. Only the first 1000 lines of output are taken into
account.
Example
A program outputing:
0
0
561
will receive 3/log 10 561 = 1.091 points.

Added by: Konrad Piwakowski
Date:
2004-07-10
Time limit: 3s
Source limit:50000B
Languages: All
Resource: Thanks to Daniel Grzonkowski for valuable comments
127. Johnny Goes Shopping

Problem code: JOHNNY
Johnny visited his favourite supermarket to purchase as many sweets as he could afford. Since daddy
had left his credit card at home untended, this was not really a problem. Once he had (barely) managed
to push the trolley laden with chocolate bars past the cash desk, he began to wonder how to carry all
the shopping home without breaking his back.
You must know that Johnny is a perfectly normal child, and has exactly 2 hands. Help him distribute
his load between both hands so as to minimise the difference in load between both hands.
Input
The first line of input contains a single integer n<= 10000 denoting the number of sweet packets
Johnny has bought. In each of the next n lines a single positive integer is given, describing the weight
of the respective packet (the weight is an integer value never exceeding 10 14 ).
Output
In separate lines, output the numbers of the packets which Johnny should carry in his left hand.
Assume packets are numbered in the input order from 1 to n.
Scoring
Your program shall receive log 10 (s/(|d|+1)) points, where s is the total weight of all parcels, while d
denotes the difference in weight between the load carried in Johnnys left and right hand.
Example
For the sample input:
3
5
8
4
a program outputting:
2
3
will score log 10 ((5+8+4)/(|8+4-5|+1))= 0.327 points.
Added by: Adrian Kosowski

Date:
2004-07-10
Time limit: 5s
Source limit:50000B
Languages: All
155. Solving the Puzzle

Problem code: SOLVING
The 15 puzzle is a classic puzzle made famous in the 19th century. It consists of 4x4 board with 15
sliding tiles numbered from 1 to 15. The objective is to get them into this pattern:
1
10
11
12
13
14
15
Here we will deal with a generalized version of the above puzzle. You should write a program that
given some initial state of the nxn board finds a sequence of moves that transforms it so that in the i-th
row there are tiles with numbers i*n+1,i*n+2,...,i*n+n (from left to right) - with the exception of the
lower right corner where the hole should be. The less moves you use, the more points you get.
Input
The first line of input contains the number of test cases c (c<=200). Then c test cases follow, each of
them begins with a line with a single integer n (3<=n<=10) in it. The next n lines describe the initial
state of the board - the i-th line consists of exactly n integers describing the i-th row. The position of
the hole is indicated by 0.
Output
For each test case output one line - the found sequence of moves. Write D to move the hole down,
U to move it up, R to move it right and L to move it left. You shouldnt use more than 10000
moves. All moves should be valid (so for example dont try to move the hole up when it is in the first
row).
Scoring
Your program will receive n^3/(m+1) points for each test case where m is the number of moves.
Example
Input:
2
4
1
5
9
2 7
6 0
10 11
3
4
8
13 14 15
12
3
0 1 2
4 5 3
7 8 6
Output:
URDDD
RRDD
Added by: Pawel Gawrychowski

Date:
2004-07-27
Time limit: 2s
Source limit:10000B
Languages: All
218. Points on a Sphere

Problem code: PSPHERE
Imagine a number of identically charged weightless dimensionless particles placed on the surface of a
ball. They will instantly reach a state of equilibrium (a stable state of minimum energy), becoming
distributed fairly evenly all round the sphere.
You probably wont be surprised to hear that Byteland has a sadly distorted electrostatic field, and the
energy of the system is not governed by ordinary laws. Instead, it is inversely proportional to the
distance between the closest pair of charges on the sphere.
Please help the charges find positions in which they will feel as comfortable as possible. Charges
should be regarded as points in 3D space, located on the surface of the unitary sphere (with center
(0,0,0) and a radius of 1).
Input
An integer t denoting the number of test cases (t<=10), followed by t test cases, each consisting of a
line with a single integer n - the number of points on the sphere (2<=n<=1000).
Output
For each test case, output n lines consisting of three floating point numbers, corresponding to the x y z
coordinates of successive points.
Scoring
The score of your program is the total of scores awarded for individual test cases.
For each test case you will receive n*d points, where d denotes the minimum distance between the
closest pair of points in the solution output by your program. If you place some of the points further
than 10 -5 from the surface of the sphere, your solution will be regarded as incorrect.
Example
1
2
0.0 0.0 1.0
0.0 1.0 0.0
will receive 2.828 points.

Date:
2004-10-09
Time limit: 5s
Source limit:50000B
Languages: All
Resource: DASM Programming League 2004 (problemset 1)
219. Pawns Gone Wild

Problem code: PAWNS
Imagine a game played on an n x n chessboard by two players sitting at opposite ends, one having n
white pawns, the other - n black pawns. Pawns are arranged in the row closest to the player. Moves are
made in turn by both players and resemble those in chess: in a single move, a player can move exactly
one pawn, either a square forward (if the square it is moving onto is free), or on the bias, one square
forward and one square to the left or right (if the square it is moving onto is occupied by an enemys
pawn, which is considered beaten and removed from the game).
[IMAGE]
Pawns may never be moved backwards or off the board, and if a pawn reaches the final line it just has
to stay there. The game ends if a player cant make a move. The winner is then the player who... oh, it
doesnt matter really (possibly the players have a fight with beer bottles, and the one who isnt
knocked out, wins). Your task is different - seeing snapshots of a game at two moments of time, try to
reenact a sequence of moves that may have led from the first situation to the second.
Input
The first line of input contains a single positive integer t<=25, the number of test cases. t test cases (of
successively increasing size) follow.
Each test case begins with an integer n (2<=n<=26) denoting the size of the board. Then, the snapshot
of the earlier situation is given, followed by a snapshot of the later situation. Each snapshot is a
sequence of n lines of n characters, corresponding to the squares of a chessboard oriented as in the
figure above. Character . - denotes an empty square, W - a square with a white pawn, B - a square
with a black pawn. Assume that it is blacks turn to move after the earlier position (though black
neednt have necessarily started the game as such).
Output
For each test case, output the number k of moves which could have led from the first to the second
position (output 0 if you dont know a solution, even though such a solution exists for certain). In the
next k lines, print the determined sequence of moves. Each move should be given in a seperate line,
using the format: old_column old_row new_column to describe the change of coordinates of
a pawn (assume board orientation as in the exemplary figures).
Scoring
The score of your program is the total of scores awarded for individual test cases. For each test case
for which you find a solution in k moves you will receive k points.
Example
1
6
....W.
.WWW.W
B.B...
......
......
B..BBB
......
.BWW..
.....W
......
.....B
B..BB.
5
A
F
C
E
F
3
2
3
1
6
B
F
D
D
F
will receive 5 points.

Date:
2004-10-10
Time limit: 21s
Source limit:50000B
Languages: All
Resource: DASM Programming League 2004 (problemset 1)
222. The Burning City

Problem code: BURNCITY
Terrorists from the BBFO have raised fires in the capital of Byteland! As is it is a hot summer day,
most of the fire brigade have quite naturally taken a day off, and so the noble task of extinguishing all
the fires falls to the only officer on duty. By now you will probably not be surprised to learn that he is
in fact... Johnny. This enterprising youth remains undaunted by the challenge facing him, and, taking
advantage of the absence of his superiors, he decides to use his favourite fire fighting technique. So, he
loads the fire stations helicopter with as many dynamite charges as it can carry, and takes off on his
errand of mercy.
From up there in the sky Johnny can see the city as a square, sliced into smaller, identical squares by a
regular grid of streets. Every square contains one of three kinds of terrain - buildings, grassland or
water (perhaps most firemen would go into further detail when analysing terrain, but you really cant
expect that from a firefighter whose preferred method of extinguishing fires is dynamite, can you?).
Johnny starts out in the centre of the square corresponding to the fire station. In the time from the start
of a minute to the end of that minute he can move to the center of one of the four adjacent squares (but
he is not allowed to leave the city). While over the center of a square he can choose to drop a single
dynamite charge on it. He starts preparing the charge at the beginning of a minute, and it is dropped
from the helicopter at the end of the same minute. Everything on the square on which the bomb was
dropped is blown apart, and in its place a crater is formed and instantly flooded by subterranean
waters.
The fire spreads in a most predictable way: if a square starts burning at the beginning of minute m,
then all four adjacent squares will catch fire at the start of minute (m+2). The only exception is a
square filled with water (either naturally, or by Johnnys bombs) which never catches fire. If a square
starts burning, all property on it is instantly destroyed. Once a square starts burning it will only stop
burning if Johnny blows it up, or when the monsoon rain comes and floods the city, at the end of the
h-th minute of firefighting.
Johnnys main objective is to save as many squares with buildings as possible (from fire and
dynamite).
An example of the fire fighting process is presented below.
An example of the fire fighting process
Input
The first line of input contains a single integer t<=500, the number of test cases.
The first line of every test case contains five integers n c h s x s y , respectively denoting: n - the length
of one side of the city (measured in squares), c - the number of dynamite charges Johnny can use, h the number of minutes after which the rain falls, s x , s y - the x and y coordinates of the square
containing the fire-station from which Johnny starts, measured relative to the North-West corner of the
city (1<=s x , s y <=n<=50, 0<=c<=h<=5*n; there are about 10 test cases for all possible values of n).
Finally, the map of the city is given in the form of n lines of n characters each, each corresponding to
the state of a square at the start of the fire fighting (b - building, g - grassland, w - water, f fire).
Output
For the i-th test case output a line containing the text city i Y if you want to solve the test case or
city i N if you wish to leave it out.
If you chose to the solve the test case, in the next line output a sequence of exactly h characters N,
S, W, E, + or -, corresponding to Johnnys actions in successive minutes (moving North,
South, West and East on the map, dropping dynamite, not doing anything, respectively).
Score
The total score is the total number of rescued squares with buildings taken over all test cases.
Example
Input:
5
3 2 9 1 1
bgg
bbg
bbf
4 2 8 3 1
bbbb
bgwg
fwgg
gbbb
4 3 15 2 1
bbbb
bbbb
bbbb
fbbb
4 3 15 2 1
bbbf
bbbb
bbbb
fbbb
4 3 15 2 1
bbbf
bbbb
bbbb
fbbb
Output:
city 1 Y
S+E---N+city 2 Y
W+SSS+-city 3 Y
ESE+SW+S+-----city 4 Y
+EES+W+-------city 5 Y
+ES+-E+-------Score:
9
(The first test case is illustrated in the figure and Johnny can save one building. In testcases 2, 3, 4, 5
Johnny saves 4, 2, 2 and 0 buildings, respectively).
Bonus info: The three digit number after the decimal point of your score denotes the number of test
cases you have solved correctly, rescuing at least one building.
Warning: large Input/Output data, be careful with certain languages
Date:
2004-10-11
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
225. Nightmare in the Towers of Hanoi

Problem code: HANOI
Consider the folowing variation of the well know problem Towers of Hanoi:
We are given n towers and m disks of sizes 1,2,3,...,m stacked on some towers. Your objective is to
transfer all the disks to the k-th tower in as few moves as you can manage, but taking into account the
following rules:
moving only one disk at a time,
never moving a larger disk one onto a smaller one,
moving only between towers at distance at most d.
You can assume that all the problems can be solved in not more than 20000 moves.
Input
The first line of input contains a single positive integer t <= 1000, the number of test cases.
Each tests case begins with the number of towers 3 <= n <= 100, the number of target tower 1 <= k <=
n, the number of disks m <= 100 and the maximum distance 1 <= d <= n - 1.
Then, the following m lines consists of pairs of numbers describing the initial situation, in the form:
the tower and disk on it. Assume according to the rules that on every tower smaller disks are on larger
disks.
Output
Process all test cases. The correct output for the i-th test case takes the following form:
i [the number of the test case (in input order)]
a b [a sequence of lines of this form, where a is the tower with the moved disk on top of it and b is the
target tower].
The test case is considered solved if after performing the sequence all disks are on the k-th tower. At
the end of the series of moves you should always write a line consisting of two zeros (0 0).
Scoring
The score awarded to your program is the sum of scores for individual test cases. For the i-th test case
you will receive T i / ( T i + A i ) points, where T i <= 20000 and A i is the number of moves in your
solution. If you dont want to solve a test case, you may output the line 0 0 without a list of moves,
for which you will not be awarded any points. Your program may not write more than 30000 kB to
output (this will result in SIGXFSZ).
Example
Input
5
3 3 3
1 1
1 2
1 3
3 1 3
1 1
1 2
1 3
4 4 4
1 1
1 2
1 3
1 4
4 4 4
1 1
1 2
2 4
4 3
4 4 4
1 1
4 2
4 3
4 4
Output
1
1 3
1 2
3 2
1 3
2 1
2 3
1 3
0 0
2
0 0
3
0 0
4
4 3
2 4
3 4
1 2
1 3
3 4
2 4
0 0
5
1 2
0 0
Score
Assuming: T = {7,6,15,7,1} the output will receive 2 points.
Bonus info: If score = xxx.xxxaaa, aaa means the number of test cases with non-zero score...
Date:
2004-10-27
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
232. Bytelandian Telecom

Problem code: BYTELE
King Johnny has a serious drink problem, which has recently become the focus of attention of all
Bytelandian tabloids and colour magazines. In a desperate effort to divert the publics attention and
ingratiate himself with his subjects, he decides to start giving out valuable gifts. This time he has
chosen to harass the peaceful life of the CEO of Bytelandian Telecom, and requested him to create a
Metropolitan Area Network for the citizens of the capital of Byteland, as part of an "our King is a
good man" campaign.
The CEO has no choice but to obey the orders he receives. This rational and business-minded man
would obviously like to perform the installation at the smallest possible cost, and he asks you for your
help.
The King has stated the topology of the network plainly enough in the form of a graph (not necessarily
connected), with vertices corresponding to nodes (computers), and edges to the cable connections
between them. It is now your task to select the points of the city to place the nodes of the network at.
The city is a regular mesh of streets (depicted as vertical and horizontal segments on a map), with
crossroads located at points with integer coordinates. Nodes may only be located at crossroads of
streets (no two nodes at the same crossroad). Cables may only run along streets and must connect
nodes by the shortest possible route under this constraint. Moreover, a cable of precisely such length
must be currently in stock (you are provided with a list of possible cable lengths). Try to layout the
network in such a way as to minimise the total length of cable used.
Input
The input starts with a line containing integer t <= 1000, the number of test cases. t test cases follow.
The first line of a test cases begins with integer k, denoting the number of different available cable
lengths, followed by k space separated integers p j corresponding to the allowed lengths of cables (1
<= k <= 100, 1 <= p j <= 100). The next line contains two integers n m, denoting the required number
of nodes and cables in the network, respectively (1 <= n <= 100, 1 <= m <= 1000). The next m lines
contain a pair of integers a j b j each, signifying that nodes a j and b j should be connected by a cable (1
<= a j ,b j <= n).
Output
A valid solution to the i-th test case consists of a line with the text city i Y, followed by n i lines
each containing two integers, the x- and y-coordinates of successive nodes in the solution (0 <= x,y <=
100).
It is guaranteed that for every test case there exists at least one possible solution. You can however
leave out a test case by outputting the line city i N instead of a valid solution.
Score
For each correctly solved test case you are awarded (m/sum) * ((p 1 +p 2 +...+p k )/k) points, where sum
is the total length of all cables used.
The score awarded to your program is the sum of scores for individual test cases.
Example
Input:
4
2 1 2
4 5
1 2
2 3
3 4
1 4
2 4
1 2
4 5
1 2
2 3
3 4
1 4
2 4
2 1 2
5 8
1 2
1 3
1 4
1 5
2 4
2 5
3 4
3 5
1 1
2 1
1 2
Output:
city 1 Y
0 0
0 1
1 1
1 0
city 2 Y
2 0
1 1
0 2
0 0
city 3 Y
0 1
0 2
1 1
1 2
0 0
city 4 N
Score:
score = 3.340003
Bonus info: If score = xxx.xxxaaa, aaa means the number of test cases with non-zero score...
Date:
2004-11-14
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
240. Santa Claus and the Presents

Problem code: SANTA
Every year Santa Claus faces a more and more difficult task. The number of children in the world is
increasing rapidly, while Santas old patched up sack can only accommodate a few presents at a time.
And every child wants their own very special present... This means that, ever so often, once his sack is
partially or completely empty, Santa has to fly back to his base in Lapland to replenish his supplies. So
irksome has this become that Santa has decided to resort to modern operational research to aid him in
his sack-packing and route planning. Please write a program which will guide Santa through his daily
chores.
Input
The input starts with a line containing a single integer t<=100, the number of test cases. t test cases
follow.
The first line of every test case consists of four integers n x y S, denoting the number of good children
who will receive a present from Santa, the x and y coordinates of Santas home base, and the amount
of space in the sack, respectively (1<=n<=10000, -10000<=x,y<=10000, 1<=S<=100000). n lines
follow, each consisting of three integers x i y i s i - the x and y coordinates of the i-th childs home, and
the amount of space taken up by this childs present when in Santas sack, respectively
(-10000<=x i ,y i <=10000, 1<=s i <=S).
Output
For each test case output a sequence of space separated integers, corresponding to successive actions
that should be taken by Santa:
-i (1<=i<=n) signifies that Santa should travel to his base and pack the present for the i-th child
into his sack (he needs to have sufficient room in his sack to do this).
i (1<=i<=n) signifies that Santa should travel to the i-th childs home and leave a present for
him/her.
0 signifies that Santa should travel back to his base and end his Christmas activity (and that you
want to proceed to the next test case).
Assume that Santa starts in his base and always travels between points by the shortest possible route
(along straight lines). All distances are measured using the Euclidean metric.
Score
The score awarded to your program is the total of all scores obtained for its individual test cases. The
score for a test case is calculated as I/P, where P stands for the distance covered by Santa in your
solution, while I is a test case specific constant (I= n*d+D*(s 1 +...+s n )/S; d is the mean distance
between two homes, while D is the mean distance between Santas base and a childs home for the
given test case).
No points are awarded for incompletely solved test cases (when not all the children receive presents).
Any other violation of transport rules results in Wrong Answer.
Example
Input:
1
3 0 0 3
1 0 1
1 0 2
1 0 3
Output:
-1 -2 1 2 -3 3 0
Score:
2/(1+1+1+1)= 0.5
Added by: Krzysztof Kluczek

Date:
2004-12-09
Time limit: 17s
Source limit:50000B
Languages: All
Resource: DASM Programming League 2004, problemset 4
246. Plant a Christmas Tree

Problem code: CTQUINE
Evergreen trees are really wonderful. They were treasured by all civilisations of the Western world,
from ancient Egiptian priests to Celtic druids in the British Isles. In the late Middle Ages a tradition of
placing an evergreen tree at home for Christmas developed in Germany and spread throughout the Old
and New World, reaching the Asia Pacific and America in the XIX-th century.
Surely, you must have noticed the sad fact that nowadays this global custom, however beautiful it may
be, results in the death of millions of coniferous trees worldwide. Help us in our effort to restore the
healthy balance. In the Christmas period, draw & plant your own tiny fir tree!
Since we are limited to text mode, there is little room for creative art, and solid, well built trees are
definitely favoured. An ideal tree consists of several lines (at least 1) of the same length, consisiting of
ASCII characters -- both whitespace ("spaces"), and non-whitespace ("relevant characters"). Counting
from the top, the number of characters between the first and last relevant characters in a line
(inclusive) is equal to 1, 1, 3, 1, 3, 5, 1, 3, 5, 7, 1, 3,... for consecutive lines. The line for which this
distance is the largest begins and ends with relevant characters. All other lines contain exactly the
same number of spaces to the left of the leftmost relevant character and to the right of the rightmost
relevant character (this gives the ideal tree a nice, vertical trunk).
Please write a program which outputs a tree as close to an ideal tree as you can get, and keeps it as
small as possible (such a tree has the largest chance of sprouting roots when planted). And it can
hardly come as a surprise to you to learn that the source code of the program you submit has to be
identical to the text it writes to output (character by character, there are no exceptions)!
Score
Your program will be judged as follows: if the program is not a quine (i.e. if it contains no relevant
characters or outputs text different than its own source code) it will be judged as a Wrong Answer.
Any other program will receive some number of penalty points depending on its size and quality as a
tree (the fewer points, the better). One penalty point is given for every line of code used. 10 penalty
points are given for a line without any relevant characters (how can you expect a broken tree to
grow?). For non-empty lines, the position of the leftmost and rightmost relevant characters in the
analyzed tree are compared with respect to corresponding positions in an ideal tree with the same
number of lines. The squared differences in position between these two pairs of characters are added to
the penalty score.
Technical note: a single newline character (ASCII 10) should be used to terminate all lines. ASCII
characters 32 (space) and 9 (tab) are treated as single spaces, all other characters are considered
relevant. Notice that the problem description doesnt penalise for left out or excessive spaces after the
last relevant character of a line (but doesnt allow any difference between the source code and output
text in this respect).
Example
C source code:
;
;
;;;
;
main(
) {;
;
; ;
/* */
;return
0
;;}
This code would be judged as Wrong Answer, since it isnt a valid quine. Were it a quine, it would
receive 16 penalty points (12 for 12 lines, 4=2 2 additional penalty points for a misplaced rightmost
relevant character in line 5).
Solutions to this problem may only be submitted in the following languages: C, C++, Pascal,
Java, C#, Python, Haskell, OCaml, Brainf**k, Intercal.
Date:
2004-12-16
Time limit: 17s
Source
30000B
limit:
All except: ADA ASM BASH CLPS LISP clisp LISP sbcl D FORT ICON JAR LUA
Languages:
NEM NICE PAS gpc PERL PHP PIKE PRLG RUBY SCM qobi ST WSPC
270. Digits of Pi
Problem code: PIVAL
In this problem you have to find as many digits of PI as possible.
Output
Output must contain as many digits of PI as possible (not more than 1000000).
Score
The score awarded to your program will be the first position of the digit where the first difference
occured.
Example
Output:
3.1415926535897932384626433832795
will be awarded with 33 points.

Added by: Roman Sol
Date:
2004-12-27
Time limit: 25s
Source limit:4096B
Languages: All except: LISP sbcl LISP clisp CLPS
Resource: ZCon 2005
SPOJ Problem Set (set6)
276. Herdkeeper
Problem code: MFENCE
After the tragic end of the watermelon plantation, Johnny has switched to farming. More precisely, he
is now a Certified Livestock Supervisor (i.e. shepherd) tending herds of antelope. It is his task to
divide the animals into herds, and to build a fence around each herd, trying to keep the total length of
all fences as small as possible. Each herd must consist of at least 2 antelope, and the antelope may
stand arbitrarily close to the fence itself.
Input
t [the number of test cases <= 1000]
n [2 <= the number of antelope <= 100]
x 1 y 1 [coordinates of the antelope, between -1000 and 1000]
x2 y2
.....
xn yn
[next test cases]
Output
case i Y [N - if you want to skip the testcase]
c [the number of herds]
a s 1 s 2 ... s a [2 <= a - the number of antelope in the first herd, and the numbers of the antelope in this
herd in the order from the input sequence]
[next test cases]
Scoring
you will receive 1 / ( 1 + sum / conv) points, where sum is the sum of circumferences of all convex
hulls of herds in your solution, and the conv is the circumference of the convex hull of the set of all
antelope. If you dont want to solve the i-th test case, you may output the line case i N and nothing
else.
Example
Input:
6
2
0 0
5 0
3
4 0
-4 -5
2 3
5
20 10
10 10
40 50
-20 -40
-30 -20
4
2 4
2 -4
2 0
-5 -3
3
2 4
-4 -4
2 3
4
-1 -3
-1 5
3 -5
-1 5
Output:
case 1 Y
1
2 1 2
case 2 Y
1
3 1 2 3
case 3 Y
2
3 1 2 3
2 4 5
case 4 Y
2
2 1 4
2 2 3
case 5 Y
1
3 1 2 3
case 6 Y
1
4 1 2 3 4
Score:
3.079001
Bonus info: If score = xxx.xxxaaa, aaa means the number of test cases with score > 0.5
Date:
2005-01-07
Time limit: 17s
Source limit:50000B
Languages: All except: C99 strict
Resource: -
285. Atomic Shelters

Problem code: ATSHELT
The election campaign of the mayor of Byteland continues. His advisors firmly believe that a military
touch might do good to his image. On the other hand, aggressive use of arms might arouse the insane
anger of the pacifist part of the electorate. So, investing in national defence seems to be the best
solution. And this is why the capital of Byteland will receive its first ever atomic shelters.
The Bytelandian capital consists of exactly n buildings and the mayor intends to build shelters
underneath exactly k of them. Now it is your task to layout the shelters in the city in such a way as to
minimise the maximum distance a citizen of Byteland may have to cover to reach the nearest atomic
shelter. After all, there is nothing more important than a mayor who guarantees your safety by putting
an atomic shelter not far from your house.
Input
t [the number of test cases <= 1000]
n k [2 <= the number of different buildings <= 100, 1 <= the number of shelters <= n-1]
x 1 y 1 [-1000 <= coordinates <= 1000]
x2 y2
.....
xn yn
[next test cases]
Output
case i Y [N if you wish to skip this test case]
b 1 b 2 ... b k [numbers of buildings to put shelters in, in increasing input order]
[next test cases]
Scoring
you will receive diam / dist points, where diam is the distance between the furthest two buildings of
the city, while dist is the longest distance from a building to the nearest shelter in your solution. If you
dont want to solve the i-th test case, you may output the line case i N and nothing else.
Example
Input:
5
5 2
-3 -4
-4 3
2 -3
-2 -3
-5 5
5 4
2 0
-5 -4
1 -1
-1 0
5 -5
5 2
-3 0
5 -2
-1 -5
2 4
4 5
5 3
5 0
-1 -5
3 2
-5 1
-1 3
5 4
-1 2
1 1
5 4
0 5
-2 2
Output:
case 1 Y
3 4
case 2 Y
1 3 4 5
case 3 Y
4 5
case 4 Y
1 2 3
case 5 N
Score:
5.592004
Bonus info: If score = xxx.xxxaaa, aaa means the number of test cases with Y answer.
Date:
2005-01-21
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
289. The Turing Music Box

Problem code: TMBOX
If youve ever dealt with the theory of information, you are no doubt familiar with the theoretical
notion of a Turing Machine. But have you ever wondered what you could do if you got a real Turing
Machine -- one of those big metal things with all the cranks and levers and rolls of infinite tape that
looks suspiciously like toilet paper?...
The sad answer is: there are few interesting things that can be done with such a machine. Even
problems that have a little charm in the theoretical model (like the intractable Halting Problem) can be
solved very efficiently with practical brute-force algorithms (see e.g. the figure at the end of the
problem description). But there is one thing that you can do with a practical Turing Machine, and cant
do with a theoretical one, and it is: to use it as a music box.
Our Turing Machine has exactly one state variable (an integer in the range 0 to 999) and is equipped
with an infinite tape, consisting of cells with symbols from a given alphabet encoded on them. A
movable read/write head is positioned over some cell of the tape, and is operated according to the list
of rules encoded in the machine. The rules are of the form S1 C1 S2 C2 M, which means: if the
machine is in state S1 and C1 is written in the current cell, change state to S2, write C2 in the current
cell, and move the head as described by move M (one cell left, one cell right, or not at all). If no
matching rule is found for the given state the machine should halt.
Now, here is the good bit. The head makes a creaking sound when performing each rule. It goes da
when moved right, di when moved left, and um when left in place. Suppose that each cell of the tape
can contain one of 16 possible symbols, formed as the concatenation of exactly two of the words: da,
di, um and sh for silence. Initially, nearly all the cells of the tape are filled with the symbol shsh.
Only a few (not more than 500) consecutive cells form a piece of music, each cell encoding a pair of
sounds (one of 9 combinations of da, di or um, without any silences). The head of the machine is
initially positioned over the leftmost of the cells containing sounds.
Now it is your task to use the Turing machine to play the piece of music written on its tape (as read
from left to right, starting from the initial position of the head, as far as the first silence) as accurately
as possible, using the head itself to produce the sounds required.
Output
The output of your program must contain a set of rules describing the behaviour of the Turing
Machine designed for playing music. Each rule must be of the form S1 C1 S2 C2 M, where S1 and
S2 are integers from the range 0..999, C1 and C2 belong to the 16 symbols of the alphabet, while M
describes the move direction of the head by the sound it makes (da, di or um).
Score
Your program will be tested multiple times for different pieces of music written on the tape. The score
of your program is equal to the total of non-negative scores, taken over all test cases.
For a test case with n notes (n/2 non-silent cells) your program will receive n-d points, where d
denotes the edit distance between the music played and the music required (i.e. the minimum total
number of notes that have to be inserted into or changed in both the pieces to obtain the same piece of
music).
Example
Consider the following set of rules output by a program:
000
000
000
000
001
dada
umda
shsh
didi
dada
000
000
000
001
002
dada
dada
shsh
didi
didi
da
da
da
di
di
Then the results of exemplary testing could be as follows:

Music: da da|da da|da da|di di|um um
Plays: da da da di di
Score: 5
Music: um da|um da|um da|da um|di di
Plays: da da da
Score: 3
Total: 5 + 3 = 8 points
Bonus info: There are no more than 100 tests. The score format is s.xxyy, where xx denotes the number
of tests for which your machine played the music perfectly, yy - the number of tests for which it
received a positive score.
While this machine halts, it loops. We just help it in its agony.
Date:
2005-01-26
Time limit: 17s
Source limit:50000B
Languages: All
294. Johnny and the Optimisation of Homework

Problem code: HWORK
One day when Johnny was still a schoolboy he got caught red-handed by his teacher while doing a
Very Mischievous Thing (of the sort that you would expect of Johnny). As a punishment he was told
off and assigned additional homework. The teacher underlined quite a few words in a dictionary and
asked Johnny to rewrite all of them to his notebook.
Johnny wasnt at all pleased about this, since writing by hand is always a painful burden. Fortunately,
Johnnys dad took pity on the crying boy and offered to help. He presented his son with a few sheets
of carbon paper, thanks to which any text Johnny wrote was at once ready in exactly k copies. Some of
the characters of particular copies could then be erased using a white correction pen, so as to obtain
only the words required by the teacher. All the characters forming a single word have to be directly
adjacent, but words can be written in any order on the sheets and different words can be separated by
an arbitrary (possibly 0) amount of space.
Johnny has cheered up considerably by now, since the bit with the carbon paper and correction pen
sounds rather fun. All that remains to be done is to write down an appropriate text, obviously keeping
it as short as possible. Please advise Johnny what to write.
Input
Input begins with a single integer t (t=1000). t test cases follow.
Each test case starts with a line containing two integers n k, respectively denoting the number of words
the teacher has asked Johnny to write and the total number of carbon copies that Johnny creates,
including the original (1<=k<=n<=512). Each of the next n lines contains a word assigned by the
teacher - a string of between 4 and 12 characters a, b, c or d. All words given at input are
Bytelandian nouns in common use.
Output
For the i-th test case output a line with the text case i Y or case i N, specifying whether you
wish to solve the given case. Then in the former case print a single line containing the text that should
be written by Johnny. Exactly n lines with a single integer on each should follow, the i-th representing
the position of the first letter of the i-th word (on the page on which this word eventually appears,
before applying the correction pen).
Scoring
The score awarded to your program is the sum of scores taken over all test cases you chose to solve.
For each test case, the score is the difference between the total number of characters of the words
provided by the teacher and the number of characters of the text eventually handwritten by Johnny.
Programs which receive a negative score for some test case will be considered incorrect.
Example
Input:
1
4 2
aaaa
aaaa
aaaa
bbaaa
Output:
case 1 Y
aaaabbaaaa
1
1
7
5
Score:
17 - 10 = 7
When given in to the teacher, the 2 pages of homework may look as follows:
aaaa__aaaa
aaaabbaaa_

Date:
2005-02-11
Time limit: 17s
Source limit:50000B
Resource: -
295. Bytelandian Origami

Problem code: BRIGAMI
Many of Johnnys school friends have perfected the art of folding a square sheet of paper into
beautiful shapes (known as origami). Johnny attempted to follow suit, but to his dismay he found that
his fingers were a little to clumsy for the task in hand. After spending yet another day creating
something especially disastrous (later named "From the series: Crumpled Pieces of Paper Seen with an
Artists Eye, No. 27"), Johnny decided hed had enough. Therefore he proudly proclaimed to all his
friends that origami was not fit for serious people, and that he intended to become the master of
kirigami, the art of cutting paper. But after experimenting with kirigami for a few weeks, he sold the
rather miserable results of his labour to the local confetti store, and announced that true beauty lay in
convex polygons, and that they were the only shapes a true artist should ever cut. Still, if a person is as
lazy and inapt as Johnny, even such a seemingly simple task may turn out a real challenge.
The method Johnny uses to create works of art consists of several steps. First, he takes a sheet of paper
in the shape of a convex polygon and uses a ruler and pencil to draw a convex polygon (lying entirely
within the sheet). Then, he proceeds to cut it out using a ruler and a razor-edged paper cutter. Every
cut is thus a segment of a line, reaching from one edge of the sheet of paper to another, and adjacent to
one side of the drawn polygon. Johnny then discards the cut off corner of the sheet and continues
cutting until the shape outlined in pencil is completely cut out. Since he is extremely disinclined to
perform hard work, please write a program to help him minimise the total length of the lines along
which the paper is cut.
Input
Input begins with a single integer t (t=200). t test cases follow.
Each test case starts with a line containing two integers m n, denoting the number of vertices of the
sheet of paper and the shape drawn on it, respectively (3<=m,n<=600). The next m lines contain two
integers a i b i each (-20000<=a i , b i <=20000), corresponding to the x and y coordinates of vertices
of the sheet of paper (given in clockwise order). The description of the shape drawn on the sheet
follows, given in the next n lines in a similar form.
Output
wish to solve the given case. In the former case, in the next line output a permutation of the numbers
1...n denoting the order in which Johnny is supposed to cut out the respective sides of the shape drawn
on the sheet (vertices are numbered from 1 to n in the input order, and side s connects vertices s and 1
+ s mod n).
Score
For each test case, the score awarded to your program is equal to the ratio of the perimeter of the sheet
of paper and the total length of the lines along which the paper is cut.
Example
Input:
3
4 4
0 0
0 2
2 2
2 0
0 1
1 2
2 1
1 0
4 3
0 0
0 3
3 3
3 0
1 1
1 2
2 2
4 3
0 0
0 3
3 3
3 0
1 1
1 2
2 2
Output:
case 1 Y
1 2 3 4
case 2 Y
1 2 3
case 3 Y
3 2 1
Score:
4.94

Date:
2005-02-11
Time limit: 17s
Source limit:50000B
Resource: -
298. Closing down Railway Lines

Problem code: DERAIL
Many cities in Byteland look back on the days when Johnny the First was king, and when nobody
bothered about public spending. One of things that the citizens liked most about Johnny was that
whenever he had a hangover, he would sign any public petition brought forth to him, just for the sake
of peace and quiet. Rail travel was extremely popular, and lots of cities and villages requested railway
lines connecting them directly, to which King Johnny always graciously agreed (even if he wasnt
quite sure what he was agreeing to). Seeing that money was no object, the railway tracks were built in
such a way as to connect pairs of cities directly, along straight lines. If two railroads intersected, a
complex intersection involving bridges and tunnels was built and everyone seemed perfectly happy.
And then after Johnnys abdication, democracy returned, and the happy days of Byteland ended. One
of the first things that had to be done was closing down most of the railway lines. The new government
intends to disassemble a large part of the direct railway connections, preserving barely enough to make
travel possible between any two cities (perhaps via other cities on the way). The total cost of
maintenance of the lines which remain open, equal to k Bytelandian Dollars per kilometer of track
open and l Bytelandian Dollars per intersection of 2 used tracks, is to be as low as possible. Please
help the government decide which railroads should remain open.
Input
Input starts with a single integer t, the number of test cases (t<=100). t test cases follow.
Each test case begins with a line containing two integers n m k l, denoting the number of cities, the
number of direct connections between cities, the cost of upkeep of a kilometer of track, and the cost of
upkeep of a single railway line intersection, respectively (3<=n<=m<=10000, 0<=k,l<=100000). Each
of the next n lines contains two integers x i y i , corresponding to the X and Y coordinates of the i-th
city, measured in kilometers, respectively (-40000<=x i ,y i <=40000). Then exactly m lines follow,
containing a pair of integers a i b i each, which denote that cities a i and b i , numbered in input order,
are connected by a direct railway track (1<=a i , b i <=n). No three cities are collinear and no three
tracks intersect at one point. All tracks are bidirectional.
Output
For the i-th test case output a line containing the text case i Y or case i N, specifying whether
you wish to solve the given case. Then in the former case, write exactly n-1 lines containing one
integer each -- the numbers of the railway connections that ought to be left open (numbered in input
order). It is guaranteed that for the input data some solution always exists.
Score
The score awarded to your program is the sum of scores received for the test cases you chose to solve.
For each such test case you will receive (s/c)-1 points, where s is the cost of maintenance of the
original configuration, while c is the cost of maintenance of only those railway lines which youve
selected.
Example
Input:
1
4 5 1 100
0 0
0 1
1 1
1 0
1 2
2 3
1 3
3 4
4 2
Output:
case 1 Y
3
2
5
Score:
(100+1+1+1+1.414+1.414) / (100+1+1.414+1.414) - 1 = 0.019
Illustration to sample test data

Date:
2005-02-19
Time limit: 17s
Source limit:50000B
Languages: All
313. The Game of Crosses & Crosses

Problem code: CROSSES
The game of gomoku (otherwise known as naughts & crosses), played on an n x n board has many
interesting variations. One of them is the Game of Crosses & Crosses, with the following set of rules:
Two players - red and black - take it in turns to place one cross of their respective color on an
unoccupied square of the n x n gaming board. Red starts the game.
After each players move any rectangles with sides equal to at least 2, lying entirely within the
gaming board and covered completely by crosses, are simultaneously removed (cut off) from the
gaming board and the game continues.
When all the squares remaining in the gaming board are covered by crosses, the game comes to
an end. The score of each player is equal to the number of crosses of his color left standing on the
gaming board, and the player with the higher score is considered the winner.
The game of crosses & crosses feels rather like playing a degenerated game of Go with an army of
suicide bombers. For many years now it has been the favourite passtime of Bytelandian schoolchildren
during their lessons. Little Johnny was no different, and among his friends he actually became a
notable crossing champion.
But not many people knew about Johnnys crossing talent, and Johnny often used this to his
advantage. So when a few years after Johnnys abdication from the throne of Byteland an unsuspecting
publisher signed a million dolar contract with the ex-king for a series of memoirs entitled The famous
victories of Johnny the Great, he was certainly not prepared for what he received -- a detailed account
of Johnnys childhood games of crosses & crosses. To make matters worse, all accounts are written by
Johnny in exciting prose, rich in action, e.g.: "Then I played yet another game on a
3x3 board. I placed my first cross at (1,1). Then I placed a cross
at (2,3). The next cross I placed at (2,2). The cross after that I
placed at (3,3). Finally, I placed a cross at (1,2) and I won the
game 2:1.".
In a desperate effort to save the day, the publisher employed you to create illustrations for the book.
You are given a free hand in reinacting the games (and in particular the oponents moves, which
Johnny has modestly left out), provided your version of events is not an evident contradiction of
Johnnys text.
Input
Input begins with a line containing a single integer t (t=100). t test cases follow.
Each test case starts with a line with three integers describing a single game: n sr sb, denoting the
length of the side of the playing board, the number of points scored by the red player (Johnny) and the
number of points scored by the black player (Johnnys oponent), respectively (3<=n<=250, 0<=sb<
sr). The next ceil(n 2 /2) lines contain 2 integers x i y i each - the coordinates of the squares where
Johnny placed his crosses in successive moves (1<= x i , y i <= n).
Output
wish to solve the given case. Then in the former case print exactly floor(n 2 /2) lines containining 2
integers each - the coordinates of the squares where Johnnys anonymous oponent placed his crosses
in successive moves.
Scoring
The score awarded to your program is equal to the number of correctly solved test cases. For each
case, the game defined by yours and Johnnys description must have the outcome (final score) defined
at input.
Example
Input:
1
3 2 1
1 1
2 3
2 2
3 3
1 2
Output:
case 1 Y
3 1
1 3
2 1
3 2
Score:
1
Illustration to sample test data

Date:
2005-03-09
Time limit: 17s
Source limit:50000B
Languages: All
314. Digits of e
Problem code: EVAL
In this problem you have to find as many digits of E as possible.
Input
There is no input for this problem
Output
Output must contain as many digits of E as possible (max = 1000000)
Score
The score awarded to your program will be the first position of digit where first difference occured.
Example
Output:
2.7182

Added by: Roman Sol
Date:
2005-03-10
Time limit: 25s
Source limit:4096B
Languages: All
Resource: ZCon
315. The Secret Fellowship of Byteland

Problem code: BFORG
The relationship between The University of Byteland and King Johnny was never a friendly one. The
king was the easy-going, open-minded sort of person who is prepared to turn a blind eye to the
embezzlement of public funds, but inwardly revolts at the thought of money going to waste, and
supporting a university was to the king a perfect example of a waste of money. On the other hand, the
chancellor of the university showed no tolerance whatsoever, and frequently stated in public that
Byteland was being governed by a monarch who took terrible decisions when he was drunk and even
worse ones when he was sober. After some time of bad-tempered coexistence, the king had had
enough and decided to close down the university. However, the kings councillors advised against this
move, suggesting it might cause social unrest. The king yielded to their advice, and instead established
a law which banned all organisations, clubs and associations active at the university.
This action had a rather curious effect on the usually lazy students of the university. They had never
before even thought of organising any sort of fellowship, but now they immediately decided they
needed to set one up. And this is how the Secret Fellowship came to life.
The main problem that faced the management of the Fellowship was to organise members meetings in
such a way as to minimise the risk to the participants. It was decided that the n members of the
fellowship should be split into k secret divisions, each consisting of at least 2 members. All members
belonging to the same division would then meet regularly, and they would take it in turns to host the
meetings of the division in their houses.
But one more important factor has to be taken into account -- the laziness of students. It is therefore
your task to form the divisions in such a way that the furthest distance a student may ever be asked to
walk is as short as possible.
Input
The first line of input contains a single integer t, the number of test cases (t=1000). t test cases follow.
Each test cases starts with a line containing two integers n k, denoting the number of students and the
number of divisions to be formed, respectively (2<=2k<=n<=200). Each of the next n lines contains
two integers x i y i each (-1000 <= x i ,y i <= 1000), denoting the coordinates of the houses of successive
students.
Output
wish to solve the given case. Then in the former case print exactly k lines. Each line should start with
integer n j (n j >=2) and be followed by a space separated list of exactly n j increasing integers s jl ,
denoting the students belonging to the j-th division, numbered in input order (1<=s jl <=n). All
divisions must be disjoint and the sum of all numbers n j must equal n.
Score
The score awarded to your program is the total of scores for the test cases you chose to solve.
For each solved test case you will receive diam / (d*k) points, where diam denotes the distance
between the two furthest houses of members of the fellowship, and d is the distance between the two
furthest houses of members belonging to the same division.
Example
Input:
2
6 3
0 0
1 0
0 1
1 1
2 0
2 1
6 2
0 0
1 0
0 1
1 1
2 0
2 1
6 2
0 0
1 0
0 1
1 1
2 0
2 1
Output:
case 1 Y
3 1 2 4
3 3 5 6
case 2 Y
3 1 2 5
3 3 4 6
case 3 Y
2 1 3
4 2 4 5 6
Score:
1.849003
Date:
2005-03-11
Time limit: 17s
Source limit:50000B
Languages: All
Resource: -
316. Japan Crossword

Problem code: JCROSS
Japan crossword is a very popular game. It represents encoded picture which consists of filled block of
cells. At the start of game you see empty grid. Each row (column) has some numbers in beginning of
the row (column). Each number means how many continious cells are filled in a hidden picture (length
of the filled blocks). Filled blocks of cells are arranged from left to right and from top to bottom.
Between filled blocks must be at least one empty cell. For example, numbers are 4, 2, 7 mean that
there are three groups with 4, 2, and 7 filled cells in it. Your task is decode hidden picture using hints.
[IMAGE]
[IMAGE]
Input
The first line of input contains a single positive integer t<=300 - the number of test cases. Then for
every test case first line specifies integer numbers R and C (number of rows and columns) of the
picture (1<=R<=50, 1<=C<=100). Below R lines are follow. Each line consists of any integers for
horizontal hints. The very last number for every line is 0. Then C lines are follow. Each line consists of
any integers for vertical hints. And again every line ends with 0.
Output
For every test case you should write decoded picture in the form of rectangle with R rows and C
characters in each line. Symbol #(sharp) means filled block and symbol .(point) means empty cell.
Score
The score awarded to your program is the total of all scores obtained for its individual test cases. The
score for a test case is calculated so that for each right row or column you get 1 points. The
row(column) is counted as a right if there is a group of filled cells for every number in beginning of
the row(or column) and lenght of every cell is equal corresponded number. If All rows and columns
are right your score multiply by 1.5 for this test case.
Example
Input:
1
10 5
3 0
2 2 0
5 0
5 0
3 0
1 0
1 0
3 0
2
3
3
5
1
5
3
0
0
0
0
8 0
3 0
1 1 0
Output:
.###.
##.##
#####
#####
.###.
..#..
..#..
..###
..##.
..###
Score:
(10+5)*1.5 = 22.500
Bonus info: If score = xxx.xxxaaa, aaa means the number of entirely correct test cases
Added by: Maxim Sukhov

Date:
2005-02-07
Time limit: 21s
Source limit:50000B
Languages: All
Resource: ;)
317. Simple Image Recognition

Problem code: IMGREC1
One of the hard problems that borrows human minds and can find the practical application in creating
Artifical Intelegence is problem of Image Recognition. This problem in its simplest form can be
applied in many spheres of manufactures. In given problem we interest in one elementary case of
Image Recognition. You have to make choise form only two possible images that are represented on a
bicoloured picture. This images is "dagger" or "zero". This images can be rotated, deformed, scaled,
moved, have some noise or different width of lines on the picture. But human always can correctly
define that is represented on a picture.
Input
t - number of test cases, than t test cases follows. [t <= 100]
[empty line]
Eache test case starts with integer N equals to number of pictures in this test, than N pictures follows.
[4 <= N <= 10]
[empty line]
Description of each picture starts from two integers H and W - height and width of picture
accordingly. [5 <= H, W <= 50]
than follows exactly H lines each consists of W chars.
Description of picture consists of two simbols only: x - painted square and . - empty square. You
can be assured, that no other symbols are present at the description of a picture.
Output
For each test it is necessary to deduce on a separate line a string of chars with length equals to N. The
string should consist of a set of two chars x and 0. Where x corresponds to a dagger on a picture,
and 0 corresponds to a zero. If answer will contains other chars or length of a string wont equals to
N you will receive status "Wrong Answer".
Score
The score awarded to your program is the sum of scores for individual test cases. The score for
individual correctly solved test equals to N (Number of pictures in this test).
Example
Input:
1
5
5 5
x...x
.x.x.
..x..
.x.x.
x...x
5 5
xxxxx
x...x
x...x
x...x
xxxxx
6 6
..x...
..x...
xxxxxx
..x...
..x...
......
5 5
.xxx.
x...x
x...x
x...x
.xxx.
5 5
.xxx.
.x.x.
.xxx.
.....
.....
Output:
x0x00
Output:
You will recieve 5 points for this solution
Added by: Roman Sol
Date:
2005-02-09
Time limit: 21s
Source limit:50000B
Languages: All
Resource: ZCon 2005
321. X-Words
Problem code: XWORDS
It is quite simple really: Ill give you a list of words and you use them to make a crossword puzzle in a
16x32 grid. Youll be able to use the words more than once in the grid and there is a special "flipper"
square you can use as a wild card. The winner will be the program that can create the "best" fully
connected crossword in one minute. The original problem appeared here: Programmer of the month
contest (Feb. 2005).
The Starting Grid
- The grid will consist of 32 columns and 16 rows
The Word List
- There will be at least one word and fewer than 512 words in the wordlist
- Each word will be two letters long or more (WORDLENGTH >= 2)
- Each word will be sixteen letters long or less (WORDLENGTH <= 16)
- Words in the wordlist will contain only letters "A" through "Z" in upper case letters with no white
space
- Words will appear in the wordlist with one word per line
- Words will not be repeated in the wordlist, but they may be used multiple times in your solution
- Do not assume anything (like sorting) about arrangement of the words in the list
- Do not assume anything about whether a "word" is contained in any dictionary: POTM, ABCDEFG,
and XYZZY are all possible "words"
- Words in the list may be subsets of one another: SCAT, CAT, CATS and XCATS may all appear in
the same wordlist ... there is no bonus for using words containing other words ... see scoring note
below
- There may be words in the wordlist which are not possible to connect to any other words in the
wordlist
Placement of the Words onto the Grid
- Any word from the word list may be used in your solution as many times as you wish
- You may use any subset of words in the wordlist, or all of them
- All words placed on the grid must read left-to-right or downwards
- All words placed on the grid must be connected to one another
- ONLY words on the wordlist may be used and empty squares or grid boundaries must be used
immediately before and after all words
- Words may not "wrap-around" the grid boundaries in any sense
- Your solution does not need to be symmetric in any sense
- Output which is not connected, or contains words which do not appear in the wordlist, will receive a
score of zero
The Flipper Square
- There is one (and only one) "flipper" square (denoted by an asterisk) permitted in your output
- You may place the flipper square within any word you place on the grid
- When used, it may represent a different letter in the horizontal and vertical words of which it is a part
- Any words formed using the "flipper" square must be part of the wordlist (if C*T is placed on the
grid, then there must be a three letter word in the wordlist that begins with "C" and ends in "T")
- The "flipper" will likely be used at a word intersection, although this is not required (why would you
use it elsewhere??)
Input
t - number of test cases [t <= 10]
N - number of words for given test case, then N lines follows each line contain one word, in upper
case. Word will contain no whitespace or characters other than [A-Z].
Output
For each testcase your output must contain exactly 16 lines with 32 characters followed by a line feed
as in printf("\n") on each line. The letters in your output must be upper case [A-Z} as in the wordlist.
The "Flipper" (if used) in your output should be an asterisk "*". Squares that do not contain a letter or
a flipper should contain an underbar "_". There should be no white space in your output. Your output
must be exactly t*528 bytes.
Score
Your "SCORE" will be the total number of letters in all the words used in your solution. If a word is
contained within a longer word, only the longer word will contribute to the score ... for example, using
POTM would not score for the word POT even if both are in the wordlist. The "flipper" square
contributes to the word length as though it was a part of each word. The total score will be the sum of
scores for individual test cases.
Example
Input:
1
28
NECESSARY
POLITICAL
CONNECTED
SEPARATE
OPINIONS
REQUIRES
SEPARATION
SELFEVIDENT
UNALIENABLE
HAPPINESS
GOVERNMENTS
INSTITUTED
DERIVING
GOVERNMENT
DESTRUCTIVE
INSTITUTE
FOUNDATION
PRINCIPLES
ORGANIZING
ESTABLISHED
TRANSIENT
ACCORDINGLY
EXPERIENCE
SUFFERABLE
THEMSELVES
ABOLISHING
ACCUSTOMED
USURPATIONS
Output:
CONNECTED__USURPATIONS_CONNECTED
O_E___R___R_U____R_P___O_E___R__
NECESSARY_E_FOUNDATION_NECESSARY
N_E___N___Q_F____N_N___N_E_U_N__
E_S_INSTITUTED_INSTITUTE_S_F_S__
C_S_N_I___I_R____I_O___C_S_F_I_E
TRANSIENT_R_A_GOVERNMENT_A_E_E_S
E_R_T_N_H_E_B____N_S_X_E_R_R_N_T
D_Y_I_THEMSELVES_T___P_D_Y_A_T_A
____T___M___E__E_____E_____B___B
HAPP*NESS______P____PRINCIPLES_L
____T___E_SEPARATION_I_____E___I
SUFFERABLE_____R_____E_________S
____D___V_SEPARATION_NECESSARY_H
________E______T_____C_________E
HAPPINESS_THEMSELVES_ESTABLISHED
Score:
341
Added by: Roman Sol

Date:
2005-04-08
Time limit: 25s
Source limit:60000B
Languages: All
Resource: Programmer of the Month 02.2005
(function() { var po = document.createElement(script); po.type = text/javascript; po.async = true;

po.src = https://apis.google.com/js/plusone.js; var s =
document.getElementsByTagName(script)[0]; s.parentNode.insertBefore(po, s); })();
326. Enjoying a Multiplayer Game

Problem code: MGAME
One of the most popular types of computer multiplayer games in existence is the simple deathmatch
shooter, in which it is the players task to eliminate all other players on the gaming board. Usually, at
the start of the game the players are distributed fairly randomly over the board, and run around in order
to find and shoot opponents.
But there is a fair percentage of players (especially the younger ones) who enjoy the shooting most and
give up the running altogether. To achieve this, at the start of the match all players are arranged very
close to each other, and everyone opens fire in the very first second of the game. The gunfire continues
until everyone within sight of everyone else is dead, and then the game ends, since no one feels like
moving from their selected camping point.
Parents are often helpless when their children get addicted to this sort of entertainment, and dont
know how to make them stop playing without causing a major quarrel. But Johnnys dad has
developed the perfect method. He always says to his son: Sure, Ill let you play another round, but tell
me please how long itll take! And no, the answer only a minute or two is just not good enough.
At the start of the game, the players are positioned on the board and each player has a list of other
players he is capable of eliminating (from his location). At the start of every second, each living player
fires a round towards one of the opponents on his list (provided the list is not yet empty). Players who
have been hit are eliminated from the game directly after the shots were fired. The situation continues
until the lists of all surviving players are empty.
We are not asking you to give an exact answer the question posed by Johnnys dad, but only for an
honest estimate. Given an arrangement of players on the board, try to find scenarios of shooting
leading to the longest possible and the shortest possible game.
Input
The first line of input contains a single integer t, the number of test cases (t=100). t test cases follow.
Each test case starts with a line containing integer n, denoting the number of players on the board
(2<=n<=500). Each of the next n lines contains a list of integers: first, d i the length of the i-th players
list, followed by the considered list of exactly d i other players (numbered in input order from the
range 1 to n).
Output
wish to solve the given case. Then in the former case print a description of the longest known game
scenario, followed by a description of the shortest known game scenario. Each scenario starts with an
integer t, the duration of the game measured in seconds (0<=t<=n-1). Each of the next t lines contains
a list of integers, representing the identifiers of players eliminated by respective players in the given
second (one integer for each player left alive and capable of hitting an enemy at the start of the second,
ordered according to the input identifiers of the shooting players).
Score
The score awarded to your program is the total of scores for the test cases you chose to solve.
For each solved test case you will receive t max / t min -1 points, where t max is the length of the first
presented scenario, while t min - the length of the second one.
Example
Input:
1
4
2 2 3
2 1 3
3 1 2 4
1 3
Output:
case 1 Y
2
3 3 4 3
2 1
1
2 1 4 3
Score:
2/1 - 1 = 1.00

Date:
2005-04-14
Time limit: 17s
Source limit:50000B
Cluster:
Pyramid (Intel Pentium III 733 MHz)
Languages: All except: NODEJS PERL 6
353. Displace
Problem code: DISPLACE
You are given two strings S1, S2 of not more than 250 characters each. S1 does not contain characters
( and ). You can swap two consecutive characters in S1. Your task is to do it in as small a number
of swapping operations as possible to obtain a string which contains S2 as a substring (you can assume
that for the given input, this can always be done).
Input
The first line of the input file contains an integer t representing the number of test cases (t < 20). Then
t test cases follow. Each test case has the following form:
The first line contains S1
The second line contains S2
Output
For each test case, output 0 iff you do not want to solve this test case. Otherwise, output a line
containing the number 1 and two more lines of the following form:
The first line contains an integer k representing the number of swap operations
The second line contains k integers p1 p2,..., pk separated by single spaces, pi means that in the
i-th operation, you swapped the i-th character and the (i+1)-th character in S1.
Score
Your task is to minimise your score for this problem. If you choose to solve a test case and the number
of swap of operations is smaller than 5000, your score is equal to the number of operations. Otherwise,
your score is 5000. Your total score is equal to the sum of scores for individual tests.
Example
Input:
1
ABCDEFGH
FC
Output:
1
3
5 4 3
Score:
3
Added by: Walrus

Date:
2005-05-05
Time limit: 9s
Source limit:50000B
Languages: All
356. Tethering the Mammoths

Problem code: MAMMOTH
Whereas most parks in different parts of the world are inhabited by pleasant little creatures like birds
or squirrels, the nature park in Bytelands capital has somewhat larger inhabitants -- a herd of
mammoths. As you may well imagine, this does lead to peculiar problems sometimes.
On one occassion the King of Bitland came on a state visit to Byteland, and, to everybodys surprise,
decided he would take a stroll in the Mammoth Park. Since mammoths tend to be a little unpredictable
and know nothing of the protocol of royal visits, they had to be tied up for the time being. But tying
mammoths properly is not as easy as it sounds.
The park consists of little clearings connected by alleys, and on every clearing there stands a
mammoth. Due to the lack of sterdy trees in the park, the only things you can tie a mammoth to are
other mammoths. Since tying a mammoth by too few ropes may actually be more dangerous than
leaving them alone, it is required that each mammoth has to be tied to exactly k other mammoths (that
way all animals are kept safe and none of them has a feeling of being unfairly treated). The ropes
connecting two mammoths must run along the park alleys and can only be 1 or 2 alleys long (in the
latter case, the rope is assumed not to touch the mammoth in between). Finally, no two ropes may run
a long a single alley, since this might result in an awful tangle.
It is your task to design which mammoths to tie together, or to determine that the required tethering is
impossible to attain.
Input
The first line of input contains integer t, the number of test cases (t<=100). t test cases follow.
The first line of each test case contains three integers n m k, denoting the number of clearings (each
with a mammoth on it), the number of alleys in the park, and the number of mammoths to tie each
mammoth to, respectively (1<=k<=n<=m<=2000).
Each of the next m lines contains a pair of integers a i b i , denoting that clearings a i and b i are
connected by an alley (1<=a i ,b i <=n).
Output
For the i-th test case output a line containing the text case i YES if you know a solution to the
given problem and case i NO in the opposite case. In the former case, you should then output
exactly (k*n)/2 lines, containing the description of a rope between two mammoths. Each such line
should begin with integer l, the length of the rope measured in alleys (l=1 or l=2) and be followed by
exactly l+1 integers corresponding to successive clearings on the path of the rope.
It is possible that for the given test case no answer exists; in that case the only allowed solutions is
case i NO.
Your score is equal to the number of test cases for which you gave the answer case i YES.
Example
Input:
3
4 4 2
1 2
2 3
3 1
1 4
4 4 1
1 2
2 3
3 1
1 4
3 3 2
1 2
2 3
3 1
Output:
case 1 NO
case 2 YES
1 2 3
1 1 4
case 3 NO
Score:
1+0+0 = 1
For the presented example, the optimal solution would score 2 points (for test cases 2 and 3).
Date:
2005-05-08
Time limit: 42s
Source limit:50000B
525. Fractions Calculator

Problem code: TFRACAL2
The input consists of exactly 1000 test cases in the following format recursive format:
Input
case i [i-th test]
< list_eq >:=< eq >\n[< list_eq >]
< eq >:=< var >=(< onp >,< fraction >)
< onp >:=(_< var >,< onp >)(_< var >,< onp >)< op >
< var >:=(a,c,g,t)[< var >]
< op >:=(+,*,/)
< fraction >:=< number >/< number >
< number >:=(1-9)[< number >]
< id >:=
< id >
(x,y)
[x]
the definition of the expression

on the right side: just use the definition of the expression
choose exactly one from the list: x or y
process (choose) x or not
The definition of every variable (on the left side) appears only once and follows its last appearance on
the right side.
Output
The output should contain the list of variables in nondecreasing lexicographic order of identifiers and
all values should be represented as simple fractions in lowest terms, i.e. in the form N / D, where N and
D are relatively prime.
Score
The score is equal to the number of correctly solved test cases divided by 100.
Example
Input
case 1
c=_g_a/_cg_g/*
cg=_a_ct_a++
g=_a_a/_ct*
ct=_a_a*
a=2/2
case 2
t=_ct_ta*_ta*
ta=_c_a_a**
c=_ct_a+
ct=_a_a+_a_a*+
a=2/4
case 3
c=_t_cg_cg//
t=_g_g+_cg_g**
cg=_g_ct/
ct=_g_g/
g=6/71
case 4
g=_tt_tt_gt+*
t=_gt_tt*_tt/
gt=_tt_tt+_a_a*/
a=_tt_tt_tt/*
tt=2/62
case 5
c=_cc_t*
ca=_a_a/_a/
a=_cc_cc_t*+
cc=_t_t_t/*
t=76/13
Output
case 1 Y [write Y and the correct answer, write N if you dont wish to answer]
a 1 1
c 3 1
cg 3 1
ct 1 1
g 1 1
case 2 Y
a 1 2
c 7 4
ct 5 4
t 245 1024
ta 7 16
case 3 Y
c 432 357911
cg 6 71
ct 1 1
g 6 71
t 432 357911
case 4 Y
a 1 31
g 1923 961
gt 62 1
t 62 1
tt 1 31
case 5 Y
a 6764 169
c 5776 169
ca 169 6764
cc 76 13
t 76 13
Score
0.05

Date:
2005-05-14
Time limit: 24s
Source limit:50000B
Languages: All
528. Shortest Superstring

Problem code: TSSTR
Input
Input begins with a single integer t (t = 1000). t test cases follow.
Each test case starts with a line containing integer n denoting the number of words (1 <= n <= 100).
Each of the next n lines contains a word - a string of between 4 and 16 characters a, b, c or d.
Output
wish to solve the given case. Then in the former case print a single line containing the shortest
superstring. Exactly n lines with a single integer on each should follow, the i-th representing the
position of the first letter of the i-th word.
Scoring
For each test case, the score is the fraction of the total number of characters of the words and the
number of characters of the text. Programs which receive a negative score for some test case will be
considered incorrect.
Example
Input:
1
4
aaaa
aaaa
aaaa
bbaaa
Output:
case 1 Y
aaaabbaaaa
1
1
7
5
Score:
17/10 = 1.7

Date:
2005-05-18
Time limit: 30s
Source limit:50000B
Languages: All
755. Rectangles in a Square

Problem code: RIS
In two fundamental branches of modern science -- electronics and telecommunication -- progress is so
marked that it may be perceived nearly as a natural power, controlling the fate of people and
companies and transforming human life. Mainframes, computers, LAN, internet, built-in systems,
Wi-Fi - generation upon generation of technology has sprung up within a time interval shorter than
that of human life. Progress has its own life cycle, and periods of growth of semiconductor device
production are interleaved with periods of decline, approximately once every five years. Experts
believe that the main reason for such decline is the lack of new tools for Electronic Design Automation
(EDAs), which can take full advantage of the latest technological achievements.
You are employed by the designers of a modern EDA and you have been asked by your boss to solve
one of the stages of the design process. More specifically, you are to present a piece of software
which, given a square-shaped board and a list of rectangular semiconductor devices, tries to place
them on the board. No element may lie outside the board (even partially) or overlap with another
element.
You are rather vague about the details of your task, and so (surprisingly) is your boss. "Just make sure
the guys from Marketing can feature <<Efficient Automated Semiconductor Placement>> in our sales
brochure" -- he says, and leaves you to it.
Eventually, you decide to pack as many of the listed chips as possible on the given board (leaving out
those that simply wont fit in), and go off for the evening to the local whisky bar, wondering whether
the next recession in the technological cycle wont come sooner than in 5 years time...
Input
t - number of test cases, then t tests follow. [t <= 500]
In the first line of each test there is an integer N, and in the second line an integer K. N is the length of
the side of the square [2 <= N <= 1000], and K is the number of available rectangles [1 <= K <=
10000]. Then exactly K lines follow, with 3 numbers on each of them: wi, hi, li. wi - length of
rectangle [wi <= N], hi - height of rectangle [hi <= N], li - number of rectangles of this type [li <=
200000]. You may rotate a rectangle by a multiple of 90 degrees.
Output
For each test case output integer R - number of used rectangles, and then exactly R lines. On each of
these lines output integer coordinates of opposite corners of rectangle xi1, yi1, xi2, yi2. Solution will
be accepted if all rectangles wont intersect with each other and wont overrun the bounds of square.
Score
The score awarded to your program is the sum of scores for individual test cases. For individual test
case you will receive points equals to area cover with rectangles divided by area of square. For test in
which square doesnt have empty area, you will receive 4 points. If score = xxx.xxxaaa, aaa means the
number of test cases with fully covered square.
Example
Input :
1
10
8
3 5
2 2
2 3
2 5
4 5
1 3
3 8
1 1
2
1
1
1
1
2
1
1
Output :
9
1
6
9
1
6
9
1
2
3
1
1
1
4
6
3
8
8
8
5 3
8 5
10 2
5 7
10 7
10 5
1 10
2 10
10 10
Example explanation :
Fig.1
On the figure rectangles marked with numbers in accordance with position in example output.
For this test case you will receive 4.000001 points, because square fully covered with rectangles.
Added by: Roman Sol
Date:
2005-03-09
Time limit: 23s
Source limit:50000B
Languages: All
Resource: ZCon 2006
758. Tetris AI
Problem code: TTR
In the very heart of a well known producer of microelectronic products, a mobile phone with a built in
game of Network Tetris is being prepared for release. The owners of such mobile phones can arrange
duels when at a small distance from each other. Data transmission between players is carried out using
the Bluetooth protocol.
However -- now we are coming to the point -- it sometimes happens that there may be no other similar
phone nearby and the player may need to play alone. For this purpose it is necessary to write a
computer player (AI) with a very hard difficulty level.
The rules of Network Tetris are pretty simple :
The game has two playing fields, each with the rules of standard Tetris: figures of 4 blocks keep
falling from the top of the field, and have to placed in such a way as to form horizontal lines. Once a
line is filled up, it is removed and all lines above it are appropriately shifted downwards. There is
however one difference with respect to standard Tetris -- a player receives additional penalty lines as
soon as his opponent clears a line. The game is over when one of players fills his own field, either on
his own or with his opponents help, to such an extent, that the next figure cannot fully enter the field.
The width of the field is 10, and the height of field is 20. There are 6 types of figures in the game:
I (1) - [IMAGE]
L (2) - [IMAGE]
J (3) - [IMAGE]
Z (4) - [IMAGE]
S (5) - [IMAGE]
O (6) - [IMAGE]
[IMAGE]
It is your task to write a bot which starts with an empty field and, knowing the sequence of figures
dropping on its field, plays in such a way as to do as much harm as possible to the opponent.
Input
t - number of test cases [t <= 150], then t tests follow.
Each test case starts with integer N equal to the number of figures which drop onto the field [10 <= N
<= 50000]. Then N integers follow, numbered from 1 to 6 - denoting one of the figures, in the same
position as they appear in the pictures. (Look at numbers in parenthesis).
Output
For each test you should output line case 1 Y if you wish to solve this test case or case 1 N otherwise.
If you output Y, then exactly N lines must follow. Each of them should contain exactly two integers: A
and X, where A is the clockwise angle of rotation in the given move, numbered from 0 to 3 (0 - 0
degrees, 1 - 90 degrees, 2 - 180 degrees, 3 - 270 degrees), while X is the horizontal coordinate of
leftmost cube of the figure [1 <= x <= 10]. The i-th figure at input corresponds to the i-th figure at
output. If the figure falls outside the field or the parameters have incorrect value, or any falling figure
stops with at least one cube in a line of number larger than 20, then the solution will be judged as
Wrong Answer.
Score
The score will be equal to the total number of cleared lines, taken over all test cases. For one cleared
line your solution will receive 1 point, for two simultaneously cleared lines - 5 points, for three
simultaneously cleared lines - 15 points, for four simultaneously cleared lines - 30 points.
Example
Input :
1
14
3
2
4
5
3
2
1
6
6
1
1
4
1
5
Output :
case 1 Y
0 1
0 8
0 1
0 8
1 7
3 3
1 5
0 7
0 9
0 1
1 6
1 6
0 1
1 4
Score :
score = 30 + 1 = 31
Added by: Roman Sol

Date:
2005-04-13
Time limit: 30s
Source limit:50000B
Languages: All
Resource: ZCon 2006
761. Minesweeper
Problem code: MSWP
The puzzle "Minesweeper" is based on the widely known game "Minesweeper", available for almost
all MS Windows users, starting from version 2.0. The goal is simple -- to discover (or more precisely:
uncover) the positions of all mines in rectangular grid. After a field without a mine on it is uncovered,
the revealed value shows how many neighboring cells (at most 8) are occupied by mines. In the
puzzle, just as in the game, you know the total number of mines on the board. But unlike in the game,
you are not asked to risk your life by uncovering fields. Instead, you are given a list of uncovered
fields (without mines, with numbers on them) and are requested to hazard a guess at the locations of
all the mines.
Minesweeper
Input
t - the number of test cases, and then t tests follow [t <= 500].
Each test starts with three integers H, W, N equal to the height, width and number of mines on the
grid, respectively [5 <= H, W <= 50] [1 <= N <= H*W]
Then exactly H lines follow, each of them consisting of W symbols.
The description of the grid consists of ASCII characters: 1-8 - the number of mines in neighbouring
cells and . - a cell with unknown content. You can be sure that no other characters are present in the
grid description.
Output
For each test you should output the text char Y in a separate line if you wish to solve this test, or
char N otherwise. In the former case, you should then output a grid with the same size as that of the
test, with mines placed on it in stead of some characters .. Mines are defined by the character X.
The number of mines should be equal to the number of mines N given in the test description.
Score
The score of your program is the total of scores awarded for individual test cases. The score for a test
is equal to the number of cells around which mines are placed correctly (i.e. the number of mines is
equal to the integer displayed in the cell). The number of cells for which mines are placed incorrectly
is subtracted from this sum. Negative test case scores are treated as zero scores. If a test case is solved
entirely correctly, the score is multiplied by 10.
Additional info: The score is given as xxx.aaa, where aaa is number of tests solved entirely correctly.
Example
Input:
2
8 8 19
........
2323..2.
..23...2
.3..33..
2.321...
....1.32
.3...3..
1...2..2
6 6 6
111.1.
1.2121
112.21
..112.
122111
1..1..
Output:
Y
X.X.....
2323X.2X
.X23XX.2
X3X.33.X
2.321X.X
.XX.1.32
.3...3X.
1X.X2XX2
Y
111X1.
1X2121
112X21
..112.
122111
1.X1XX
Score:
The first test is solved entirely correctly, for which 23*10 = 230 points are awarded. The score for the
second test case is equal to 10-15 = -5, treated as 0. The total score is thus 230.001.
Added by: Roman Sol
Date:
2006-01-01
Time limit: 30s
Source limit:50000B
Languages: All
Resource: ZCon 2006
919. Prime checker

Problem code: PRIC
For this task you will have to check as many numbers as possible to see if they are prime. As not to
make the problem I/O oriented, consider the numbers you should check in the following order: first
take 1 and then construct the numbers in the sequence after the recursion: a i =(a i-1 +1234567890) mod
2 31 . Be careful not to use more than 4096 bytes of code.
Output
For each number you should write to output the digit "1" if the number is prime or the digit "0" if it is
not prime.
Score
The score of your program will be the index of the first number in the sequence after which you do not
have a correct answer. Because of some limitation you should not write more than 33 333 333
characters to output. If you reach this limit, your score will be adjusted in accordance to your runtime.
Example
Output:
01000000000000000000000000001000010000000001100000
should receive 50 points.

Added by: Gogu Marian
Date:
2006-08-29
Time limit: 25s
Source limit:4096B
Languages: All
1414. SuDoku Puzzle

Problem code: SUD
The name "Sudoku" is the Japanese abbreviation of a longer phrase, "suji wa dokushin ni kagiru",
meaning "the digits must occur only once". Sudoku is a logic-based number placement puzzle. The
objective is to fill a 9x9 grid so that each column, each row, and each of the nine 3x3 boxes contains
the digits from 1 to 9. The puzzle setter provides a partially completed grid.
[IMAGE]
Unlike in magazines and newspapers, the digital representation of Sudoku a puzzle is a string of length
81, with all rows of the puzzle placed one after another. The representation uses ASCII symbols
1-9 for digits and . for an empty space. For example, the puzzle from figure above can be
represented as:
7..25..98..6....1....61.3..9....1.......8.4.9..75.28.1.94..3.......4923.61.....4.
In this task you are to solve such puzzles automatically. The score will depend on the number of
solved puzzles and on the speed of your solution. Some of the puzzles have multiple possible
solutions, so be careful. A solution is correct if it satisfies the given puzzle. You can be sure that all
given Sudokus are correct.
Input
t - the number of test cases; then t test cases follows. [t <= 500]
Each test case describes one SuDoku puzzle and consists of an 81-character-long string.
Output
For the i-th test case output a line containing Y if you want to solve the test case or N if you wish to
leave it out. If you chose to solve the test case, in the next line output a sequence of exactly 81
characters corresponding to the solution for the i-th Sudoku puzzle.
Score
The score for this task calculated using the formula: score = 200*total_solved/(200+time), where
total_solved - number of correctly solved puzzles, time - running time of your program. If the score
has the following form: xxx.xxxaaa, then aaa - is the number of correctly solved puzzles.
Example
Input:
3
..41..3.8.1....62...82..4.....3.28.9....7....7.16.8...562..17.3.3.....4.1....5...
1.......4....1.38.27.9.4...91.7...........5..86.4.5.9..3......8..9....2.4.......7
7..25..98..6....1....61.3..9....1.......8.4.9..75.28.1.94..3.......4923.61.....4.
Output:
Y
294167358315489627678253491456312879983574216721698534562941783839726145147835962
Y
198563274654217389273984615915726843347198562862435791731642958589371426426859137
N
Score:
In this case total_solved = 2. If the program runs for 10 seconds,
then the score of this solution will be equal to 1.905002
Added by: Roman Sol

Date:
2006-03-30
Time limit: 30s
Source limit:100000B
Languages: All except: ERL JS
Resource: ZCon 2007
1416. Electrification
Problem code: ELC
We are trying to develop the electrical power infrastructure in the small country of Byteland. For this
purpose not far from each city we have built a nuclear power plant (NPP). We have also connected the
nearest house to this NPP with a cable. The goal of this project is to connect all houses of each city to
the source of electricity. Each house already connected to electricity become a source of electricity.
Since there is a severe shortage of electrical cable, the total length of the electricity network should be
kept as small as possible. In some places we can set up transformer/splitter boxes to which we can
potentially connect several cables; all their endpoints are then considered connected.
Input
t - the number of cities; then follows the description of each of t cities. [t <= 50]
The description of each city begins with N - the number of houses in the city [3 <= N <= 3000]. Then
exactly N lines follow, with two real numbers: x, y in each, representing the coordinates of a house.
[0.0 <= x, y <= 10000.0]
Output
For each test case you must output a connected electrical net, e.g. all houses must be connected with
each other, directly, through other houses or through transformers. For each test output integer M [0
<= M <= N] - the number of required transformers. On each of following M lines output the
coordinates of the transformers x, y [0.0 <= x, y <= 10000.0]. Next output the number K which is equal
to the number of required cables [N+M-1 <= K <= (M+N)*(M+N-1)/2]. On the following K lines
output two integers i, j - indexes of houses or transformers. Indexes for houses begins with 0 and end
with N-1, indexes for transformers begin with N and end with N+M-1.
Score
The score for the problem is given as: total_score = (200+time)*(score_1+score_2+...score_t)/200. In
the above formula, score_i is equal to the length of the electrical cable used for electrification of the
ith city, and time is the runtime of your solution.
Example
Input:
1
4
1.0 1.0
1.0 11.0
11.0 1.0
11.0 11.0
Output:
1
6.0 6.0
4
0
1
2
4
4
4
4
3
Score:
Suppose that the solution ran for 10 seconds. The length of the cable is score_1 = 20*sqrt(2). In this
case number of points awarded to the program will be equal to 29.698485.
Added by: Roman Sol
Date:
2006-04-12
Time limit: 45s
Source limit:60000B
Languages: All
Resource: ZCon 2007
1422. Digital Image Processing

Problem code: DIP
One of the most interesting problems of contemporary times is digital image processing to remove
noise. A good solution to this problem is very important e.g. when developing digital cameras. In this
task we are given a set of pictures, each of which is a grayscale image, transferred by some
communication channel with failures. During the transfer some data was corrupted. A picture is
defined as a rectangular matrix of integers from the range from 0 (black) to 255 (white). A number X
at position (i, j) means that the pixel in the picture at the point with coordinates x = i and y = j has
color RGB(X, X, X). The considered form of corruption generates noise in the following way: each
pixel of the picture has its color replaced with probability between 2 and 20% by a random value from
the range [0; 255].
Thus, you now receive a set of corrupted pictures, which were originally e.g. avatars, banners or
photos. You are to restore the picture with maximum quality. The more exact a picture you obtain, the
fewer penalty points you get.
Original Picture Grayscale Picture Noised Picture Denoised Picture
Original Picture Grayscale Picture Noised Picture Denoised Picture
Input
t - the number of test cases [t <= 60] (total number about 250), then t test cases follows.
Each test case begins with three integers: Q, H and W, denoting the noise probability for the generator
in percent, and the height and width of picture respectively [2 <= Q <= 20], [10 <= H, W <= 200].
Then H rows follow with W integers in each of them.
Output
For each test case you must output a picture after noise reduction in following format: In the first line
output the two integers H and W. Then H rows must follow with W integers in each of them. Each
integer is the color value of a pixel after the restoration process.
Score
The score of the program will be equal to the sum of scores for each single test case + 1. The number
of points for a single test case is calculated from the formula:
score = sqrt((x[1][1]1 - x[1][1]2)^2 + (x[1][2]1 - x[1][2]2)^2 + .... + (x[H][W]1-x[H][W]2)^2),
where x[i][j]1 is the color of the pixel at position i, j in the restored picture
and x[i][j]2 is the color of the pixel at position i, j in the original picture.
Example
Input:
1
6 20 20
255 255
255 255
255 000
255 000
255 000
255 058
255 076
255 000
255 000
255 255
036 255
255 255
255 255
255 255
255 255
255 255
022 022
255 255
255 255
255 255
255
200
255
255
255
058
255
255
255
255
255
100
255
255
255
177
022
255
255
255
255
255
255
255
255
058
255
255
255
255
255
195
255
255
255
255
022
255
079
255
255
255
096
096
096
096
096
096
096
255
255
002
002
002
002
255
066
255
079
255
255
255
255
255
255
255
255
255
255
255
255
167
002
002
002
255
022
255
079
255
255
255
079
079
079
079
079
079
079
255
255
002
002
002
002
255
022
255
079
255
255
255
079
255
255
079
255
255
079
255
255
002
002
002
002
104
022
255
079
255
255
255
079
255
255
079
255
242
079
058
255
002
002
002
002
255
022
255
079
255
255
255
079
255
255
079
255
255
079
255
255
002
002
002
013
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
046
002
255
022
255
079
255
255
255
045
045
045
045
185
045
045
255
255
002
002
002
002
255
022
255
079
255
255
255
255
129
255
255
255
255
255
198
255
002
002
002
002
255
022
255
079
255
255
255
045
045
045
045
045
045
043
255
255
002
002
002
002
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
002
002
255
022
255
079
255
255
255
068
068
068
068
068
068
048
255
255
002
088
002
002
255
022
255
079
255
255
255
043
255
255
255
255
255
048
255
255
255
255
255
255
012
022
255
079
255
028
255
043
255
255
255
255
255
048
255
255
255
255
255
255
133
022
255
255
203
255
255
043
043
189
068
068
068
048
255
255
255
255
143
255
255
022
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
022
255
255
255
Output:
20 20
253 253
254 255
255 000
255 000
255 000
255 058
255 000
255 000
255 000
255 255
255 255
255 255
255 255
255 255
255 255
255 255
022 022
255 255
255 255
255 255
255
255
255
255
255
058
255
255
255
255
255
255
255
255
255
255
022
255
255
255
255
255
255
255
255
058
255
255
255
255
255
255
255
255
255
255
022
255
079
255
255
255
096
096
096
096
096
096
096
255
255
002
002
002
002
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
002
002
255
022
255
079
255
255
255
079
079
079
079
079
079
079
255
255
002
002
002
002
255
022
255
079
255
255
255
079
255
255
079
255
255
079
255
255
002
002
002
002
255
022
255
079
255
255
255
079
255
255
079
255
255
079
255
255
002
002
002
002
255
022
255
079
255
255
255
079
255
255
079
255
255
079
255
255
002
002
002
002
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
002
002
255
022
255
079
255
255
255
045
045
045
045
045
045
045
255
255
002
002
002
002
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
002
002
255
022
255
079
255
255
255
045
045
045
045
045
045
043
255
255
002
002
002
002
255
022
255
079
255
255
255
255
255
255
255
255
255
255
255
255
002
002
002
002
255
022
255
079
255
255
255
068
068
068
068
068
068
048
255
255
002
002
002
002
255
022
255
079
255
255
255
043
255
255
255
255
255
048
255
255
255
255
255
255
255
022
255
079
255
255
255
043
255
255
255
255
255
048
255
255
255
255
255
255
255
022
255
255
255
255
255
043
043
043
068
068
068
048
255
255
255
255
255
255
255
022
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
022
255
255
255
255
255
255
255
255
255
255
255
255
255
255
002
002
255
255
079
079
079
079
079
079
079
255
255
002
002
255
255
079
255
255
079
255
255
079
255
255
002
002
255
255
079
255
255
079
255
255
079
255
255
002
002
255
255
079
255
255
079
255
255
079
255
255
002
002
255
255
255
255
255
255
255
255
255
255
255
002
002
255
255
045
045
045
045
045
045
045
255
255
002
002
255
255
255
255
255
255
255
255
255
255
255
002
002
255
255
045
045
045
045
045
045
043
255
255
002
002
255
255
255
255
255
255
255
255
255
255
255
002
002
255
255
068
068
068
068
068
068
048
255
255
002
002
255
255
043
255
255
255
255
255
048
255
255
255
255
255
255
043
255
255
255
255
255
048
255
255
255
255
255
255
043
043
043
068
068
068
048
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
Score:
Original
20 20
255 255
255 255
255 000
255 000
255 000
255 058
255 000
255 000
255 000
255 255
255 255
255 255
255 255
picture:
255
255
255
255
255
058
255
255
255
255
255
255
255
255
255
255
255
255
058
255
255
255
255
255
255
255
255
255
096
096
096
096
096
096
096
255
255
002
002
255
255
255
022
255
255
255
255
255
255
022
255
255
255
255
255
255
022
255
255
255
255
255
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
002
002
255
022
255
079
255
255
255
255
022
255
079
255
255
255
255
022
255
255
255
255
255
255
022
255
255
255
255
255
255
022
255
255
255
score = sqrt(2^2 + 2^2 + 1^2) + 1 = 1 + 3 = 4 (three pixels differ in the top-left corner)
Original picture: [IMAGE] Noisy picture: [IMAGE]
Added by: Roman Sol

Date:
2006-12-19
Time limit: 11s
Languages: All
Resource: ZCon 2007
1423. Digits of SQRT(2)

Problem code: SQRT2
In this task you are to find as many digits of the square root of 2 as possible. You have to make it
within the limit of time and source code length.
Input
There is no input for this problem
Output
The output must contain as many digits of the square root of 2 as possible (max = 2000000)
Score
The score awarded to your program will be the first position of the digit where the first difference
occurs.
Example
Output:
1.41421356237309504

Added by: Roman Sol
Date:
2007-01-07
Time limit: 20s
Source limit:4096B
Languages: All except: LISP sbcl LISP clisp CLPS
Resource: ZCon 2007
1481. Yet another computer network problem

Problem code: PT07E
ACRush and Jelly are practising in the computer room for next TCO. Suddenly, they found the
network is very slow. After a few diagnoses, they realized that there are many redundant wires. So
they plan to repair the network, change it to an optimal tree topology. And they cant spend too much
money to purchase wires. Then.. too easy? Are you thinking about minimum spanning tree?
But the real trouble is the connectors have their own limitation. They can only allow one computer
connects with at most B computers.
There are totally 10 cases, arranged in increasing order of the size of N (number of computers). Weight
of case i-th is w[i] = i. We define infinity = 4 * 10 9 . And in a tree, lets call number of computers that
computer i connects with is degree of computer i.
For case i-th you must show us a satisfied tree with total cost C[i] and maximum degree M[i],
considering all computers of that tree.
The formula to compute score is as below:
With case i-th:
If your M[i] <= B then Score[i] = w[i] * C[i]
If your M[i] > B then Score[i] = (w[i] + 10) * C[i] * M[i]
To make the challenge more interesting, with a simple brute force program, we generated 10 upper
bound degrees U[i] (1 <= i <= 10) for each of 10 cases.
For any case i-th:
If your M[i] > U[i] then Score[i] = infinity
Finally, TotalScore = (Score[1] + Score[2] + ... + Score[10]) / 10
Try to minimize the TotalScore.
Input
First line contains 3 integers N, M, B -- number of computers, number of pairs of computers can be
connected and the maximum number of computers that a computer can connect with. (1 <= N <= 10 4 ,
1 <= M <= 10 5 , 1 <= B <= N)
Next M lines, line i-th contains a triple (u[i], v[i], c[i]) -- means if we want to connect computers u[i]
and v[i] we should purchase a wire, cost c[i] (1 <= u[i], v[i] <= N, 1 <= c[i] <= 20000). The wires are
bidirectional.
Output
The first line contains 2 numbers --- total cost of your tree and the maximum degree in all computers
of that tree. Next, print N-1 lines, corresponding to N-1 edges of the tree, each edge on one line, forms
u v.
Example
Input:
3 3 2
1 2 1
2 3 1
1 3 5
Output:
2 2
1 2
2 3
Added by: Thanh-Vy Hua

Date:
2007-04-07
Time limit: 10s
Source limit:50000B
Languages: All
Resource: Co-author Amber
1492. Lexicographic sort

Problem code: SLEXSORT
Given alphabet A and a list of words, sort the list according to the lexicographic order induced by A.
Input
The first line of input contains t, the number of tests.
Each test begins with a line with alphabet A, which consists of lowercase letters arbitrary chosen from
the Latin alphabet. The next line contains an integer n<100 000 - the number of words. The subsequent
n contain one word each, which is not longer than 1 000 letters. Additionally, you can assume that the
total number of letters in all words of each test does not exceed 4*10 6 .
There is an empty line after each test.
Output
For each test output the sorted list of words in successive lines.
Score
The score is equal to the length of the source code of your program.
Example
Input:
2
re
3
ere
rer
re
balujemy
5
bel
luba
lej
bal
leje
Output:
re
rer
ere
bal
bel
luba
lej
leje

Added by: ukasz Kuszner
Date:
2007-04-10
Time limit: 30s
Source limit:50000B
Languages: All
1558. Math II
Problem code: MATH2
Background
This is a mathematical(?) problem. See problem MATH1 and AMATH.
Input
The first line of the input contains a single integer c(1<=c<=2).
The second line contains 3 integer numbers separated by single spaces, D(1<=D<=1 000 000
000),n(1<=n<=700),m(1<=m<=700).
n lines follow, each contains m space-separated integer numbers.The number which is in the i-th row
and j-th column is defined as a(i,j).
Output
You should output n lines, each contains m integers,which is either 0 or 1.We define the number in the
i-th row and j-th column of your output b(i,j).
Score
If your answer is valid, the score of your program equals to the sum of the scores of each test case
multiply 10000.
The score for each test case is calculated in the following way:
a) c=1
The score S equals to
[IMAGE]
If S>1.5, your score will be multiplied by 10000.
b) c=2
The score S equals to
[IMAGE]
If S>2, your score will be multiplied by 10000.
Example
Input
1
7 3 4
1 6 4
7 0 3
2 5 1
#1:
6
3
5
Output #1:
0 1 0 1
1 0 1 0
0 1 0 1
Input
2
7 3 4
1 6 4
7 0 3
2 5 1
#2:
6
3
5
Output #2:
0 1 0 1
1 0 1 0
0 1 0 1
Score:
11428.5714
Warning: large input/output data, be careful with certain languages.

Blue Marys Note: Some unofficial tests were added.
Blue Marys Another note: the score system has been changed to avoid Wrong Answer.
Added by: Blue Mary
Date:
2007-05-16
Time limit: 10s
Source limit:50000B
Resource: IOI Chinese Team Selection Contest(CTSC) 2007
1690. Intercept
Problem code: INTER
Long long ago, so long ago, no body knows how long ago, there was a huge galactic war. There was a
very powerful general, General Ramuk, who had every possible soldier and scientist under him. One
of his scientists reports that he had intercepted a transmission that he believes is from the aliens. A
group of experienced cryptographers believe that in the following hypotheses:
1.
2.
3.
4.
5.
6.
The aliens follow use binary system for representing numbers

Their 0 should be interpreted as 1 and vice-versa
The message is encoded as follows: [32bits of n1][16bits of n2][n2 bits of n3]
The retransmission they expect is: [32bits of the remainder] when n3 is divided by n1.
All the numbers are written, Most significant bit first.
Remainder must be communicated in the following format:
[remainder for 1st instance]
[remainder for 2nd instance]
in their own number system, without leading 1s (0s).
7. The number of instances is about 200.
The first transmission was completed. Ramuk is eagerly waiting for the second transmission, which
must be replied. Being such a simple problem, he asks you to write a program to do the same.
He says: "Nee evalovu chinnadha codea ezhudhariyo avalovu parisu onnakku kaathhirriku ", which
translates to: "The smaller the code you write, that much reward is awaiting you...".
You want to save the world from a probable Alien Invasion, and get as much money as possible.
Constant bit length numbers will be prefixed by 1s (0s in their notation).
Scoring
The scoring for this problem is the length of the source code.
Sample Input
NOTE: The colons (:) and newlines are for clarity
11111111111111111111110001001110:1111111111101111:0011100111000100
11111111111111111111110001001011:1111111111101100:0100100001000011111
The actual input will be like:

1111111111111111111111000100111011111111111011110011100111000100
1111111111111111111111000100101111111111111011000100100001000011111
(new line is again, for clarity)
Sample Output
0101101001
0010001111
Explanation
n1=945
n2=16
n3=50747
output=662
n1=948
n2=20
n3=376288
output=880
Warning: Large Input.

Added by: Vimal
Date:
2007-07-16
Time limit: 5s
Source limit:500B
Languages: All
Resource: Own Problem
2004. Analyse Simple Arithmetical Expressions

Problem code: EXPR2
You are to write a program to analyse some simple arithmetical expressions. The BNF form of the
defination of the expression is below.
<expression>::=<num><oper><num>
<num>::=0|1|2|...|99
<oper>::=+|-|*
Tip: You may find this problem is like the problem GALAXY very much. To get round of the
programming problems of using Brainf**k, Whitespace or Intercal, you must use C/C++/Pascal/Java
to do the programming. Seems easy? Now there is an additional objective: there must not be any
semicolons ";" in your program!!!
Input
Multiple test cases, the number of them T is given in the very first line, T<=99. (In the judge data, T =
99.)
Each test case contains one line with a correct expression, without leading or trailing spaces.
Output
For each test case you should output one line contains the result of the expression without any leading
zeros. You may assume this number is always a non-negative one.
Example
Input:
3
6*7
67-25
31+11
Output:
42
42
42
Score
Thanks to Jin Bins suggestion, Ive changed this problem from a classical one to a challenge one.
Suppose the number of non-whitespace characters(ASCII 33 - 126) in your solution is K, the your
score is floor(K 3 /1000)+1.
Note
The judge had something wrong and it has been fixed on Jul.1, 2008. Please accept my apology.
Note 2
Sorry to some users, but the C function "system()" is prohibited in this problem. Judge has been
modified. Use problem CE to practice your programming skills without any(?) restrictions.
Added by: [Trichromatic] XilinX
Date:
2007-11-03
Time limit: 17s
Source limit:17000B
Languages: C C++ 4.0.0-8 JAVA PAS gpc PAS fpc
Resource: A copy of problem GALAXY, with language restrictions modified

2335. Error Minimization

Problem code: ERRORMIN
In this problem, you have to reverse an algorithm. The known algorithm takes inputs A and C, and
produces output B. Your task will be to take A and B as inputs, and produce C.
The known algorithm can be expressed several ways:
As a mathematical
expression:
As a repeating
pattern:
B[0] = A[0] * C[0]
B[1] = A[0] * C[1]
+ A[1] * C[0]
B[2] = A[0] * C[2]
+ A[1] * C[1] +
A[2] * C[0]
B[3] = A[0] * C[3]
+ A[1] * C[2] +
A[2] * C[1] + A[3]
* C[0]
B[4] = A[0] * C[4]
+ A[1] * C[3] +
A[2] * C[2] + A[3]
* C[1] + A[4] *
C[0]
B[5] = A[0] * C[5]
+ A[1] * C[4] +
A[2] * C[3] + A[3]
* C[2] + A[4] *
C[1] + A[5] * C[0]
...
As a program:
for(int iB = 0; iB < len; iB++) {
for(int iC = 0; iC < len; iC++) {
B[iB + iC] += A[iB] * C[iC];
}
}
When you produce a solution (C), you can check your work by running the known algorithm on it, and
the output value (B) will be called Bprime. If B equals Bprime, then your program is working.
However, errors will be introduced into B, such that it is impossible to produce a matching Bprime. In
that case, your program must find the closest match. Here is the criteria for a success:
1. When given perfect inputs, B must match Bprime exactly.
2. The sum of the deltas between B and Bprime (sum(B[n] - Bprime[n])) must equal zero:
3. The sum of the differences between B and Bprime (sum(abs(B[n] - Bprime[n]))) must be as low
as possible:
Your score is the sum total of the errors between B and Bprime during its test. The goal is to get as
low a score as possible.
Notes:
1. The lengths of arrays A, B and C are the same.
2. The arrays are floating point numbers.
Input
Each request is sent in two lines; each of the values for A separated by spaces, and each of the values
for B separated by spaces. More than one request will be made.
Output
Your program must output the value for C on one line, separated by spaces, in response to each pair of
input lines.
Example
Input:
1 2 0 1 0 0
5 10 1 7 0 1
0 1 0 1 0 0 0
0 0 1 0 -1 0 0
0 1 0 1 0 0 0
0 0 0.5 0 1 0 0
Output:
5 0 1 0 0 0
0 0 0 0 0 0 0
0 0.75 0 0 0 0 0
All source code submitted for this problem must be free of intellectual property restrictions, and
becomes the intellectual property of Michael Mudge.
The longest input array is no more than 50 entries.

Added by: Michael Mudge
Date:
2008-01-13
Time limit: 10s
Source limit:50000B
Languages: C C# C++ 4.0.0-8 C99 strict JAVA
2624. JawBreaker Game

Problem code: JAWB
The goal of this popular game is to get maximum number of points, by removing aligned pieces of the
same color. Pieces can only be removed if they touch each other by an entire side. The more pieces
you remove in one turn, the more points you get. The number of points in one turn is described by the
following formula: N*(N-1), where N is the number of pieces (for example 2*(2-1)=2, 10*(10-1)=90).
If you remove pieces from the middle of the field, then all pieces located higher fall down and occupy
the empty spaces. The game is finished when no pieces which can be removed from field remain.
JawBreak game
In this problem you will be given a field and pieces on it. Your goal is to obtain the maximum number
of points.
Note: You can practice a little and plan your strategy with this on-line game [the on-line game is
slightly different from the one described above]: http://www.bigfrog.net/jawbreaker/
Input
t - the number of tests, then t tests follow. [t <= 500]
Each test starts with 3 integers: H - the number of rows of the playing field, W - the number of
columns of the playing field and C - the number of different colors of pieces. [4 <= H, W <= 50] and
[3 <= C <= 20]. Then follow H rows with W numbers in each, separated by spaces. Each number is in
the range from 0 to C-1 and describes the color of a piece.
Output
For each test you must output the letter "Y" if you want to solve this test, or the letter "N" otherwise. If
you output Y, you must output a set of lines with 2 integers x, y in each. These integers define rows
and columns in the field. [0 <= x < H], [0 <= y < W]. Coordinates are counted from the upper left
corner of field. After your last move output the line -1 -1. Youll receive status Wrong Answer if your
coordinates are outside the field, or point to an empty space, or to a single piece.
Score
The score received for this problem is calculated as follows: score = 200*total_score/(200+time),
where total_score - sum of points received for each playing field, time - process time for your solution
in seconds. The score for a playing field is calculated as (C*C*base_score)/(H*W), where S - number
of different colors, H - field height, W - field width, base_score - number of points calculated as in the
description of problem.
Example
Input:
1
4 4 3
0 0 1 1
1 1 2 2
0 1 2 0
0 1 1 2
Output:
Y
1 0
1 0
3 2
-1 -1
Explanation:
Initial field:
0
1
0
0
0
1
1
1
1
2
2
1
1
2
0
2
After the first turn (removed 5 "ones"):

.
0
0
0
.
.
.
0
.
1
2
2
1
2
0
2
After the second turn (removed 4 "zeros"):

.
.
.
.
.
.
.
.
.
1
2
2
1
2
0
2
After the third turn (removed 3 "twos"):

.
.
.
.
.
.
.
.
.
.
.
1
.
1
2
0
Score:
In this case base_score = 5*(5-1) + 4*(4-1) + 3*(3-1) = 20 + 12 + 6 = 38,
total_score = (3*3*38)/(4*4) = 21.375. Lets suppose that ittakes 10 seconds to finish calculations, then score = 200*21.375/210 = 20.357143
Added by: Roman Sol

Date:
2007-07-19
Time limit: 50s
Source limit:50000B
Languages: All
Resource: ZCon 2008
2628. Markov Algorithm

Problem code: MAR
Markov schemes are well known field of study in theory of algorithms. Lets define some slightly
simplified schemes. We have some character set (alphabet), and a string composed of these symbols.
Besides, we have rules of replacement, and each rule specifies the substring to be replaced and the
replacement string. The replacement string can be empty. The order of rules is fixed. Everything
functions as follows. Rules are looked through in input order. The first rule which can be applied, is
applied exactly once (the given replacement which is described by the rule is carried out), and then the
operation cycle repeats (the list is looked through anew). If there are many substrings in the line which
satisfy a given rule then only the first (i.e., the leftmost) will be replaced. The process comes to an end
if after the last rule application the line has not changed. During the process of replacements the length
of the initial string can change, increasing or decreasing.
Example:
Lets consider the string ababaab
and the set of rules
ab->c
cc->ab
As a result of the application of rules the initial string will be transformed into "cac". The following
intermediate results will appear: ababaab, cabaab, ccaab, ccac, abac, cac.
Thats all. And now some tasks.
Task 1: The initial non-empty string was obtained from an ordinary arithmetic formula by the deletion
of every symbol except brackets. You are to write the set of rules which transforms this string into the
string "RIGHT" or "WRONG" depending on the correctness of brackets positions, following rules of
bracket use in arithmetical expressions. For example, the string ()((())()) must be replaced by the string
RIGHT, while the string (() must be replaced by the string WRONG with the same replacement rules.
Task 2: The initial string represents an arbitrary string of the following type [integer1]+[integer2]=?,
where [integer1] and [integer2] are decimal representation of some positive integers. You are to write
a set of rules which translates the initial string into a string of the following type:
[integer1]+[integer2]=[sum], where [sum] is the decimal representation of the sum of two numbers
integer1 and integer2. For example, the string 2+2=? must be replaced by 2+2=4, and the string
25+76=? must be replaced by 25+76=101. The integers can be up to 100 digits in decimal notation.
Task 3: You are given a string which consists of uppercase letters (A-Z), and ends with the "?" sign.
You are to output this string in reverse order without the "?" sign. For example, the string ABBCD?
must be transformed into DCBBA
Task 4: You are given a binary integer which consists of 0s and 1s. You are to write it as a string of
letters "z", and the total number of such letters must be equal to the given binary number. For example,
110 must be translated by the algorithm into "zzzzzz"
Task 5: You are given a string which consists of uppercase letters (A-Z), and ends with the "?" sign.
You are to output this string in non-descending order without the "?" sign. After applying the rules to
DFAAS?, the string should look like this: AADFS
Task 6: You are given two decimal positive integers separated by the "_" symbol and followed by
"=?", for example 30_42=?. You are to find and output the value of the greatest common divisor for
this pair. For example for 30_42=? itll be 6.
Note: The limit on the increase of the string during the work of the algorithm is 100000 symbols.
Input
There is no input data for this problem.
Output
You should output your solutions to every task one by one. If you dont want to solve some particular
task just output 0, otherwise output the length of your solution N. Then output exactly N lines
abc->def, where abc is the substring for replacement, and def is the substring by which it will be
replaced.
Score
For each correctly solved task you gain 1 point and additionally 1/N bonus points, where N is the
length of the proposed solution.
Example
Output:
0
0
0
5
a->b
b->c
d->v
g->l
l->a
0
0
Score:
In this case (if the set of rules leads to a correct answer)youll get 1 + 0.2 = 1.2 points for the 4-th task.
Added by: Roman Sol

Date:
2007-09-03
Time limit: 10s
Source limit:50000B
Languages: TEXT
Resource: ZCon 2008
2629. Robo Eye

Problem code: EYES
A robot which helps to translate old papers into digital format is being prepared for mass production.
But it requires special software to work efficiently. All scans which will be analyzed by the robot use
one of the standard fonts: Arial, Courier, or Times New Roman. As the press is not ideal and pages can
be rotated, some of the scans will be rotated by some degree. Imperfections of the robots camera
("eye") can also cause some noise. Uniform noise can be up to 2% of the number of pixels. All
analyzed documents are in uppercase English. The total number of letters in the robots eye ranges
from 3 to 6. The matrix in the robots eye is monochrome and its size is 200x200 pixels.
Input
t - the number of tests [t <= 500], then t tests follows. Each test consists of 200 rows with 200 chars in
each of them. Characters can be . and X, where . means the white color of the page, and X is the
black color of words.
The input data was generated using an on-line generator. The generator outputs data in 2 formats:
1) as a picture
2) as text
The datasets used for testing are such that all letters of the word are contained inside the picture.
Output
For each test output the recognized word in a separate line.
Score
The number of points youll receive for each image will be equal to the number of letters of the word,
provided that it is correctly recognized.
Example
Input:
2...........X...........X..............................................................X.................................................................................................................
.............................................X...........................X......................X.........................................X...............................................X.............
........................................................................................X...............................................................................................................
X............X....X...............................................................................................................X......X..................X......X.......................X..X.........
.........................................................X.........X.............................X.........................X.....XXX........X................................X..........................
................X.................................X...X....X......X.........................X...................................XXXXX.........................X.........................................
..............................X.X...........X.......................................................X......X....X.........X....XXXXXXX.........................................X........X...............
..............................................X...................................................................X..X.........XXXXXXXX.................................................................
......................................................................................................................X..........XXXXXXX................................................................
.....................................................................X............................................................XXXXXXX.......X......................X................................
...................................................X...........................X.....X...........X........X........................XXXXXXX...........................X..................................
.......................X...............................................................X............................................XXXXXXX.......................X...X.................................
.........X.................................................................................................X......X..................XXXXXXX.......................................................X....
.............X.........X.............................................X.....X...X.............X........................................XXXXXXXX...........................X...............X..............
...X....................................X.........................................................................................X....XXXXXXXX.........................................................
......................................X..........X...................................................................................X..XXXXXXXX.......................X................................
...........................................................................X.............................................................XXXXXXXX.......................................................
.....................................................X..X.........................................X.................XX...........X........XXXXXXXX......X.....................................X.........
......................X............................................................................................XXXXXXX.................XXXXXXXX....XX.................X.............................
....................X...........................................................................X..............X..XXXXXXXXXXXXX.............XXXXXXXX......X.....................X.......................
................................................................X................................................XXXXXXXXXXXXXXXXXXX.........XXXXXXXX...............X...................................
.............................................................................X......X..............X..............XXXXXXXXXXXXXXXXXXXXXXX.....XXXXXXXX..........X.......................X...............
......................X...........X.............X.............X....................................................XXXXXXXXXXXXXXXXXXXXXXXXXX..XXXXXXXX..............................................X..
....................................................................................................................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX....................................X...........
.X...................X.............................................................X.................................XXXXXXX...XXXXXXXXXXXXXXXXXXXXXXXXXX..X.........................................X..
................................X..................................................................................X..XXXXXXX.......XXXXXXXXXXXXXXXXXXXXXX...........X..................................
..................................X..............................................................................X.....XXXXXXX...........XXXXXXXXXXXXXXXXX...........................................X..
.......................................X................................................................................XXXXXXX..............XXXXXXXXXXXX...............................................
.....XX...........................................................................X......................................XXXXXXX..................XXXXXX................................................
..............................................................................................................X...........XXXXXXX..................................................X....................
................X.....................................X.......................................X............................XXXXXXX.X.........X.............X......................X..............X......
......................................................................................................X.....................XXXXXXX.................................X.............................X...X.
....................X..X..................................................X...........................X......................XXXXXXX...............X.....X............................X.................
..................................................X....X.......................................................X..............XXXXXXX...................................................................
...........................X.............................................................X.X...................................XXXXXXX..................................................................
........X.X.......X..........................................................................X......................X...........XXXXXXXX..............................X.................................
.X............................................................................X...................XXX............................XXXXXXXX.........................................X.....................
........X..................................X.....................................................XXXXX............................XXXXXXXX........................................X.................X...
................................................................................................XXXXXXX........X...................XXXXXXXX.............................................................
.................................X.......................X.......................................XXXXXXX............................XXXXXXXX..X....X...............X....................................
................................................................X.................................XXXXXXX............................XXXXXXX..............X.................................X...........
...................................................................................................XXXXXXX....................X.......XXXXX.....................X.......................................
......X........................................X....................................................XXXXXXX............................XXX..............................................................
................X....................................................................................XXXXXXX............X...............X.....................................................X.........
......................................X...................................................XXX...X.....XXXXXXX....................XX....................................................................X
......................................................X..................................XXXXX.........XXXXXXX..................XXXX.....................X..X...........................................
...................................X........................X...........................XXXXXXX.........XXXXXXX.XX..............XXXXX...................................................................
.........................................................................................XXXXXXX.X.......XXXXXXX...............XXXXXX....................X.............X................................
.................................................................................X.....X..XXXXXXX.........XXXXXXX.....X.......XXXXXXX................................................................X..
.......................................X...................................................XXXXXXX.........XXXXXXX...........XXXXXXX........X.............X............................X................
.....................................................X...X..................................XXXXXXX.........XXXXXXX.........XXXXXXX............................................X........................
...........................................X.....................X.........................X.XXXXXXX.X.......XXXXXXXX.X....XXXXXXX...........................................X..........................
..........X...........................................................X............X..........XXXXXXX.........XXXXXXX.....XXXXXXX.....X.............X............................X...X..................
.X.................................................................X..............XXX..........XXXXXXX.........XXXXXXXX..XXXXXXX..X.................X...................................................
...................................X.............................................XXXXX..........XXXXXXX........XXXXXXXXXXXXXXXX............................................X............................
................................................................................XXXXXXX..........XXXXXXX.........XXXXXXXXXXXXX.......X......................................X...........................
...................................X.....X......X................................XXXXXXX..........XXXXXXX.........XXXXXXXXXXX..............................................................X............
.......................................X..........................................XXXXXXX..........XXXXXXX......X..XXXXXXXXX...................X...........................X.......X....................
.......................................................................XX..........XXXXXXX...X..X...XXXXXXX..X......XXXXXXX.....................X................X.....................X................
.........................X........................X.................................XXXXXXX..........XXXXXXX.........XXXXX...................X..............................................X...........
................................X..X..X..............................................XXXXXXX..........XXXXXXX.X.......XXX......X.......................................................X................
.......................................................X..............................XXXXXXX..........XXXXXXXX........X...........................X....................................................
.................................................................X.....................XXXXXXXX.........XXXXXXXX.................................................................X......................
.......................X................................................................XXXXXXXX.........XXXXXXXX.............................................X.........................................
...................................X.X.................X..............X..................XXXXXXXX.........XXXXXXXX....X..X...........................................................X..................
..........................X....................X........X.................................XXXXXXXX.........XXXXXXXX.................................X..X.......X........................................
.X........................................X..........................XX........X...........XXXXXXXX.........XXXXXXX........................X................................................X...........
....................................................................XXXXXXX....X............XXXXXXXX.........XXXXX.....X........................X.......................................................
.....................................X................X...........XXXXXXXXXXXXXX.............XXXXXXXX.......X.XXX.......................................................................................
X........................X........................................XXXXXXXXXXXXXXXXXXX.........XXXXXXXX.........X......................................X.................................................
.................X.................................................XXXXXXXXXXXXXXXXXXXXXXX.....XXXXXXXX.............X........................................................................X..........
......X....................X...................................X....XXXXXXXXXXXXXXXXXXXXXXXXXX..XXXXXXXX...............................X........................................................X.X.....
.............................X...X...................................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX........................................X......................................................
.....................................X........................XX......XXXXXXX...XXXXXXXXXXXXXXXXXXXXXXXXXX..........................X...................................................................
.............................................................XXXX......XXXXXXX.......XXXXXXXXXXXXXXXXXXXXXX..........................................................................................X..
.....X..........................................X...........XXXXXX......XXXXXXX...........XXXXXXXXXXXXXXXXX...........XX...X............................................................................
................X...........................................XXXXXX.......XXXXXXX..............XXXXXXXXXXXX.....X........................................................................................
...........................................X.................XXXXXX.......XXXXXXX..................XXXXXX............................X.....................................X............................
.......X.................................X....................XXXXX........XXXXXXX...................................................X.............................X....................................
..............................................................XXXXXX........XXXXXXX..X..........X.........................X.....................................X...............X...............X.......
.............X............................................X....XXXXXX....X...XXXXXXX........X...........................................................X.........X...................X........X........
.....................................................X..........XXXXX.........XXXXXXX.................XX................................................................................................
..........X.....................................................XXXXXX.........XXXXXXX........................................................................X.........................................
...........................................X.....................XXXXXX.........XXXXXXX.................................................................................................................
.................................................................XXXXXX..........XXXXXXXX...................X..X........X...............................................................................
...............................X...........................X......XXXXXXX.......X.XXXXXXXX...........X................X..................X..................X...........................................
.........................X........................XX...............XXXXX...........XXXXXXXX................................X.................X.........X................................................
.................................................XXXXX.X...........XXXXXX...........XXXXXXXX...................................X........................................................................
X........................................XX..X..XXXXXXXX............XXXXXX...........XXXXXXXX.....................X.........................................................................X...........
...............................................XXXXXXXXXXX...........XXXXX.X..........XXXXXXX...................X..........X...............................................X............................
....X.........................................XXXXXXXXXXXXXX.........XXXXXX............XXXXX.....................................................X.....................X............X....X..............
......X.......................................XXXXXXXXXXXXXXX.........XXXXX.............XXX...........................X.................................................................................
........................X......................XXXXXXXXXXXXXXXX........XXXXX.............X...................................................................................................X.....X....
...............................................XXXXXX.XXXXXXXXXXX......XXXXXXX..................................................X.......................................................................
.........................X......................XXXXXX.XXXXXXXXXXXX.....XXXXX.....................X..............................X...........................X..........................................
................................X................XXXXX....XXXXXXXXXXX....XXXXX..........................X....................................X.......X...X.......................................X......
............X......................X.............XXXXXX.....XXXXXXXXXXX..XXXXX..................................................................................X....................................X..
........................X.........................XXXXXX......XXXXXXXXXXX.XXXXX...............X...........................................................................X.............................
..................X...........X...................XXXXXXX.......XXXXXXXXXXXXXXXX........................................................................................................................
..............................................X...XXXXXXX.........XXXXXXXXXXXXXX.........................................................X............................X.................................
...................................................XXXXXX...........XXXXXXXXXXXXX..................................X....................................................................................
...................................XXX..............XXXXXX............XXXXXXXXXXX.......................................................................................................................
..................................XXXXXX.............XXXXX..............XXXXXXXX........................................................................................................................
............X...X................XXXXXXXXX...........XXXXXX..............XXXXXXX.......................................X................................................................................
.....X...........................XXXXXXXXXX...........XXXXXX...............XXXX....................X...................X..............................................X..X..............................
...................................XXXXXXXXXX.......X.XXXXXX...........................................................X.........................................................X....................X.
.....................................XXXXXXXXXX........XXXXXXX....................................................................X...........................................X.........................
.......................................XXXXXXXXX.....X.XXXXXX.....................................................................................................................X.....................
..X.....................................XXXXXXXXXX......XXXXXX..........................................................................................................................................
...................................X....X.XXXXXXXXXX.....XXXXX................X.........................................................................................................................
...............................X......X.....XXXXXXXXX....XXXXXX.............XX..............................................................................................X...................X.......
..............................................XXXXXXXXX...XXXXXX.....................X..................................................................................................................
................................................XXXXXXXXX.XXXXXX...X............................X.................................X...........X..X......................................................
X......X.X........................X.X............XXXXXXXXX.XXXXXX.........................X................X.....X.....................................................X...................X............
...................................................XXXXXXXXXXXXXX....................................X.....................X............................................................................
.................................XX..................XXXXXXXXXXXXX...........................................X...X.X..........................................................................X.........
...........................X...........................XXXXXXXXXXX...X......................................X..................X........................................X...............................
...............................................X.........XXXXXXXXX.....................X................................................................................................................
..........................................................XXXXXXX..............................................................X.....................................X..................................
.............................X..........................X...XXXX...........X............................................................................................................................
....X..X..................................................X...X......................................X.....................X.....................................X......................................
....X....................................................X..............................X......X........................................................................................................
........................................................................................................................................................................................................
........................................X......X..X...............X...........................................................................X.......................X.............X...................
......................X......................................................X.....X...............X....................................................................................................
.........X.................................................................................................................X..........X..................................................X.............X
...........................X......................................................................................................................................X.....X...............................
......................................X...........................................................................X.......................................................X.........X.................X.
.............................................................................................................................................................................X....................X.....
....................................................................X................................X..................................................................................................
.................................................................................X.............................................X........................X......................X........................
........................X..................................................................................X...........................................................................X................
...........X.......................................X................X..............................X........................................................X.................................X.........
..........X.....................................................................................................X.......................................................................................
........................................................................................................................................................................................................
................................................................................................................X...............................................................X.......................
.............................X..............................................................X....................................................................X......................................
.....................X...............X....................X..................X....X.......X...............................................X......X......................................................
......................................................................................................................................................................X........................X........
..............................X.....X..................................................................................................................X..........X....................X..............X.
...........................X.X......................X.........X...............................X.......X..................................X................................X.............................
..X............................................................................X..........X......................................X....................................................X.................
.........................................................................................................................................................................X..........X..X................
.......................................................................................................................................X..........................X..........................X.........X
.....X.................................................X...........................X......X.................................................................................X...........................
............................X............................................................................X.X........................X...X.........................................................X.....
..X...........................................................X.......X...................................................X......................................................................X......
...........................X......................X....................X........................................................X.....X.................................................................
...................................X....................................................................................................................................................................
....................................................X.......................................................................................................X.......X.....................X.X...........
..........................XX.......................................................X...................X.......................................................................X........................
.................................X....................................................X.........................................................................X............................X.....X....
.................................................................X.......................................................X..............................................................................
............X...................X...................................................................................X..........................X........................................................
..............X.........................................................................................................................................................................................
........................................................................................X...............................................................................................................
..............................................................................X..................X.............................X........................................................................
.........................................................................X....X.............................X.....................X.....................................................................
..............................X............................................................X...................................X.................................................................X......
..........................................................................................................X.......X.....................................................................................
.............................................................................................X.....X....................................................................................................
..X............................................X...............................................................................X........................................................................
..................................................X...................X............................................X..X......................X...X..................X...................................
...........X.......................................X.X.......................................X................................................................................X................X........
................................................X..................................................................X...............................X.................................X..................
..X....................................................................X.................................................................................................................X..............
.....................................X..............................................................................................X...................................................................
......X........................................X..........................................................................................X.........................................................X...
..................................................X...................X..............................................................................................X........X.........................
.............X....................................................................X.......................X..................................................................X..........................
.............................X................................................................X....................................................X...............................X.......X............
.................................X..................................................................................X........................X.........X....................X...................X.......
.................................................................................................X.........................X............................................................................
...........X...X..............................................................................X.........................................................................................................
..................................................................................................................................X..................................................................X..
......X.........................................................................................................................X.......................................................................
.......................................................................................................................X................................X..............................................X
......................................................X..................................X...............................X..............................................................................
.............................X................................................................X.......................................................................XX.................X..............
.........................................X..........X.....................................................................................X.................X...X......................................X
......................................................X..........................................................................................................XX.....X...............................
.X..........................X...................X.....................................................X...................................................................X.............................
.............................................................X.................................................................................X..........................................X........X....
..........................................X............................................X................................................................................................................
......X..........X........................................................................................................X......X............................................................X.........
...................X...............X.............................................................................X........................................................X...X.........................
....................................X...........X..................................X....................................................................................................................
.............X........................................................X........X.......................................................X................................................................
..................X............................................X.........................................X............................................X................................................X
........................................................................................................X..X...........................................................................................X
.........................................X...................................................................................................................................................X..........
.......................X.......................................................................X....X...................................................................................................
...............................................................................................X.....................................X..................................................................
....X...........................................X...............................................................X.............X..............X..........................................................
....................................................X..............................................................................................X..X......................X....................X.....
............................................................................................X...............................X...............................X................X..........X...............
...X.............X...............X...........X.....................................................................................................................X....................................
.................................................................................................................................................X........................XX.X..........................
.X......X.............................X..............X.........................................................X................X.....X.................................................................
...X..............................................X.....................................................................................................................................................
..............X................................................................X....X...................................................................................................................
.........................X...............................................................X..X...........................................................................................................
.......................X................X..........X....................X.................................................X.....................X................X......................................
......................X...........................................................................................X.......................................X.........X...................................
...........X.........................................................................................................X...........X..........................X...........................................
................................X.............X...X.........................................X...............X........................................................X...............X..................
.................................................................X..............X.........X..............X..........................................X...................X............X..................
....................................................................................X................................................................X...................X..............................
..X...................................................................................................................................................................X.....X...........................
............................................................................X...........................X...............................................................................................
.........................................................................................................................X................................X.............................................
...................................................X.....................................................X......................X.......................................................................
...................................X...............................................X............X.......................................................................................................
....................................................X..........X..................................X......X....................................................X................................X........
............................X.......................................X..........................X.............................................X........................................X.........X.......
....................................................................................................................................................................................................X...
....................................X....................................................X.X...................X...X...............................................................X....................
...................X.......................................................................X............................................................................................................
..................................X............X.............................................................................X..........................................................................
............X..................X...........................................X...X..........X.............................X........X.......................X...........X.........X..............X.........
................................................................................................................X...............................X......X...X..............................X.............
......................................X...............................................................................................................X.X...................................X...........
X.............................................X..........X........................................................................................X................X....................................
.............................................................................X..........................................................................................................................
............................................................X..............................X......................................X.....................................................................
..........................................................................................................................X............................................X................................
...........................X..............................X...............................................................................X.............................................................
.............................................X....................................................................X.....................................................................................
......................................................................................................................................................X...X.............................................
...........................................................................................X.................................................................................................X.X........
..............................X.......................................................................X..X.............X..........X..............X......................................................
..........................................................X....................................X......................................................X.................................................
..............X....................................................................................................X.............X......................................................................
.............................................XX.....X.....................................X.............................................................................................................
........................X................................X.X.......................................................................................................................................X....
............X................X...............X............................................................................................X.............................................................
X.....X...............................................................................................X.................................................................................................
........................................X.............................................................X..............X.............................................X.................................X..
...................X...X..................................................X...................................X..............................................X...............................X..........
....................................X.............................X..................................................................X...........................................................X......
................................................X...............................X............X.................................................................................................X........
.......X..................................X.............................................................................................................................................................
.................X.............X....X............................................................................................................................X............X.........................
...........................................................X............................................................................................................................................
............................................................................................X...........X.......X.........................X..................................X.........................X
...X....................................................................................X..............X..X............................X................................................................
....................................................X...........................X............X...................................................................X.X....................................
....................................X..........X......X...........................................X..........X.........X.........X.................................................................X....
...............................................X...........X.X....................................................X...............X.....................................................................
...................................................................X....................................................................................................................................
...........................................................................................................................................................................X...X........................
...............................................X........................................X..............................................................................................X................
....................................X..............................X.........X.X........................................................................X...............................................
........................................................X....X........................................................................X....................................X.........................X..
....................X........................................................................X.............................................X..X...............X..X......................................
.........................X..................................X...............................X...X.............................................................X.........................................
...............X.......................X....................X......X....................................................................................X...........................................X...
............................................X...........X...............X..................X...........X....................................X...........................................................
...X.....................................................X..............................................................................................................................................
.....................................................X..................................X...................................................................................X...........................
........X.............................................................X................X.....................................X.......................................X..................................
X..................X......X...........................................................................................X...............X.................................................................
.........................................................................X.......................................................................................................X..............X.......
..............X..........................X...........................X..............................X...................................................................................................
..................................X.............X..................................................................................................X...................................................X
....................................X................................................................................................................................................X....X.............
.............X..........................................................................................................................................................................................
.................................X..................................................................................................................................................X.................X.
....................................................................................X...................................................................................................................
.............................................X........................................X.X..................................................................X...........................................X
.....................................X....................................................................................................................................X.X........X...............X..
................................X......X...............................X....................................................X..............................X............................................
.............X..........................................................................................................................................................................................
...........................................................X............X......................................................................................................................X........
...........................................................................................................................................................X............................................
......X........................................................................X.................X...................................................................................................X..
.....X..................................................................X...............................................................................................................................
.........................................................................................................................................................X..............................................
.............................X.....................................................X.........................................................X..........................................................
...........................X....................................................X.......X............................................X........X.......................................X.................
.........................................X.....................................................................X.......................X..................................................X.............
.X................................................................................................................................X.....................................................................
........................................................X...........................X.................X......................X..........................................................................
......X..........................................................X...............X....................X....................X...........X.X.....................X..X.....................................
XX..................................................................XXX.................................................................................................................................
....X.......X..................................X.....................XXX...........................X..............................................X.............................................X.......
...................X........X.................................X......XXXX...............................................................................................................................
....................................................................XXXXXXX....................................X....................................X....X...............X..............................
.....................................X.............................XXX..XXXX....X.........................X.............................................................................................
........X.........................................................XXX.....XXX.............................X.................................................X.....................X..X.............X....
.............X...............................X....................XX.......XX........................................................X..................................................................
.................................................................XXX........XX.........X.........................................................................................................X......
................X...............................................XXXX........XX..X........X...X................X.................X..............................X........................................
...............................................XX.............XXXX..........XX.................................................................................................X...........X............
.X..........................................X..................XXXX.........XX...XX..........................................X...................X......................................................
.X..........................X.................................XXXXXXX.......XX...XXXX.......................X............X....X.........................X...............................X........X......
.............................................................XXX..XXXX.....XXX....XXX.......................................................................................................X...........
............................................................XXX.....XXXXXXXXX....XXXX.................................................................X.................................................
.X...X...................................................XXXXX.....X.XXXXXXX....XXXXX...................X...............................................................................................
................................X........................XXXX..................XXXXX..........................X.......................X................................................X................
...........................................................XXX................XXX.XX.............................XX.....................................................................................
............................................................XXX...............XX..XX.....................X........X........X.....................X...........................X.......................X..
..................................................X..........XXX.............XXX..XX...........................................X..........................................................X..........X..
......................X.......................................XX............XXX...XX.........XX.........................................................................................................
.................................X.......................................X.XXX..XXX........XXXXX.....X...........................................................................X......................
..........X................................X....X.....X....................XX....XX.....XXXXXXXXX.......................................................................................................
.....................................................................X....XXX....XX...XXXXXXXX.XX......X..............X.................................................................................
...............................X.........................................XXX....XXX.XXXXX..XX.....XXX...........................................X.......................................................
....................X.................................................XXXXX......XXXXXX...XXX......XXXX.................................................................................................
.................................X..X.................................XXXX......XXXXX....XXX........XXX.............................................................X........................X..........
.............X.....X...........................................X.......XXX.......XX.....XXX..........XXXX..................................................X............................................
.........................XX...X................................X........XXX..X..........XX..........XXXXX..................................................X.........................................X..
..X..........XX.......................................................................XXXX.........XXX.XX................X..............................................................................
......................................................................................XXX........XXXX..XX...................................X...........................................................
.............................................XX......X.........X....X................XXX.......XXXX....XX...............................................................................................
..............................X.....................................................XXX.......XXXX....XX..................X.............................................................................
X...................X...............................................................XX......XXXX......XX................................................................................................
..........................X...................X.....X............................XXXXX.....XXXXXX.....XX...........................................X........X...........................................
..X.......................................................X......................XXXX....XXXXXXXX....XX.............X................................X..........................X.......................
....X................................................X.........X..................XXXXXXXXX....XXX...XXX................................................................................................
.....................X..............................X...............................XXXXXX......XXXX.XX................X...............................................X................................
.............X........................................X...............................XXX........XXXXX...................................................X..................................X...........
.............X.......................................X...........X.....................XXX.........XXX..................................................................................................
..................................................................X.X....................X..........XX..........................................................X...................................X...
....XX......X.......X.............................................X................X...............XX.................X.............X........X........................X...X....X........................
.....................................................X.............................................XX...................................................................................................
...................................................................................X.X.............XX................................................X........X.........................................
...........................X................................X.....................................XX.................................................X.........................................X........
............................X...................................................................XXXX.......................................................X......................................X.....
...........................................X....................................................XXXX.........................................................................X..........................
.X..................X..........................................................XX................XXXX............................................................X......................................
........................................................................................X..........XX......X...........................X............................................X...X...............
............................................X.................................X.............................................................................X............X.......X.............X........
X...............................................X..........X......................X...................................................................................................X.................
.................................................X...................X..........X.....X...............................................................X...........X.....................................
.....................................................................................................................................................X..................................................
....................................................................................................................................X..............................................X....................
....................................................................................................................X.........................................................X.......................X.
......X..........................................X...............XX.....................................................................................................................................
.............X..............X............................................................X..............................................................................................................
X............X...X................X...............................................................X.....................................................................................................
........................................................................................X................................................................................X.................X............
.......................X.................X.....................X...............................XX......................................................X..............................................X.
X.XX...........................................................X.....................X............................X..................................X..................................................
.............................................X.....................................................X..........................X........................................X................................
........................................................................X...........X......X............X........................................................................X......................
.........XX......X.................................................X...............................X...........X..X...........................................X..............X..........................
........................................................................................................................................................................................................
.................................................X.................X......................................................................X.............................................................
................................................................................................................................................................X.......................................
......................X.............................................................................................................X..........................................................X........
..X..X...X.......................................................X.....................X.........................................................................X...................X..................
........X.............................................X..............................................................................................................................X..................
.............................................................................................X..............................................................................X....................X......
..........................X.......X................................................X....................................................................................................................
....X..............X.....................X.......................X.................................................................X....................................................................
...........................................................................................................X.....................................................................X......................
........................................................................................................................................................................X.............X..X..............
..X........................................................................X...........................................X........X.X........X...........X................................................
...............X.................X.......X.............................................................................................................X................................................
.........X....X................................X...................................................................................................X.......................................X............
..X.............X.....................X.............................................................................X..X...........................X............................XX..X...................
.....X..........................X......................................................X.............................X..X...............X....X.......................X.............X....................
.......X...............XX.....................X.........................................................................................................................................................
...........................X..............................................................X...............................................X...................X.........................................
.............................................................................................................................................X..........................................................
....................................X...........................................................................X..............X........X.....X.X.......................................................
...............X...................................X.............................X...................................X...............................................................X..................
........................................................................................................................................................................................................
..................................................X.................................................................................................X...................................................
........................................................................................................................................................................................................
......................................X......................................................................................................................X..........................................
......................................X...........................................................................................................X.....................................................
......X................X.........................................................................................................................................................X......................
.X.............X......................................................X.............................................................X...................................................................
......X..........................................X......................................................................................................................................................
...........................................................................................................X...........................X....................X..........X....X...........................
..............................................................................................................................X.........................................................................
..............................................X..X......................................................................................................................X...............................
.......................X................................X...............................X...X........................................................X..................X...............................
.............................................................................................................X....................X...................X.............X..........................X....X...
........................................X.....................X.......................................................X........X......X....................X............................................
............................................................X........X..X....................X..........................................................X...........................X...................
........................................................................................................................................................................................................
.....X.......X.......X.......................................................X........X.........................................................X.....................................X.................
..................X.............................................................X...........................................................X..........X.......X........................................
..X..............................X.........................X..............................X.....................X.......................................................................................
.....................................................................................X.................................................................................................X................
....................................................X...................................................................................................................................................
...................................X................X..........X...............................................................X..................X...........X.....................X.......X...........
..............X................X..................................................................................X...........X...X.............................X....................X..................
...............X........................................................................................................................................................................................
....................................X................X..........................................................................................................X..............................X........
....................................................................................................................................................................X...................................
..........................................................................................X.............................................................................................................
........................................................X.......................X..........................X............................................................................................
............X......X.......X.........X.........................................................................X.....X........................................X.....................................XX..
..............................X.....................................................................................................................................X...................................
...X.........X...........................................X................XX............................................................................................................................
......................................................X..................................................................................................................................X..............
Output:
WNILN
PML
Score:
score = 5 (first test is correct and contains 5 letters, the second test has an error in the last letter)
Examples of images:
[IMAGE] [IMAGE] [IMAGE] [IMAGE] [IMAGE] [IMAGE]
Additional pictures can be generated with the on-line generator.
Added by: Roman Sol

Date:
2008-02-13
Time limit: 50s
Source limit:50000B
Languages: All
Resource: ZCon 2008
2659. Carl
Problem code: CARL
Professor Octastichs has invented a new programming language, Carl. An expression in Carl may be a
positive or negative integer, or may be of the form (p e1 e2) where p is a real number between 0 and 1
(inclusive) and e1 and e2 are Carl expressions. An integer represents itself and (p e1 e2) represents x +
y where x is the value of e1 and y is the value of e2 with probability p, otherwise it represents x - y.
Given a Carl expression, what is its expected value?
Input
Input consists of several Carl expressions, one per line, followed by a line containing ().
Output
For each expression, output its expected value to two decimal places.
Score
Score is the length of your source program.
Example
Input:
7
(.5 3 9)
()
Output:
7.00
3.00
Added by: Blue Mary

Date:
2008-04-19
Time limit: 1s
Source limit:512B
Resource: Waterloo Local Contest

3099. Super Quine

Problem code: SELF
Write A program to print itself n(-10 <= n <= 10) times.
Negative count means the reversed program.
Input
A line contains an integer n.
Output
The required string described above.
Score
Score is the length of your code.
Example
Input:
-2
Source:
abcdefg
Output:
gfedcbagfedcba
Score:
7
Hint:
You can contact me if you have any question about the Special Judge or your code.
Added by:
Date:
Time limit:
Source
limit:
Cluster:
Bin Jin
2008-10-03
1s
10240B

C C# C++ 4.3.2 C++ 4.0.0-8 C99 strict D F# GO HASK JAVA CAML PAS fpc PAS gpc
Languages:
SCALA
Resource: Wu Zhuojie
3880. Nop
Problem code: NOP
Mirko purchased a new microprocessor. Unfortunately, he soon learned that many of his programs that
he wrote for his old processor didnt work on the new processor.
Deep inside the technical documentation for both processors, he found an explanation. In order to
work faster, the new processor imposes certain constraints on the machine code of programs,
constraints that never existed on the previous model.
The machine code of a processor consists of instructions that are executed sequentially. Each
instruction uses a byte of memory. Also, instructions can have zero or more parameters, each of which
uses an additional byte of memory. In machine code, parameters immediately follow an instruction.
When formatted as text, machine code instructions are uppercase letters, while parameters are
lowercase letters. For example:
A b c b B c c C D e f g h
This program consists of four instructions; the first takes three parameters, the second two, the third
none and the fourth takes four parameters. The program uses 13 bytes of memory.
The new processor model fetches memory in four-byte chunks so each instruction must start at a
memory address that is divisible by four (the first byte in memory is address 0). To achieve that, we
can insert NOP (no operation) instructions into the old program, instructions that do nothing and are
not limited to memory locations divisible by four. The above program, adapted to run on the new
processor, can look like this:
A b c b B c c NOP C NOP NOP NOP D e f g h
The instructions A, B, C and D are now at memory locations 0, 4, 8 and 12, which satisfies the
processors constraints.
Write a program that determines the smallest number of NOP instructions that need to be inserted for
the given program to work on the new processor model.
Input
The input contains the machine code of the program written for the old processor model. The program
will consist of at most 200 English letters.
The program will always start in an instruction i.e. the first letter in the machine code will be
uppercase. If an instruction appears more than once in the machine code, it will always take the same
number of parameters.
Output
Output the smallest number of NOP instructions needed to adapt the program for the new processor.
Example
Input
Abcd
Output
0
Input
EaEbFabG
Output
5
Input
AbcbBccCDefgh
Output
4
Score is your source code length. Have fun!

Added by: Race with time
Date:
2009-02-17
Time limit: 1s
Source limit:360B
Languages: All
Resource: COCI 2008/2009 - Croatian Regional
3947. Brainf F##k Writing

Problem code: BFWRITE
Task is about checking your Brainf**k Skill!! So you have to write "SPOJ is indeed awesome" just
using brainf**k. Try to use as few letters as possible.
Input
Nothing
Output
Just: "SPOJ is indeed awesome"
Example
Input:
Output:
SPOJ is indeed awesome
Added by: Michael Suchacz

Date:
2009-02-24
Time limit: 0.5s-1s
Source limit:50000B
Languages: BF
4246. Place the Numbers II

Problem code: PLCNUM2
Some days ago, Little Chucha bought a computer game. She is given a NxN board which she has to
fill with the numbers 1 to N^2, no repetitions allowed. The computer calculates the sum of distances
for each pair of consecutive numbers, that is, 1 -> 2, 2 -> 3, ..., N^2 -> 1. The goal is to make that sum
as short as possible.
After many hours spent playing, Chucha has mastered the game. So she bought a new version and now
the goal is to make the sum of distances as big as possible. Can you help her?
Input
Input consists of a single integer number 1<=N<=100, the size of the board.
Output
Output one possible placing of the numbers. You are to write N lines, N space separated integers each.
Example
Input:
3
Output:
1 2 3
4 5 6
7 8 9
Score:
Score for the example is:
Distance 1 -> 2 : 1
Distance 2 -> 3 : 1
Distance 3 -> 4 : 3
Distance 4 -> 5 : 1
Distance 5 -> 6 : 1
Distance 6 -> 7 : 3
Distance 7 -> 8 : 1
Distance 8 -> 9 : 1
Distance 9 -> 1 : 4
Sum of distances (SOD): 16, Min SOD: 10, Score: 1+16-10=7 points.
Added by: yandry prez clemente

Date:
2009-04-22
Time limit: 5s
Source limit:50000B
Languages: All
6173. Burned Pancakes Tower

Problem code: DBP
The cook at the Frobbozz Magic Pancake House sometimes falls asleep on the job while cooking
pancakes. As a result, one side of a stack of pancakes is often burned. Clearly, it is bad business to
serve visibly burned pancakes to the patrons. Before serving, the waitress will arrange the stacks of
pancakes so that the burned sides are facing down. You must write a program to aid the waitress in
stacking the pancakes correctly.
We start with a stack of N pancakes of distinct sizes, each of which is burned on one side. The
problem is to convert the stack to one in which the pancakes are in size order with the smallest on the
top and the largest on the bottom and burned side down for each pancake. To do this, we are allowed
to flip the top k pancakes over as a unit (so the k-th pancake is now on top and the pancake previously
on top is now in the k-th position and the burned side goes from top to bottom and vice versa).
For example (+ indicates burned bottom, - a burned top):
+1 -3 -2 [flip 2] => +3 -1 -2 [flip 1] => -3 -1 -2 [flip 3] => +2 +1 +3 [flip 1] => -2 +1 +3 [flip 2] => -1
+2 +3 [flip 1] => +1 +2 +3
You must write a program which finds a sequence of flips, which converts a given stack of pancakes
to a sorted stack with burned sides down.
Input
The first line of the input contains a single integer N < 55, the number of problem instances to follow.
Each of the following N lines gives a separate dataset as a sequence of numbers separated by spaces.
The first number on each line gives the number M of pancakes in the data set. The remainder of the
data set is the numbers 1 through M in some order, each with a plus or minus sign, giving the initial
pancake stack. The numbers indicate the relative sizes of the pancakes and the signs indicate whether
the burned side is up (-) or down (+). M will be, at most, 1000.
Output
For each dataset, you should generate one line of output with the following values: The number of
flips (K, where 0 <= K <= 3000) required to sort the pancakes and a sequence of K numbers, each of
which gives the number of pancakes to flip on the corresponding sorting step. There may be several
correct solutions for some datasets and your task is to find the shortest one.
Score
For each test case is (3M-1)/(K+1)
Example
Input:
5
12 -2 -1 -10
11 +2 +6 -10
11 +1 +8 +11
13 -2 -12 +8
12 +11 -3 +7
+7 -4 -8 +12 -3 +5 +11 +6 -9
+4 -1 -5 +7 -8 -3 +9 -11
+10 +4 +3 -5 +2 -6 -7 -9
+9 +10 -6 -5 +3 -7 -4 +11 -1 +13
-5 -8 -12 -9 -1 +4 -2 -10 +6
Output:
25 7 12 3 1 11 4 10 2 1 9 3 1 8 6 7 2 1 6 4 5 1 1 4 1 3
25 11 1 11 3 1 10 1 1 9 7 1 8 2 1 6 1 5 3 4 2 1 3 1 2 1
25 3 11 8 1 10 3 9 7 1 8 7 1 7 6 1 6 4 1 5 3 4 1 1 3 1
24 2 1 12 2 1 11 4 10 3 7 2 1 6 4 5 2 1 4 1 3 1 1 2 1
29 6 1 12 7 11 6 10 1 1 9 5 1 8 6 7 5 6 2 5 2 1 4 1 1 3 1 1 2 1
Score:
6.4943590
Added by: Ruslan Sennov

Date:
2010-02-18
Time limit: 5s
Source limit:50000B
Resource: Soccer Choreography, Flipping Burned Pancakes
6295. Area Difference

Problem code: SQDIFF
A gardener bought two sprinklers for his new garden. Each sprinkler moistens the soil around a circle
with known radius. One will be working in the morning and the other in the evening. To plan how
many plants of different species is better to plant, the gardener wants to know what area of the garden
will be watered only in the morning, only in the evening or both in the morning and in the evening.
After some searching on the Internet, he found a formula for calculating the area of intersection of
circles, but for some reason the formula that would help to calculate the remaining two areas was not
found.
Input
The first line contains T (1 <= T <= 1000) - the number of tests. The next T lines contain six integers
x1, y1, r1, x2, y2 and r2 (0 <= xi, yi, ri <= 10000) - coordinates and radii of the first and second
sprinkler, respectively.
Output
For each test case print the absolute value of the difference between the the area that is going to be
watered only in the moring and the area that is going to be watered only in the evening rounded to two
decimals after the point. Your score is the source length.
Example
Input:
1
2 2 4 5 2 3
Output:
21.99
Added by: Spooky

Date:
2010-03-09
Time limit: 1s
Source limit:2000B
Resource: Advancement Spring 2010, http://sevolymp.uuuq.com/, author: Alexey Shchepin
SPOJ Problem Set (tutorial)
6338. Monster
Problem code: MONS
Your Task is simple. Write the code that will print the content of the following file.
https://www.spoj.pl/content/skydbms:monster
Input
No Input
Output
The content of the above file.
Score
Minimum is the size, better is the score.
Added by: A@K@$h J0h@rI
Date:
2010-03-14
Time limit: 1s-5s
Source limit:3000B
Languages: C C99 strict C++ 4.0.0-8 C++ 4.3.2 JAVA

6646. Fully Parenthesized Expression

Problem code: BRACKETS
Clyde has written a program that can evaluate arithmetic expressions. There is just one problem - the
expressions must be fully parenthesized!
Help Clyde by making sure all of his expressions are fully parenthesized - hes willing to reward you.
Input
The first line of input contains a single integer n (1 <= n <= 1000) that indicates the amount of test
cases.
On the next n lines will be a string s representing the expression. S will always contain a valid
expression and will be strictly less than 256 characters in length.
The operators used in s are */% of high precedence and +- of low precedence. All operators are
binary. All input strings will consist of only characters in the set "0123456789+-*/%()" (no
whitespace).
Output
Your program should output n lines, each containing the fully parenthesized expression s.
A fully parenthesized expression is one where each operator is one where all operands are surrounded
by either one parenthesis and one operator, or two parentheses. There should not be any extra
parentheses.
The outputted expression does not need to be a solvable expression.
Fully Parenthesized
Not Fully Parenthesized
(42)
42
(1+(2*3))
1+(2*3)
(1+((61%(3+6))*7))
1+61%(3+6)*7
Example
Input
6
42
1+2*3
1%6*2
2/0
(1+((61%(3+6))*7))
(((((1)))))
Output
(42)
(1+(2*3))
((1%6)*2)
(2/0)
(1+((61%(3+6))*7))
(1)
Score
Your score is the length of your source code.
Added by: Jargon
Date:
2010-05-13
Time limit: 1s
Source limit:50000B
Languages: All except: PERL 6
Resource: Own problem

7105. Reverse the Input

Problem code: REVINPUT
A simple task is a rare thing in SPOJ these days. If you are looking for one, then this is just the task for
you! All you need to do is to reverse the input N times.
Score is the length of your solution.
Input
The first lines of the input is an integer N (1 <= N <= 100). Next follows the input consisting of ASCII
characters. The input is terminated by EOF. You may assume that length of each word is less then
1024 and maximum number of words can be never more than 1024.
Output
The input reversed N times with atleast a space/newline between any two words of your output.
Input:
2
fox jumpsover thelazy dog.
Output:
.god .god yzal yzal eht eht revo revo spmuj spmuj xof xof
Input:
1
It matters not how strait the gate,
How charged with punishments the scroll.
I am the master of my fate:
I am the captain of my soul.
Output:
.luos ym fo niatpac eht ma I
:etaf ym fo retsam eht ma I
.llorcs eht stnemhsinup htiw degrahc woH
,etag eht tiarts woh ton srettam tI
.luos ym fo niatpac eht ma I
:etaf ym fo retsam eht ma I
.llorcs eht stnemhsinup htiw degrahc woH
,etag eht tiarts woh ton srettam tI
Added by: .:: Debanjan ::.

Date:
2010-08-13
Time limit: 1s
Source limit:1000B
Cluster:
Languages: All
7225. Word To Number

Problem code: WORDNUM
In this task you just need to convert a number from its word form to digit form. For example, you
should output 1 for one, 37000 for thirty seven thousand or 99 for ninety nine. You can assume
that output will be >= 0 and < 50000. Also all numbers will be valid i.e output will not have numbers
like 023.
Input
First line of input has a single positive integer t = number of test cases. In the next t lines, given a
number in word form.
Output
Output the number as specified.
Example
Input:3one hundred twenty threethirty four thousand one hundred eightelevenOutput:1233410811Score : Source code length
Added by: XeRon!X

Date:
2010-08-24
Time limit: 1s
Source limit:1000B
Resource: -

7965. The Electronic Dice

Problem code: DIE_PIP
A die is a small throwable object with multiple resting attitudes, generally used as gambling devices,
especially for craps or sic bo, or for use in non-gambling tabletop games.A traditional die is a cube
(often with corners slightly rounded), marked on each of its six faces with a different number of
circular patches or pits called pips. All of these pips have the same appearance within a set of dice,
and are sized for ease of recognizing the pattern formed by the pips on a face.Die These pips are
typically arranged in patterns denoting the numbers one through six. The sum of opposing faces
traditionally adds up to seven.
In this problem we will be developing a module for electronic die,your task is to convert from the
decimal die roll to the visible configuration of pips (dots) on the electronic dies face,as this die is
electronic we will use 0 and 1 instead of the standard one.
The challenges thrown to you are that you can use any one of your favourite programming
language(s) as long its name starts with C and to keep your solution less than 128 bytes.
Score is the length of your source.
Input
An integer N (0<N<7), one in each line. Input is terminated by EOF.
Output
The face of the die giving the appropiate value.
Example
Input:123456
Output:
0 0 00 1 00 0 00 0 10 0 01 0 01 0 00 1 00 0 11 0 10 0 01 0 11 0 10 1 01 0 11 0 11 0 11 0 1
Added by: .:: Debanjan ::.

Date:
2010-11-29
Time limit: 1s
Source limit:128B
Cluster:
Languages: C C# C++ 4.3.2 C++ 4.0.0-8 C99 strict CLPS CLOJ CAML
8315. Number to Word

Problem code: NUMWORD
Input
In this task you just need to convert a number from its digit form to word form. For example, you should output one for 1,thirty seven thousand for 37000 . You can assume that input will be >= 0 and < 50000. Also all numbers will be valid i.e input will not have numbers like 023.
input contains one line which is n 0<=n>=50,000
Output
Example
Output the number in words as specified.
12334108
Output:
one hundred twenty threethirty four thousand one hundred eight
Score : Source code length
problem modified on 23 / 2 / 2011

many other languages added as users want!!! and problem statment changed which lead to no accepted solutions
and that is because increasing in test cases number
Added by:
Date:
Time limit:
Source
limit:
Languages:
Resource:
kawmia institutes problem setters

2011-02-12
1s
1000B
C C++ 4.0.0-8 C++ 4.3.2 HASK JAVA PAS gpc PAS fpc PERL PERL 6 PHP PYTH 2.5
PYTH 3.1.2 RUBY
XeRon!X problem in opposite way
Input:

8473. PATHS
Problem code: WAYS
Problem Statement:
Consider a square matrix of order m(m rows and m columns). At each step you can move one step to
the right or one step to the top. How many possibilities are to reach (m,m) from (0,0)?
Input:
The first line consists of an integer t, the number of testcases. Each testcase consists of a single
integer m, the order of square matrix.
Output:
For each case print the number of possibilities of reaching the point (m,m) from (0,0)
Input Constraints:
1<=t<=10
1<=m<=14
Example:
Sample Input:
3
1
2
3
Sample Output:
2
6
20
Explanation of test case #2:

There are 6 possible ways of reaching (2,2) from (0,0)
Added by: cegprakash

Date:
2011-03-06
Time limit: 1s
Source limit:120B
Cluster:
Languages: C C++ 4.3.2 C++ 4.0.0-8 JAVA

8579. BF_MODULUS
Problem code: MODULUS2
See also http://www.spoj.pl/problems/PROBLEM1/
Problem
Given an integer n print all the possibilities of a%n.
Input
The first line consists of an integer t, the number of test cases followed by t lines containing an integer
n.
Output
For each test case print all the possibilities of a%n in descending order separated by a single space.
After each test case print a new line character. If there are no possibilities print "NOT POSSIBLE".
Input specifications:
0<t<=100
0<=N<=100
Time limit: 1 second
Example
Sample Input
2
1
2
Sample Output
0
10
Date:
2011-03-18
Time limit: 1s
Source limit:50000B
Cluster:
Languages: BF

8638. Sum of Fibonacci numbers

Problem code: FIBSUM
Given the ith (1<=i<=35) Fibonacci number F i calculate the sum of the ith till i+9th number
F i +F i+1 +...+F i+9 and the last digit of the i+246th one F i+246 .
Be careful: Your solution mustnt exceed111 bytes. But rather half of it should be more than enough.
Score is source length.
Input
In the first line the number of testcases N<=35, then N lines with one positive integer i.
Output
One line with "F i +F i+1 +...+F i+9 +last digit of F i+246 " for each i.
Example
Input:
2135
Output:
1461821381552
Added by: HWK

Date:
2011-03-25
Time limit: 1s
Source limit:111B
Languages: All

8950. Grid points

Problem code: GRIDPNT
Theres a Cartesian lattice with 0<=x,y<=n. Given one point (x1, y1>0) in this lattice rotating
clockwise as little as possible around the originfind the next point (x2, y2). The given and searched
points mustnt haveanother point between the origin (0, 0) and this point itself.
x1, y1, x2, y2 are non-negative integers.
Score is source length.
Input
In the first line the number T (T<100) of test cases.
Then T lines with the space-separated n (1<=n<=50), x1 and y1.
Output
For each test case the space-separated x2 and y2.
Example
Input:
31 1 15 3 250 48 49
Output:
1 05 349 50
Added by: HWK

Date:
2011-05-24
Time limit: 20s
Source limit:50000B
Languages: All
9380. Connecting three towns

Problem code: THREETWN
Given three towns find the point for which the summary distance to alltowns is as small as possible.
The shorter all streets together, the shorter your source code and the faster your codethe better will
beyour score. For the street length you can get at most 10000000 points, for each of the other parts
5000.Thus thebest score is 10010000.
Input
In the first line the number T (T<100) of test cases. Then T lines with the space separated coordinates
(integer 0<=x,y<=100) of the three towns.
Output
For each test case the coordinates of the above specified point.
Example
Input:
22 2 1 1 2 11 0 0 0 2 1
Output:
1.78867513459 1.211324865411 0
Added by: HWK

Date:
2011-08-12
Time limit: 1s
Source limit:5000B
Languages: All

10295. HQNP Incomputable Hard

Problem code: HQNP2
See problem HQNP for description.
Score : Score is number of test cases correctly solved.
Limits
Any HQ0-9+-INCOMPUTABLE?! program( output for each case ) must be at most 20,000 commands
long. The accumulator is unbounded (it can store an arbitrarily large integer). After each command, the
buffer must be at most 20,000 characters long. To prevent code injection vulnerabilities, during the
execution of your program( output for each case ) the buffer must never contain non-alphanumeric
characters, i.e. characters other than A-Z, a-z, and 0-9. If it happens, your score for that particular test
case will be 0.
Additionally for this challenge you must use the command + at least once for each test case.
Input
First line has integer T i.e number of test cases. ( T <= 1000 ). Next T lines has a number n ( 0 <= n <=
10^1000 ).
Output
For each n, output the required HQ0-9+-INCOMPUTABLE?! program( having + at least once )
which will give n as output. If there are multiple solutions, output any one of them. Output of each test
case must be in a single line. If you dont want to solve a test case, leave a blank line for it.
PS : No of test cases in 11 test files are respectively -> 10, 10, 100, 1000, 80, 20, 40, 500, 100, 50, 200
Update ( Dec/5/2012 ) : A small bug in judge which was causing internal error has been fixed. With
refinement in test files, all solutions have been rejudged.
Added by: XeRoN!X
Date:
2011-12-27
Time limit: 1s-10s
Source limit:50000B
Cluster:
Languages: All
Resource: Variation of IPSC Problem

11397. Find all independent nodes

Problem code: INDISET
Let G be a graph with a set of n nodes and a set of m edges. An independent set I is a subset of
nodes, no two nodes of which are connected by any edge in G.
A maximal independent set is an independent set such that adding any other node to the set forces the
set to contain at least two nodes connected by an edge in G.
In this task, you are given a undirected graph as the input, and you have to find as many as possible
independent nodes within the time limit. Your score is the total number of independent nodes found in
all test cases.
Input
The first line contains two integers, n and m, representing the numbers of nodes and edges in the
graph. 3 <= n <= 2000 and 3 <= m <= 40000. The nodes are numbered 1..n, but not necessarily in
any order. The next m lines contain pair of integers representing edges between two nodes. The list of
edges are not in any particular order.
Output
There should be one line output listing all valid independent nodes you found in the graph. The nodes
are separated by one space.
Example
Input:6 71 21 52 32 53 43 65 6Output:1 4 6
Added by: Jimmy Tirtawangsa

Date:
2012-04-17
Time limit: 1s-9s
Source limit:50000B
Languages: All except: AWK BASH BF
Resource: http://en.wikipedia.org/wiki/Independent_set_(graph_theory)

11410. Find New SPOJ Problems

Problem code: FINDPROB
After solving several problems on SPOJ you quickly browse to the ranking page to look at all
thecompetitors you have overtaken. While looking at their account pages you see lots of new
problems. It is too hard to remember all the problem names, so you must write a script that generates a
lists of new problems for you to solve.
Input
The input begins with the HTML source of your SPOJ account page.
> The following line contains a number (C<100), which represents the number of SPOJ competitors to
consider.
> The remainder of the input consists of the HTML source of the (C) competitors account pages.
Output
Print a list of problem codes you have not yet attempted that a competitor has solved.
> Sort the list by the number of competitors that have solved the problem, then alphabetically to break
ties.<p>
Example
Input:
Preview
Output:
Preview
Score
Your CPU is old and can only store 512 characters. Minimize your source length.
Added by:
Date:
Time limit:
Source
limit:
Languages:
Resource:
Jared Deckard
2012-04-19
1s
512B
BASH C C# C++ 4.3.2 FORT HASK JS PERL PERL 6 PHP PYTH 2.5 PYTH 3.1.2
RUBY
Review the account page source code.

11445. EASY MATH (Challenge)

Problem code: EASYMATC
You will be given 4 numbers
n m a d
find count of numbers between n & m (inclusive) not divisible by (a) or (a+d) or (a+2d) or (a+3d) or (a+4d).
Input
first line has number t - number of test cases.
each test case has 4 numbers n m a d
Output
Single line having single number giving the count
Example
Input:
3
1 10 2 2
20 100 3 3
100 1000 4 5
Output:
5
54
543
NOTE - 1<=n<=m<= 2^32
1<=a<= 2^32
1<=d<=2^32
2<=t<=100
Added by: Devil D

Date:
2012-04-23
Time limit: 1s
Source limit:3000B
Languages: All
Resource: own

11451. Aritho-geometric Series (AGS) (Challenge)

Problem code: AGSCHALL
Arithmetic and geometric Progressions are 2 of the well known progressions in maths.
Arithmetic progression(AP) is a set in which the difference between 2 numbers in constant. for eg,
1,3,5,7,9 .... In this series the difference between 2 numbers is 2.
Geometric progression(GP) is a set in which the ratio of 2 consecutive numbers is same. for eg,
1,2,4,8,16.... In this the ratio of the numbers is 2.
.....
What if there is a series in which we multiply a(n) by r to get a(n+1) and then add d to a(n+1) to get
a(n+2)...
For eg .. lets say d=1 and r=2 and a(1) = 1..
series would be 1,2,4,5,10,11,22,23,46,47,94,95,190 ......
We add d to a(1) and then multiply a(2) with r and so on ....
Your task is, given a , d & r to find the a(n) term .

since the numbers can be very large , you are required to print the numbers modulo mod - mod will
be supplied int the test case.
Input
first line of input will have number t indicating the number of test cases.
each of the test cases will have 2 lines
firts line will have 3 numbers a ,d and r
2nd line will have 2 numbers n & mod
a- first term of the AGS
d-the difference element

r - the ratio element
n- nth term required to be found
mod- need to print the result modulo mod
Output
For each test case print "a(n)%mod" in a separate line.
Example
Input:
21 1 213 72 2 210 8Output:16 Description - for the first test case the series is 1,2,4,5,10,11,22,23,46,47,94,95,190..13th term is 190 and 190%7 = 1Note - the value of a , d , r , n & mod will be less than 10^8 and more than 0.for every series 2nd term will be a+d and third term will be (a+d)*r .. and so on ..
Added by:
Date:
Time limit:
Source
limit:
Cluster:
Devil D
2012-04-24
1s
10000B

BF C C# C++ 4.3.2 C++ 4.0.0-8 C99 strict LISP sbcl D FORT ICON ICK JAR JAVA JS
Languages:
LUA NEM NICE NODEJS PRLG SCALA SCM guile SCM qobi SED ST TCL WSPC
Resource: Own

11462. Fun with Fibonacci Series (Challenge)

Problem code: FIBFUNCH
Fibonacci series is a series in which every element is sum of previous 2 elements.
first 2elements are 0,1 and the series goes like 0,1,1,2,3,5,8,13 ........
What if you were given 2 random numbers as the starting of the series and u follow the same rule as
the Fibonacci rule.
for eg. if you were given 2 and 2 .. the series would become
2 2 4 6 10 16 26 .........
Now your task is simple ...

You will be given 2 numbers a & b .. the first and second term of the series..
you need to calculate the sum of first n numbers of the series so formed..
Since the numbers can be big you need to print the result mod some number M provided in the input.
Input
first line will have single number t - number of test cases.
each test case will have 4 numbers a,b,n & M
a- first number of the series
b- second number of the series
n- calculate the sum till n numbers
M- print the result mod M
Output
single number for each case - sum of n terms mod M
Example
Input:
22 2 10 211 3 10 21Output:
134Explanation - for first case series is 2 2 4 6 10 16 26 42 68 110 .. Sum is 286.. o/p = 286%21 = 13NOTE -Number of test cases <=100.0 <= a,b<= 10^8
1 <= n,m <= 10^8
actually n ranges from 1 to 10^8
Added by:
Date:
Time limit:
Source
limit:
Cluster:
Devil D
2012-04-26
1s
4000B

BF C C# C++ 4.3.2 C++ 4.0.0-8 C99 strict D FORT ICON ICK JAR JAVA JS LUA
Languages:
NEM NICE NODEJS PRLG SCALA SCM guile SCM qobi SED ST TCL WSPC
Resource: Own

11689. Real Roots

Problem code: REALROOT
In this problem you are challenged to factor the real roots of polynomials.
You are rewarded points based on the number of testcases you solve.
Input
The first line contains the number of test cases, T.
The first line of each test case contains an integer N, the number of coeficients.
The second line contains the polynomial coeficients a N-1 , ..., a 1 , a 0 such that (P(x) = a N-1 x N-1 + ...
+ a 1 x 1 + a 0 x 0 ).
Output
The roots of the polynomial, in sorted order. That is all real numbersr 0 , r 1 , r 2 , ...such that P(r) = 0.
Constrains
T <= 20
N <= 20
All coeficients are in the inclusive range [-10 6 ,10 6 ]
The output precision must be at least 2 decimal digits
The roots must truly be real. No complex roots even if the imaginative part is very small.
Cases
1.
2.
3.
4.
5.
6.
7.
Same as the example

~3 random integer roots
~15 random integer roots
~10 Random interger coefficients
~10 Random floating point roots
~10 Random floating pointcoefficients
Polynomials on the form p 0 =1, p k+1 =(p k -a)^2e.g. ((x-3)^2-1)^2
Example
Input:
4
3
1 0 -2
3
1 0 1
4
-1 3 -3 1
7
1 -1 -9 13 8 -12 0
Output:
-1.414214 1.4142135
1 1 1
-3 -1 0 1 2 2
x2 - 2
x2 + 1
-x 3 + 3x 2 - 3x + 1
x 6 - x 5 - 9x 4 + 13x 3 + 8x 2 - 12x
-sqrt(2), sqrt(2)
No real roots
Triple root in x=1
Mixed integer roots
Notes
1. All testcases a double checked using Mathematica with 30 digits of precision.
2. Constrains are set such that most approaches should be fine using double working precision.
Added by: Thomas Dybdahl Ahle

Date:
2012-06-06
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All

11719. The dojo s corridor

Problem code: M5TILE
Leo is training his martial arts in bytelands dojo. There is a rectangular (5 2n) corridor to join the
dojo.
In how many ways W(n) can we exactly cover the corridor with 5n tatamis (2 1) ?
Input
Theres no input for this task
Output
You should output 17 lines with: W(1), W(2), W(3), ..., W(17)
Example
Output:
8
95
... (15 lines follows)
Score
Score is source length, you have to use less than 190 bytes, the third should be enough.
Information
W(17) fit in a 64bit signed container, W(18) doesnt.
You may try M3TILE or M4TILE first.
After that, you may try those : Tiling a WxH Grid With Dominoes , Corridor I , Corridor II .
Added by: Francky

Date:
2012-06-14
Time limit: 1s
Source limit:190B
Cluster:
Languages: All
Resource: M3TILE extension

11746. Sum the Series

Problem code: SUMUP
Nilendu is a brilliant student of Mathematics and always scores A+ in it. His professor RamjiLal is
quite impressed seeing his mathematical skills and asks him to sum the following series:
1/3 + 2/21 + 3/91 + 4/273 + .....
But the fact is Nilendu is quite lazy to do his assignment. He has to watch a film and many other
activities to do. So he asks you for your help. Will you be able to solve it ??
Input
Input consists of t (number of test cases), then t line follows, each containing an integer N (1 <= N <=
10,000).
Output
A single line containing the sum upto Nth integer (rounded upto 5 digits)
Example
Input:
512345Output:
0.333330.428570.461540.476190.48387
Edit: The score is your source length. The smaller your code is, the more point you will get. All
the solutions have been rejudged !!!
Added by: Better late than never !!!
Date:
2012-06-20
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All
Resource: RamjiLal Sir

11790. Size Contest!!!Reloaded!!

Problem code: JH1
After seeing the popularity of the question size contest, Aradhya thought of adding its new version.
The problem statement is really simple. You are given n and and then next n lines contain n
numbers.You have to calculate p and q.
p is the sum of numbers at even places ,but we add them only if they are positive.
q is the sum of numbers at odd places,but we add them only when they are negative.
Then you need to find the absolute value of p and q.
If p is greater than q or equal to q,then print "Some Mirrors Lie!". Wink ( without quotes )
If q is greater than p, then print "Every Girl Lies!" ( without quotes ) Laughing
Input
First line contains a integer t=number of test cases.
Then each test case contains a number n. and next line conatin n numbers separated by a space.
1<=n<=100
and the numbers are less than 10^18
Output
A single line for each test case as described above.
Example
Input:
1
5
-1 2 -3 5 -4
Output:
Every Girl Lies!
Mind you--->The less your fingers work Cool
.The more you GAIN!!!Laughing Laughing Laughing
Note -- > Source Limit is made a little strict !!Surprised .. So chill out !!Laughing
Added by: CounterinsurgectoR

Date:
2012-06-29
Time limit: 1s
Source limit:250B
Cluster:
Languages: All except: PERL 6

11793. Cartesian Shortest Path

Problem code: CSPATH
The task is simple, on the 2D cartesian coordinate system, how many different shortest path from point
O(0,0) to point A(x,y), but not through point B(x1,y1) and C(x2,y2).
Input
The first line is an integerT(1 <=T<= 10000), denoting the number of test cases. Then,Ttest
cases follow.
Each test case consist of 3 lines:
-first line contains two integer xand y(1 <= x,y<= 10)location of point A
-second line contains two integer x1(0 <= x1< x)and y1(1 <= y1<= y) location of point B
-third line contains two integerx2(1 <=x2<= x)andy2(0 <=y2< y) location of point C
Output
For each test case, output number of different shortest path from (0,0) to point A but not through point
B and C.
Example
Input:
2
4 5
3 4
2 2
3 3
2 1
1 2
Output:
32
2
See also: Another problem added by Tjandra Satria Gunawan

Added by: Tjandra Satria Gunawan
Date:
2012-06-29
Time limit: 10s
Source limit:450B
Languages: All

11815. Tiling a WxH Grid With Dominoes

Problem code: MNTILE
Write a program that takes as input the width, W and height H of the grid and outputs the number of
different ways to tile a W-by-H grid with (2x1)dominoes.
Input
The first line is an integerT(1 <=T<= 276), denoting the number of test cases. Then,Ttest cases
follow.
For each test case, there are two integers Wand H(0 <= W+H<= 22)written in one line, separated
by space.
Output
For each test case, output the number of different ways to tile a W-by-H grid with (2x1)dominoes.
Example
Input:
6
1 2
2 3
3 4
4 5
5 6
6 7
Output:
1
3
11
95
1183
31529
Information
All outputs will fit on 64-bit signed integer and less than 10 15 .
You may try M3TILE, M4TILE, or M5TILE first.

Date:
2012-07-02
Time limit: 1s
Source limit:300B
Languages: All
Resource: Generalization of M3TILE, M4TILE/GNY07H, and M5TILE problems.

11849. A Very Easy Problem! (Challenge Mode)

Problem code: EPROBLEM
This is challenge version of A Very Easy Problem!.Given integer i, Your task istoconvert integer i
into http://www.spoj.pl/problems/EASYPROB/format.
Input
There are multiple test cases, each line contain an integer i(0 <i< 2 64 ). Process input until EOF.
Output
For each case, output the converted number in separate line.
Example
Input:
137
1315
Output:
137=2(2(2)+2+2(0))+2(2+2(0))+2(0)
1315=2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)

Date:
2012-07-13
Time limit: 10s
Source limit:300B
Cluster:
Languages: All except: NODEJS PYTH 3.2.3 n
Resource: A Very Easy Problem! (Classical Mode)

12393. Enigma Machine

Problem code: ENIGMAS
This challenge is to simulate the three rotor M3 Enigma Machine. For each test three lines of
information will be provided; the first line will contain the rotor settings, the second the plugboard,
and the third will be the text to encode/decode with the Enigma cipher.
Input
The first line will contain a single value T, for the number of tests to follow, where T <= 100.
For each test there will be three lines:
The first line will contain three entries indiciating: the Walzenlage, the Ringstellung,and the
Grundstellung in the form 123 AAA BBB. The Walzenlageonly contains numbers 1-5. The
Ringstellungand Grundstellungwill be provided as triplets of letters in the range A-Z.
The second line will contain pairs of letters, from the range A-Z, indicating the settings for the
Steckerbrett- there may be up to 13 pairs of letters.
The final line of the test will contain an unknown length message to encode/decode - the message
will be in the standard quintuple form used at the time, separated with spaces,eg ABCDE
FGHIJ KL. The final group may be 1-5 letters in length. Again, only the range of letters A-Z will
be used. The line will be terminated in a newline (0x0A).
The Enigma machine used is the three rotor M3 version. This had five rotors, of which only three
would have been installed at any time. The Umkehrwalzein use is the B wiring.
Output
The output is to match the third line of the input, i.e. must be in the same quintuple grouping. One line
of output per message is to be produced.
Example
Input:
2
123 JAN DER2
123 JAN DER
SP OJ RU LZ
THISX ISXAN XEXAM PLEXI NPUT
543 SPO JPL
SH OR TE NI
YUQKD YVPSF HCQEI VHAPE NAQZQ I
SP OJ RU LZYUQKD YVPSF HCQEI VHAPE NAQZQ I
Output:
SJLKM SVZYM HXTUW VVWYY EDEB
THISX ISXAX DECOD XEDXM ESSAG E
Added by: Jander

Date:
2012-10-04
Time limit: 10s
Source limit:50000B
Cluster:
Cube (Intel Pentium G860 3GHz)
Languages: All
Resource: http://en.wikipedia.org/wiki/Enigma_machine

12845. Minimum knight moves Challenge

Problem code: NAKANJC
Anjali and Nakul are good friends. They had quarrelled and you had written a program for Anjali to know theminimum number of moves a knight takes to reach from one square to another square of a chess board(8X8).Nakul is brilliant and knows Anjali didnt write it herself and says her program is too slow by all standards. He isunimpressed so she asks you to try solve the problem faster this time using as few keystrokes as possible.She wants to know whether you can actually do it. Anjali is very weak in programming. Help her to solve theproblem.Since you are busy and tend to forget she reminds you that "A knight can move in the shape of an "L" in a chessboard - two squares either forward, backward, left, or right and then one square to its ...Since you are busy and tend to forget she reminds you that-"A knight can move in the shape of an "L" in a chessboard - two squares either forward, backward, left,or right and then one square to its left or right. A knight move is valid if it moves as mentioned above andit is within the boundary of the chessboard (8 X 8)."first solve problemhttp://www.spoj.pl/problems/NAKANJ/
a1 h8
a1 c2
h8 c3
Output:
614
Score:
Your source code length (if you are successful in avoiding TLE and WA)
The smaller code the better
EDIT: Time limit increased 28-11-2012. All submissions rejudged
Added by: Aditya Pande

Date:
2012-11-26
Time limit: 0.5s-3s
Source limit:5000B
Cluster:
Languages: All
Resource: own
Input
There are T test cases in total. The next T lines contain two strings (start and destination) separated by aspace.T<=200001The strings start and destination will only contain two characters - First character is an alphabet betweena and h (inclusive), Second character is a digit between 1 and 8 (inclusive) - (Quotes just for clarity).
Output
Print the minimum number of moves a knight takes to reach from start to destination in a separate line.
Exam

12874. Pell Fourth

Problem code: PELLFOUR
The double palindrome, or Quarter Pell Art
Leo was quietly fighting with XerK along the East-coast with 300 friends, when XerK proposed Leo a
beer, it was a Pell-Fourth.
Then XerK told Leo he had a good problem found in an ancient book :
-D is a given positive integer number, consider the equation :
X^2 = DY^2 + 1, with X and Y positive integer numbers.
Find the minimum number X within all solutions.
Sometimes its possible, sometimes not!
Examples :
If D=2, 3^2 = 22^2 + 1, so X=3.
If D=3, 2^2 = 31^2 + 1, so X=2.
If D=4, its impossible!
-Leo said that he very well knows this problem and claimed that there is yet on SPOJ a classic edition
and surely others related ones. But XerK told him he had an army of bytelands computer that gave
him the list of the worst test cases for D. This list begins with 2, 5, 10, ...
First examples are:
D
2
5
10
X
3
9
19
where each new line is the minimal D to break a new record for X.
E.g : for any D in [5, 10[, X(D) will be not greater than 19.
The search and print of those pell-fect (D, X) is the goal of this challenge.
Input
Theres no input for this challenge.
Output
Start with D=2 and X=3, and print consecutive pell-fect "D X" of this sequence. As the answer X
could be a huge number, print instead CHK(X, 2^16384), this only affect X numbers on line 127 and
after.
Example
Output:
2 3
5 9
10 19
[...]
constraints
This is madness, but XerK can judge 1000 lines.
Score
If you can output n lines, XerK decided that the fairest score was exp(sqrt(n)), but he didnt want to
tell why, so it was decided to set the score at just n. You need to output more than 44 lines to get
accepted.
Added by: Francky
Date:
2012-12-01
Time limit: 44s
Source limit:50000B
Cluster:
Languages: All

12919. Man of Steel

Problem code: MOS
Clark Kent is a young journalist who was born Kal-El on the alien planet before being rocketed to
Earth as an infant by his scientist father Jor-El, moments before the planets destruction and adopted as
a child by Jonathan and Martha Kent. Raised with the values of his adoptive parents, he feels alienated
because of his unique super human abilities.
Before the alien planets destruction Jor-EL was killed by Dru-Zod( also known as General Zod ). Zod
was sentenced to exile to the prison of Phantom Zone for his attempts to overtake the planet. Zod
somehow managed to escape from his prison and now wants to kill the son of Jor-El i.e. Clark Kent.
Now, Zod has reprogrammed the robot army guarding Phantom Zone and is planning to attack Earth
starting with the city of Metropolis.
Fortunately, CAELOSS ( group of activists that employ electronic communication and super science
cybernetics ) issued a warning for the Zods upcoming attack to the Metropolis citizens. CAELOSS
also found that Zods Robots will be attacking the buildings such that pairwise distance of all buildings
under attack is minimum. Clark after getting the information decided to defend his city and himself but
he is unable to solve this complex problem of getting the Robots attack configuration. To make an
effective defence startegy he wants someone to give the best approximate result. No two Robots will
attack the same building.
Pairwise distance in set of N points is defined as :SUM [ distance( A, B) ] for all distinct pairs (A,B)
where A and B are points in given set. Pair (A,B) is same as (B,A).
distance(A,B) = sqrt[ (A.x-B.x) 2 + (A.y-B.y) 2 ]
Input
First line : T ( No of test cases ) <= 20. Each test case starts with N and K i.e. number of buildings in
Metropolis and number of Zods Robots respectively. Next N lines have two integers i.e. x and y
coordinates of each building.
3 <= N <= 10^5 and 2 <= K <= minimum(N, 1000) and ( 0 <= x <= 10^6, 0 <= y <= 10^6 ) and T*N
<= 2*10^5
Output
For each test case output "Save" K and then K lines, each having index of the building in the input (
see example ). It is obvious but stating it explicitly that for each test case:
=>each building index in output should lie in range [1,N] .

=>output should have exactly k distinct building indices.
Otherwise solution will be judged as wrong.
Example
Input:
24 30 00 11 12 23 21 11 29 9Output:Save 312 4Save 212Score : Average of S/A over all test cases. [ minimize the score ]
S = sum of pairwise distance of buildings in output.
A = average distance of buildings in input from (0,0).
Added by: XeRoN!X

Date:
2012-12-05
Time limit: 1s-20s
Source limit:50000B
Cluster:
Languages: All
Score for the first test case = [pairwise distance between A(0,0), B(0,1), C(2,2)]/1.3106...
i.e [distance(A,B) + distance(B,C) + distance(C,A) ]/1.3106...

12996. Wow Square

Problem code: WOW_SQR
"Wow Square" This problem is about the perfect square number, given a positive integernyour task
is to find two integersxand ythat satisfy:
1) x<y<=n. Remember that xis always less than y.
2) x*y is a perfect square. This means that theres a positive integer z such that z*z=a*b.
3) x*yis maximum. Find x*y as large as possible without violating previous rules.
4*) y-xis maximum. If there still multiple solution x,ythat satisfy all previous rules, choose x,ywith
largesty-x.
Input
First line, theres an integer T(1 <= T<= 10,000) then Tcases follow.
Each test case theres an integer n(4 <= n<=10,000,000).
Output
For each test case, output xand ywith this fotmat: x*y. see the examples for more detail.
Example
Input:
6
4
10
15
20
321
1020
Output:
1*4
4*9
3*12
8*18
245*320
864*1014
Score is length of your code.

See also: Another problem added and recommended (new!) by Tjandra Satria Gunawan
Date:
2012-12-14
Time limit: 1s
Source limit:1000B
Cluster:
Languages: All

13016. "If Equal" in BF

Problem code: TSET
your task is simple... you will read tow numbers a,b then print 1 if a==b or print 0 if a!=b
a and b are one_digit_numbers {0,1,2,3,4,5,6,7,8,9}.
NOTE : The Only Available language For This Problem Is BrainF***.
Input
there are 10 test cases ... in each one there is:
one_digit_number a
followed by space
then one_digit_number b
followed by end_of_line charachter
Output
the logic value of a==b
Example
Input:4 78 89 70 1..Output:0100..Score is your Code Length.
Added by: Mostafa 36a2

Date:
2012-12-16
Time limit: 1s
Source limit:250B
Cluster:
Languages: BF
Resource: BF it self ^_^

13077. Fewest possible vertices to cover a graph

Problem code: VERCOVER
Let G be a graph with a set of n nodes and a set of m edges. A vertex cover VC is a subset of the
nodes, such that each edge in graph G is covered by at least one node in the subset. (One or both ends
of each edge must be in VC).
A minimal vertex cover is a vertex cover for G such that removing one of the nodes in the set causes at
least one edge in G to be uncovered.
In this task, you are given a undirected graph as the input, and you have to find as small as possible
vertex cover within the time limit. Your score is the average of ratios of the total number of nodes in
vertex covers to the total nodes in the graph for all of the test cases.
Input
The first line contains two integers, n and m, representing the numbers of nodes and edges in the
graph. 3 <= n <= 2000 and 3 <= m <= 40000. The nodes are numbered 1..n. The next m lines contain
pair of integers representing edges between two nodes. The list of edges is not in any particular order.
Output
There should be only one line of output, listing all valid nodes in the vertex cover you found in the
graph. The nodes are separated by one space.
Example
Input:6 71 21 52 32 53 43 65 6
Output:
5 3 2
Added by: Jimmy Tirtawangsa

Date:
2012-12-27
Time limit: 1s-15s
Source limit:50000B
Cluster:
Languages: All
Resource: http://en.wikipedia.org/wiki/Vertex_cover

13083. "If Bigger than" in BF

Problem code: BFBIGTHN
Brainf*** is a Turing complete language...
what ever the arithmatic/logic operation other langs like C or LISP can do ...BF can do it also !
your task is to write a BF code to test if a is Bigger Than b ..
Input:
tow_digit_number t (number of test cases)followed by end_of_line charachter
then t lines each of them contains:
tow_digit_number a
followed by space
then tow_digit_number b
followed by ASCII(10) (End of line).
(at the end of the file there is EOF charachter which value is (-1))
output:
the logic value of (a > b) for each test case
(dont forget to print any space after each output such like \n or \t or space )
Example:
inputs:
09
41 92
99 40
01 20
23 00
00 01
20 30
00 09
99 00
11 12
outputs:
0
1
0
1
0
0
0
1
0
BE CAREFUL: ONLY BRAINF*** AVAILABLE FOR SUBMIT .
ENJOY ;)
Note : maybe it will be helpful for you to know that a never equal to b in the test cases ;)
Date:
2012-12-27
Time limit: 1s-5s
Source limit:2000B
Cluster:
Languages: BF
Resource: BF it self ^_^

13172. Good
Problem code: GOV02
The problem is very easy.
You are given n terms ( the terms can be integer as well as floating ). Let S = sum of all the n terms. A
number k (x<=k<=y) is said to be good if S is divisible by it.
Input
Input begins with an integer t.
Then t test cases follow.
For each test case, three numbers n,x,y are given. Then n terms of the sequence follow.
(REMEMBER: all the input is on a single line)
Output
For each test case,
You have to output a single integer m.
where, m = (sum of all even good numbers) - ( number of all odd good numbers)
(REMEMBER: all the output should be on a single line)
The numbers should be separated by spaces.
Example
Input:
2 3 1 2 1 2 3 4 1 10.5 -1 4.5 4.5 4
Output:
1 10
Scoring:
Your task is to minimise the source code length.
The less your fingers work, more you gain.
Remember:
Only python 2.7 is permitted.Sorry in advance, I will not allow any other language.
Source limit is tight. So be careful.
Constraints:
1<=t<=10
1<=n<=100
-100<=any term of sequence<=100
0<x<=y<=100
Added by: Govind Lahoti

Date:
2013-01-07
Time limit: 0.5s
Source limit:200B
Cluster:
Languages: PYTH 2.7
Resource: self

13175. "a mod b" in BF

Problem code: BFMODULO
your task is simple ..find the answer of a mod b as fast as you can.
a and b are integers
0<=a<1000 and 0<b<10
Input:
integer a with leading zeroes
then space ASCII(32)
then b .. and EndOfLine ASCII(10)
output:
the value of(a mod b)
Example1:
input:
999 2
output:
1
Example2:
input:
005 6
output:
5
Example3:
input:
099 1
output:
0
Score:
Sometimes I enjoy writing lots of + in my code ..

but sometimes I prefer some thing like ++++[->++++<] to shorten it.
But With This New Judge, the first way is shorter.
This New BF_OPERTIONS_COUNTER counts how many BFoperations your implemintaion do ..
example..
code1 : +++++++++++++++.
code2 : +++[->+++++<]>.
as you see LengthOfcode2< LengthOfcode1
But .. the judge look at code2 like this:
+++[->+++++<]->+++++<]->+++++<]>.
and It will count these operators : +,-,<,> only
so : code1 will have score of 15
and code2 will have score of 28
Score is "how many +,-,>,< your code does at the run time"
BUT: since there is many test files ... and your code may expand or shorten as the judge see it ..
So the final Score will be your scores average ...
Thanks for Tjandra Satria Gunawan for his suggestion for the new judge .
note: you can see how the judge read your code at your submission info (only the first test file).
LAST UPDATE NOTE 15/1/2012:
Ive complete improving test files ... there is now 59 test files ,also now you can write 100,000 byte
code
after solving the problem,maybe you can see that MCLT: MORE CODE --> LESS TIME Wink
Enjoy :)
Date:
2013-01-07
Time limit: 1s
Cluster:
Languages: BF
Resource: FizzBuzz Happy 2013

13224. The BrainFast Processing! Challenge version

Problem code: FAST_BF2
Warning: Only Brainf**k language is allowed.
After I solve this problem in 0.00s using BF, I have an idea to set new BF problems, now here I come
Wink
The task is simple, given a <string>(1<="length of string"<=10) just check if the string is palindrome
or not.
The string contains character in range ASCII(97)<=char<=ASCII(122) (lower case alphabet)
Input
The first line, there is an integer T(1<=T<=100)denoting number of test cases then you should
process only next Tlines, each line is a <string> terminated by new line character (\n) ASCII(10)
Output
For each test case:
if <string> is palindrome, output: YES
else, output: NO
Example
Input:
2
aba
ab
Output:
YES
NO
Score
Score is length of your source.
If you TLE here, you may trythis problemfirst. If you got AC in 0.00s there you shoud got AC in
0.00s here too Wink
Date:
2013-01-10
Time limit: 0.009s
Source limit:1500B
Cluster:
Languages: BF
Resource: The Mirror of Galadriel Problem plus my own idea ;-)

13366. TWO KINGS

Problem code: CONQUER
TRIVIADOR
Triviador is a war between two Kings.
You are given a 3D matrix containing characters X and O.
X - The region is owned by King 1
O - The region is owned by King 2
A king can attack an enemy region at each step. When a king attacks a region, he conquers all the
enemy regions connected to it(not just the immediate neighbours). Every region is connected to all
the regions that share an edge or a corner with it. The kings get alternate chances to attack. King1 gets
the chance to attack first. Assume both kings are intelligent and find who will conquer the whole
territory at the end of the war. It can be proved that one of the Kings can win for sure if he is
intelligent!
Input Specification:
The first line consists of an integer t, which denotes the number of test cases. For each test case the
first line consists of three integers a, b, c denoting the dimentions of the territory (each cell is a region).
Then the description of each cell follows. Every region contains a character X if it is owned by king1
or O otherwise.
The description of the axbxc 3D matrix is represented by a bxc 2D matrixes.
Output Specification:
For each test case output the result in a single line X if king1 wins or O if king2 wins.
Input Constraints:
1<=t<=50
1<=a,b,c<=50
Sample Input:
3
235
OXOOO
OOXXX
XXXXO
<- empty line just for clarity.
XOXOO
XOOXO
OXXOX
116
OXOXXO
113
OOO
Sample Output:
X
O
O
Explanation:
Case 1: King 1 wins in his first move by attacking any enemy region.
Case 2: King 2 can win if he is intelligent.
Case 3: King 2 already won.
Try the 2D version of this problem : http://www.spoj.com/problems/TWOKINGS

Date:
2013-01-15
Time limit: 3s
Source limit:50000B
Cluster:
Languages: All except: BF

13418. Fibonacci factorization

Problem code: BMS1988
The Mysterious Affair at Byte Court
Hercule was quietly on hollydays (Nol) at Byte Court when Fibonacci and Lucas (well-dressed)
knocked at his door. They came in, and the first one said : "Monsieur, can you factorise my first 1001
terms, please?". Hercule said : "It was useless to come in to ask that, but since you are here, Ill do that
very quickly." Then Lucas said : "Its not a speed challenge, we like Styles too, the shorter your code
is, the best your score is."
Output
You have to output 1001 lines, the factorization of the 1001 first terms of the Fibonacci sequence. See
sample for output details.
Example
F(0)= 0
F(1)= 1
F(2)= 1
F(3)= 2
F(4)= 3
F(5)= 5
F(6)= 2^3
F(7)= 13
F(8)= 3 * 7
F(9)= 2 * 17
F(10)= 5 * 11
F(11)= 89
F(12)= 2^4 * 3^2
[...]
F(1000)= 3 * 5^3 * 7 * 11 [...]
Added by: Francky

Date:
2013-01-20
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All

13423. 64bit-Fibonacci
Problem code: FIB64
Warning
This task is intended to help people to debug their codes and try speed experiments.
The task is the same as in some known problems, but with new constraints and speed goal.
The Fibonacci sequence is defined for any positive integer number by : If N<2: Fib(N)=N, else
Fib(N)=Fib(N-1)+Fib(N-2)
You have the task of being the fastest to compute Fib(N) mod M.
Input
The input consists of 500000 lines. In each the 500000 lines there are two integer numbers N, M.
Output
For as many test cases you can, on a single line, print Fib(N) mod M.
Example
Input:
5 4
5 5
5 6
[...]
Output:
1
0
5
Constraints
0 <= N <= 10^18
2 <= M <= 10^18
Score
As in the example, if you can output the 3 first correct answers, your score will be 3 points. No need to
solve all the input, the minimum is 1 ; every solver in any language will be able to check his
FIB64-speed.
Added by: Francky
Date:
2013-01-20
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All

13872. The SPP constant challenge

Problem code: SPPC
Warning
This task can be easily solved with a O(log(N)) algorithm. Youll have to work on the constant to get
more points. This task should help you to try some speed improvements for problems like SPP, Snaky
Numbers, or Crack the Safe which share the context. Here, the keypad had been carefully chosen...
Have fun. You dont need to solve the whole input, just as many cases as you can. Not all, it could be
impossible. You will get one point per case. For your information, my 1.2kB-python3 code got 1789
points, whereas my fastest 2kB-C one got 109000 points. I just hope that limit is impossible to reach!
Surprise.
The Safe and its Lock

Since 1984, theres too many terrorists, so Leo have a very secured safe with a very long password. He
uses it to store all other passwords he needs. The only restriction of the password for that safe is that
every pair of neighboring keys in the password is adjacent on the keypad. Adjacent means that the
keys share a common edge. The secure door have a 66 lock which resembled this :
A
G
M
S
Y
5
B
H
N
T
Z
6
C
I
O
U
1
7
D
J
P
V
2
8
E
K
Q
W
3
9
F
L
R
X
4
0
[Enter]
[Enter] is not part of the password.

Now, given the length of the password, we just would like to know how many different possibilities
are there for the password.
Input
The input consists of 666666 lines. In each the 666666 lines there are two integer numbers N, M.
Output
For as many test cases you can, on a single line, print the number of different passwords of length N.
As the answer could be an enormous number, output the answer modulo M.
Example
Input:
1 10
2 100
987654321123456789 1000000000
[...]
Output:
6
20
831617808
Explanations
For a one key password, there are 36 possibilities, answer modulo 10 is 6. For a two keys password,
there are 120 possibilities, answer modulo 100 is 20. For the last case, the answer has around
510^1^7 digits, the nine last ones are 831617808.
Constraints
1 <= N <= 10^18
2 <= M <= 10^9
Theres one input file, and data are uniform-randomly chosen in their range.
Score
SPPconstant-speed.
Added by: Francky
Date:
2013-02-22
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All

13923. Fractionated morse cipher

Problem code: FMORSE1
Fractionated morse is a classic cipher:

The plaintext letters are in [A-Z] only with no punctuation.
Each letter of the plaintext is first enciphered using Morse code with "|" after every letter.
If the length of the resulting string is not multiple of three, you have to truncate the remaining
symbols.
Standard morse table:
A=.- B=-... C=-.-. D=-.. E=. F=..-. G=--. H=.... I=.. J=.--- K=-.- L=.-.. M=-N=-. O=--- P=.--. Q=--.- R=.-. S=... T=- U=..- V=...- W=.-- X=-..- Y=-.-- Z=--..
This series of [A-Z] and | letters is taken off in units of three, each trigraph set and
cipher letters assigned to each group using a keyword alphabet to obtain the ciphertext.
Fractionated morse table with keyword alphabet (key=ROUNDTABLE):
R=... O=..- U=..| N=.-. D=.-- T=.-| A=.|. B=.|- L=.|| E=-.. C=-.- F=-.| G=--.
H=--- I=--| J=-|. K=-|- M=-|| P=|.. Q=|.- S=|.| V=|-. W=|-- X=|-| Y=||. Z=||Your task is simple. You only will have to code the input message using the keyword.
You have to reduce the keyword by the alphabet:
(JIMMORRISON => JIMORSN reduced key)
Score is the source length.
Input
N testcases (no more than 100)
Each line of the input contains the keyword and a plaintext.
The keylength max is 100 and the length of the plaintext is limited to 200.
The last testcase ends with EOF.
Output
Output consist of exactly N lines of cyphertexts with letters in [A-Z] with no spaces.
Example
Input:JIMMORRISON RIDERSONTHESTORMINTOTHISHOUSEWEAREBORN
Output:
OQVNTNMGVXJNQAWKEHMELHKJQQNJWKSJURUSOUCAHOV
Added by: legrand

Date:
2013-02-27
Time limit: 1s-5s
Source limit:2000B
Cluster:
Languages: C C++ 4.3.2 C++ 4.0.0-8 C99 strict CAML PYTH 2.7 PYTH 3.2.3 PYTH 3.2.3 n
Resource: own

13929. Matrix Exponentiation

Problem code: MATEX
Many problems can be solved with matrix exponentiation. This task can be easily solved with a
O(log(N)) algorithm. Youll have to work on the constant to get more points. Well work with a
small matrix and constant modulo. This task should help you to try some speed improvements for
problems like R Numbers, Grid Tiling, and the great Flibonakki... You dont need to solve the whole
input, just as many cases as you can. Not all, it could be impossible. You will get one point per case.
There will be one input file and the matrix will have a size W = 18, unlike in the sample. For your
information, my fastest 3kB-C code got 190000 points, with 23MB of memory usage. (Lot of stuff!)
Input
The first line contains an integer number W : the size of the squared matrix. The W next lines contains
W integer numbers Mij : the coefficients of the matrix, line by line. In each the 838383 next lines there
are three integer numbers I, J, N. You dont have to read the whole input, just as many as you can
solve...
Output
For as many test cases you can, on a single line, print the coefficient on the Ith line, Jth column of the
matrix M^N (M to the power N). As the answer could be a big number, output the answer modulo
1000000007.
Example
Input:
5
32 82 7 66 30
57 1 28 2 89
53 66 6 35 61
45 87 88 24 20
35 22 23 80 93
1 1 1
1 5 2
5 1 3
5 5 99
[...]
Output:
32
12795
2714937
764817976
Explanations
For the first case: M^1 =
32
57
53
45
35
82 7 66 30
1 28 2 89
66 6 35 61
87 88 24 20
22 23 80 93
For the second case: M^2=

10089 9570 9060 6505 12795
6570 8655 2818 11912 11824
9486 9195 6738 9560 14203
12843 12113 5851 8400 16801
10448 13416 10178 12519 14660
For the third case: M^3=

2089068
1802809
2112086
2377555
2714937
2282253
2029855
2375941
2551827
2953573
1259668
1625446
1532239
1589794
1948704
2181834
1781368
2245976
2622329
2545886
3027095
2477165
3026032
3550751
3742082
Constraints
W
1
1
1
= 18
<= I,J <= W
<= Mij <= 10^9
<= N <= 10^18
Uniform-random input in the range.
Score
MATrix-EXponentiation-speed.
Added by: Francky
Date:
2013-02-27
Time limit: 1s
Source limit:50000B
Cluster:
Languages: All

14530. Quadratic primes

Problem code: GOV04
Euler published the remarkable quadratic formula:

n^2 + n + 41
It turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. However,
when n = 40, 402 + 40 + 41 = 40(40 + 1) + 41 is divisible by 41, and certainly when n = 41, 41^2 + 41
+ 41 is clearly divisible by 41.
Using computers, the incredible formula n^2 79n + 1601 was discovered, which produces 80 primes
for the consecutive values n = 0 to 79. The product of the coefficients, 79 and 1601, is 126479.
Considering quadratics of the form:
n^2 + an + b, where |a| 1000 and |b| 1000
where |n| is the modulus/absolute value of n
e.g. |11| = 11 and |4| = 4
Find the product of the coefficients, a and b, for the quadratic expression that produces the maximum
number of primes for consecutive values of n, starting with n = 0.
Euler published the remarkable quadratic formula:
n^2 + n + 41
It turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. However,
when n = 40, 40 2 + 40 + 41 = 40(40 + 1) + 41 is divisible by 41.
Using computers, the incredible formula n^2 - 79n + 1601 was discovered, which produces 80 primes
for the consecutive values n = 0 to 79. The absolute product of the
coefficients, 79 and 1601, is 126479.
We are interested in producing better quadratic formulas.( which produces more prime numbers )
Considering quadratics of the form:
n^2 + an + b, where |a| <= R and |b| <= R
( Your input will be the value of R )
where |n| is the modulus/absolute value of n
e.g. |11| = 11 and | - 4| = 4

Find a and b, for the quadratic expression that produces the maximum number of primes for
consecutive values of n, starting with n = 0.
If two different values of n produces same prime, then we consider those primes as different (i.e. we
count them twice) -- look at example.
Remember |a| <= R and |b| <= R
If you get multiple answers, choose the one having smallest value of a. Even then, if you get multiple
answers, choose the equation having smallest value of b.
Input
First line of input contains an integer t representing the number of test cases. Then t lines follows.
Each line contains an integer R.
t<=8000
R<=10000
Output
Output should be of the format:
Integer 1<space>@<space>Integer2
Integer 1: Number of primes equation n 2 +an+b produces for consecutive value of n, starting from
n=0.
Integer 2: absolute product of the coefficients, a and b.
Output of each test case should be on separate line.
Scoring
Lesser your fingers work, better it is. :-)
(Minimize your source code length)
Example
Input:
2
41
5
Output:
41 @ 41
5 @ 5
Explanation:
case 1: a=-1 b=41
case 2: a=-1 b=5 ( Here n=0 and n=1 produces same prime 5, but we will count it twice)
Added by: nice problem

Date:
2013-04-10
Time limit: 1s-2s
Source limit:10000B
Cluster:
Languages: All
Resource: Project euler

14808. Discrete Math Problem (shorten)

Problem code: GCD4
Warning: This problem looks like, but differs from GCD3 : GCD3 : (2 K -2) ---vs--- GCD4 : (2K-2)
Moreover, your challenge will be to shorten your code to get more points. GCD4 could be harder than
GCD3!
Input
The first line of input contains an integer T, the number of test cases. On each of the next T lines, your
are given three integers N, M and K such that: N = a + b M = a 2 + b 2 - (2K-2)ab
with a > 0, b > 0 and gcd(a, b) = 1.
Output
For each test case, you have to print gcd(N, M), the greatest common divisor.
Example
Input:
2
2214811 1451126169481 7
107603 9066347749 9
Output:
1
1
Note: For the first trio a = 117651 and b = 2097160. For the second a = 1313 and b = 106290.
Constraints
0
0
1
0
<
<
<
<
T
N
M
K
<
<
<
<
14321
10^200
10^200
17
For your information, my 293B C code get AC in 0.03s with 1.6MB of memory print. Size code limit
will be 666B. Language restrictions are quite the same than in GCD3, and it is justified ;-) Have fun
;-)
Added by: Francky

Date:
2013-05-03
Time limit: 1s
Source limit:666B
Cluster:
Languages: C C++ 4.3.2 C++ 4.0.0-8 C99 strict D FORT PAS fpc PAS gpc
Resource: GCD3

15036. Automatic Brainf##k Code Generator

(Shortening AI)
Problem code: BFK_AUTO
In this problem, youll make an automatic Brainf**k code generator. Given a text file (input data),
your program should output brainf**k code that if executed it will print the text file (exactly same with
given input data). The text file containts printable ASCII character only: { <line feed>(ASCII(10)) ,
<space>(ASCII(32)) , ... , ~(ASCII(126)) }. Its guaranteed that the filesize of text file is less than
1MB.
Input
Text file containing printable ASCII only with size<1MB.
Output
Brainf**k code that print that text file.
Score
Your score is: Sum of all BF code length in all test data
Example
Input:
Hello World!
Output:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Your Score (BF Code Length, valid command only):
111
Note: This is the first time I make my own judge, Ive tested it hundred times with various test data,
and so far no bug is found (found some but has been fixed). If you found a bug, you can send me info
via PM or email, Ill fix that as soon as possible. Btw, here is the judge for this problem, maybe itll be
useful information for you. Good Luck and Have Fun :-D
Added by: (Tjandra Satria Gunawan)(???)
Date:
2013-05-25
Time limit: 22s
Source limit:50000B
Cluster:
Languages: All
Resource: This problem is purely came from my own idea \(^_^)/

15619. Optimal Swap Sort

Problem code: SWAPSORT
One day, Budi is learning selection sort, He like this sort because the swap operation is always less
than nwhere nis number of element to be sorted. Budi is smart person, so he modify the algorithm
and make number of swap is as small as possible (Optimal). Now He want your help to analyze his
algo, He wonder what is the worst number of swap operation needed when His algo sort nelement(s)
with kdifferent element(s).
Input
The first line there is an integer Tdenoting number of test case.
Next Tlines there are two integers nand k for each line, n and khas been described above.
Output
For each test case, output an integer that is the desired answer that has been described above.
Constraints
1 <= T<= 10 5
1 <= k<= 10 9
k <= n <= 10 9
Example
Input:
3
1 1
2 1
2 2
Output:
0
0
1
Explanation
For first and second test case it has one different element so it already sorted, no need to do any swap
operation.
For second test case if the element is decreasing (this is the worst case), only one swap is needed, then
the sort is complete.
Other Info
Score is your source length.
Seems that its impossible to solve this problem using some programming languages e.g(Brainf**k,
Intercal, etc).
Click here to see my score for this problem (Link has been updated after rejudge)
Added by: (Tjandra Satria Gunawan)(???)
Date:
2013-08-11
Time limit: 10s
Source limit:200B
Cluster:
Languages: All

SPOJ Challenge

Uploaded by

Copyright:

Available Formats

SPOJ Challenge

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SPOJ Challenge

Uploaded by

Copyright:

Available Formats

Archives of the Sphere Online Judge

Last updated: 2013-08-12 14:10:38

Enjoy problem-solving at the Sphere Online Judge!

Problem KAMIL (53. Kamil)

Problem EXPR2 (2004. Analyse Simple Arithmetical Expressions)

93. Problem EPROBLEM (11849. A Very Easy Problem! (Challenge Mode))

SPOJ Problem Set (challenge)

Added by: Adam Dzedzej

SPOJ Problem Set (main)

72. Food Shortage in Byteland

Added by: Micha Maafiejski

SPOJ Problem Set (challenge)

126. Solovay-Strassen Inverted

will receive 3/log 10 561 = 1.091 points.

SPOJ Problem Set (challenge)

127. Johnny Goes Shopping

will score log 10 ((5+8+4)/(|8+4-5|+1))= 0.327 points.

Added by: Adrian Kosowski

SPOJ Problem Set (challenge)

155. Solving the Puzzle

Added by: Pawel Gawrychowski

SPOJ Problem Set (challenge)

218. Points on a Sphere

Added by: Adrian Kosowski

SPOJ Problem Set (challenge)

219. Pawns Gone Wild

will receive 5 points.

SPOJ Problem Set (challenge)

222. The Burning City

SPOJ Problem Set (challenge)

225. Nightmare in the Towers of Hanoi

SPOJ Problem Set (challenge)

232. Bytelandian Telecom

SPOJ Problem Set (challenge)

240. Santa Claus and the Presents

Added by: Krzysztof Kluczek

SPOJ Problem Set (challenge)

246. Plant a Christmas Tree

SPOJ Problem Set (challenge)

will be awarded with 33 points.

SPOJ Problem Set (set6)

SPOJ Problem Set (challenge)

285. Atomic Shelters

SPOJ Problem Set (challenge)

289. The Turing Music Box

Then the results of exemplary testing could be as follows:

SPOJ Problem Set (set7)

294. Johnny and the Optimisation of Homework

Added by: Micha Maafiejski

SPOJ Problem Set (set8)

295. Bytelandian Origami

Added by: Micha Maafiejski

SPOJ Problem Set (challenge)

298. Closing down Railway Lines

Illustration to sample test data

SPOJ Problem Set (challenge)

313. The Game of Crosses & Crosses

Illustration to sample test data

SPOJ Problem Set (challenge)

will be awarded with 6 points.