German Collegiate

Programming Contest 2015

June 20th

Problems
A A Journey to Greece
B Bounty Hunter II
C Cake
D Carpets
E Change of Scenery
F Divisions
G Extreme Sort
H Legacy Code
I Milling machines
J Souvenirs
K Upside down primes

Sponsored by
This page is intentionally left (almost) blank.
 Problem A: A Journey to Greece
For a long time Tim wanted to visit Greece. He has already purchased his flight to and from
Athens. Tim has a list of historical sites he wants to visit, e.g., Olympia and Delphi. However,
due to recent political events in Greece, the public transport has gotten a little complicated. To
make the Greek happy and content with their new government, many short-range bus and train
lines have been created. They shall take the citizens around in their neighborhoods, to work or
to their doctor. At the same time, long-range trains that are perfect for tourists have been closed
down as they are too expensive. This is bad for people like Tim, who really likes to travel by
train. Moreover, he has already purchased the Greece’ Card for Public Conveyance (GCPC)
making all trains and buses free for him.

taxi 5

stay 2
3
4 2
1 2 6 3

2 10
stay 2 5 3 1 stay 2
5 2
2

0 Athens

Figure A.1: Visual representation of the Sample Input: Tim’s tour has length 18.

Despite his preferred railway lines being closed down, he still wants to make his travel trough
Greece. But taking all these local bus and train connections is slower than expected, so he wants
to know whether he can still visit all his favorite sites in the timeframe given by his flights. He
knows his schedule will be tight, but he has some emergency money to buy a single ticket for a
special Greek taxi service. It promises to bring you from any point in Greece to any other in a
certain amount of time.
For simplicity we assume, that Tim does never have to wait for the next bus or train at a station.
Tell Tim, whether he can still visit all sites and if so, whether he needs to use this taxi ticket.

Input
The first line contains five integers N , P , M , G and T , where N denotes the number of places
in Greece, P the number of sites Tim wants to visit, M the number of connections, G the total
amount of time Tim can spend in Greece, and T the time the taxi ride takes (1 ≤ N ≤ 2 · 104 ;
1 ≤ P ≤ 15; 1 ≤ M, G ≤ 105 ; 1 ≤ T ≤ 500).
Then follow P lines, each with two integers pi and ti , specifying the places Tim wants to visit
and the time Tim spends at each site (0 ≤ pi < N ; 1 ≤ ti ≤ 500). The sites pi are distinct from
each other.
Then follow M lines, each describing one connection by three integers si , di and ti , where si
and di specify the start and destination of the connection and ti the amount of time it takes
(0 ≤ si , di < N ; 1 ≤ ti ≤ 500).
All connections are bi-directional. Tim’s journey starts and ends in Athens, which is always the
place 0.

GCPC 2015 – Problem A: A Journey to Greece 1

Output
Print either “impossible”, if Tim cannot visit all sites in time, “possible without
taxi”, if he can visit all sites without his taxi ticket, or “possible with taxi”, if he
needs the taxi ticket.
Sample Input 1 Sample Output 1
6 3 10 18 5 possible with taxi
1 2
4 2
5 2
0 1 2
1 2 3
2 4 3
1 3 10
2 3 6
0 3 2
3 4 2
4 5 1
3 5 2
0 5 5

GCPC 2015 – Problem A: A Journey to Greece 2

 Problem B: Bounty Hunter II
Spike the bounty hunter is tracking another criminal through space. Luckily for him hyperspace
travel has made the task of visiting several planets a lot easier. Each planet has a number of
Astral Gates; each gate connects with a gate on another planet. These hyperspace connections
are, for obvious safety reasons, one-way only with one gate being the entry point and the other
gate being the exit point from hyperspace. Furthermore, the network of hyperspace connections
must be loop-free to prevent the Astral Gates from exploding, a tragic lesson learned in the gate
accident of 2022 that destroyed most of the moon.
While looking at his star map Spike wonders how many friends he needs to conduct a search on
every planet. Each planet should not be visited by more than one friend otherwise the criminal
might get suspicious and flee before he can be captured. While each person can start at a planet
of their choosing and travel along the hyperspace connections from planet to planet they are still
bound by the limitations of hyperspace travel.

0 4

0 1 2 1 2 5

3 3

Figure B.1: Illustration of the Sample Inputs.

Input
The input begins with an integer N specifying the number of planets (0 < N ≤ 1000). The
planets are numbered from 0 to N −1. The following N lines specify the hyperspace connections.
The i-th of those lines first contains the count of connections K (0 ≤ K ≤ N − 1) from planet i
followed by K integers specifying the destination planets.

Output
Output the minimum number of persons needed to visit every planet.

Sample Input 1 Sample Output 1

4 2
1 1
1 2
0
1 1

Sample Input 2 Sample Output 2

6 4
0
1 2
2 4 5
1 2
0
0

GCPC 2015 – Problem B: Bounty Hunter II 3

This page is intentionally left (almost) blank.
 Problem C: Cake
Sophie loves to bake cakes and share them with friends. For the wedding of her best friend Bea
she made a very special cake using only the best ingredients she could get and added a picture of
the engaged couple on top of the cake. To make it even more special she did not make it round
or square, but made a custom convex shape for the cake. Sophie decided to send the cake by a
specialized carrier to the party. Unfortunately, the cake is a little too heavy for their default cake
package and the overweight fees are excessive. Therefore, Sophie decides to remove some parts
of the cake to make it a little lighter.
Sophie wants to cut the cake the following way: First, she chooses a real number s ≥ 2. For
each vertex and each incident edge of the cake she marks where 1/s of the edge’s length is.
Afterwards, she makes a direct cut between the two markings for each vertex and removes the
vertex that way.

3 1
4 4

1
4

3
4

(a) Cutting the upper-right corner of a (b) Cutting a cake with s = 3

rectangle with s = 4

Figure C.1: Illustration of the first two Sample Inputs.

Sophie does not want to cut more from the cake than necessary for obvious reasons. Can you
tell her how to choose s?

Input
The first line contains a floating point number a and an integer N , where a denotes the ratio of
the cake’s weight allowed by the carrier and N the number of vertices of the cake (0.25 ≤ a < 1;
3 ≤ N ≤ 100). a will be specified with at most 7 digits after the decimal point.
Then follow N lines, each describing one of the cake’s vertices with two integers xi and yi , the
coordinates of the vertex (0 ≤ xi , yi ≤ 108 for all 1 ≤ i ≤ N ). The vertices are given in the
order in which they form a strictly convex shape.
You may safely assume that the weight is uniformly distributed over the area of the cake.
Furthermore, it will always be possible to cut the cake with some 2 ≤ s ≤ 1000 such that the
proportion of the remaining cake is a of the original weight.

Output
Print a line containing s, the biggest value as specified above such that the remaining cake’s
weight is at most the proportion a of its original weight.
Your answer will be considered correct if the absolute error is at most 10−4 .

GCPC 2015 – Problem C: Cake 5

Sample Input 1 Sample Output 1
0.875 4 4.000000
0 0
8 0
8 4
0 4

Sample Input 2 Sample Output 2

0.85 5 3.000000
6 0
12 6
9 12
0 12
3 3

Sample Input 3 Sample Output 3

0.999998 4 1000.000000
20008 10000
15004 15005
10001 20009
15005 15004

GCPC 2015 – Problem C: Cake 6

 Problem D: Carpets
The computer science Professor Toving Liles loves the floor tiles in his office so much that he
wants to protect them from damage by careless students. Therefore, he would like to buy cheap
small rectangular carpets from the supermarket and cover the floor such that:

1. The entire floor is covered.

2. The carpets do not overlap.

3. The carpets are rotated arbitrarily.

4. No carpet is cut into pieces.

But when checking the supermarket’s stock he begins to wonder whether he can accomplish his
plan at all. Can you help him?

Input
The first line contains two integers W and H describing the size of his room (1 ≤ W, H ≤ 100).
The second line contains an integer c, denoting the number of different carpet colors the
supermarket has in stock (1 ≤ c ≤ 7).
Each of the following c lines consists of three integers ai , wi , and hi , which means: the
supermarket’s stock contains ai carpets of size wi , hi and color i (1 ≤ ai ≤ 7; 1 ≤ wi ≤ 100;
1 ≤ hi ≤ 100). P
The supermarket has at most 7 carpets, i.e. i ai ≤ 7.

Output
For the given room dimensions and the supermarket’s stock of carpets, print “yes” if it is
possible to cover the room with carpets as specified above and “no” otherwise.

Sample Input 1 Sample Output 1

2 4 yes
2
3 1 3
2 2 1

Sample Input 2 Sample Output 2

100 100 no
3
4 42 42
1 100 16
1 32 42

GCPC 2015 – Problem D: Carpets 7

This page is intentionally left (almost) blank.
 Problem E: Change of Scenery
Every day you drive to work using the same roads as it is the shortest way. This is efficient, but
over time you have grown increasingly bored of seeing the same buildings and junctions every
day. So you decide to look for different routes. Of course you do not want to sacrifice time, so
the new way should be as short as the old one. Is there another way that differs from the old one
in at least one street?

Input
The first line of the input starts with three integers N M and K, where N is the number of
junctions and M is the number of streets in your city, and K is the number of junctions you pass
every day (1 ≤ K ≤ N ≤ 10 000, 0 ≤ M ≤ 1 000 000).
The next line contains K integers, the (1-based) indices of the junctions you pass every day. The
first integer in this line will always be 1, the last integer will always be N . There is a shortest
path from 1 to N along the K junctions given.
M lines follow. The i-th of those lines contains three integers ai bi ci and describes a street from
junction ai to junction bi of length ci (1 ≤ ai , bi ≤ N , 1 ≤ ci ≤ 10 000). Streets are always
undirected.
Note that there may be multiple streets connecting the same pair of junctions. The shortest path
given uses for every pair of successive junctions a and b a street of minimal length between a
and b.

Output
Print one line of output containing “yes” if there is another way you can take without losing
time, “no” otherwise.

Sample Input 1 Sample Output 1

3 3 3 yes
1 2 3
1 2 1
2 3 2
1 3 3

Sample Input 2 Sample Output 2

4 5 2 no
1 4
1 2 2
2 4 1
1 3 1
3 4 2
1 4 2

GCPC 2015 – Problem E: Change of Scenery 9

This page is intentionally left (almost) blank.
 Problem F: Divisions
David is a young boy and he loves numbers. Recently he learned how to divide two numbers.
David divides the whole day. He is happy if the result of the division is an integer, but he is not
very amused if this is not the case. After quite a while he decided to use only a single dividend
each day.

The parents of David are very careful and they would like to ensure that David experiences
enough happiness. Therefore they decide which number David will use as the dividend for this
day.

There is still a problem: The parents are not very good at math and don’t know how to calculate
the number of positive integral divisors for a given dividend N , which lead to an integral result.
Now it’s up to you to help David’s parents.

Input
The single input line contains the single integer N , where N is chosen as a dividend (1 ≤ N ≤
1018 ).

Output
Print the number of positive integral divisors of N that lead to an integral result of the division.

Sample Input 1 Sample Output 1

12 6

Sample Input 2 Sample Output 2

999999999999999989 2

Sample Input 3 Sample Output 3

100000007700000049 4

GCPC 2015 – Problem F: Divisions 11

This page is intentionally left (almost) blank.
 Problem G: Extreme Sort
John likes sorting algorithms very much. He has studied quicksort, merge sort, radix sort, and
many more.
A long time ago he has written a lock-free parallel string sorting program. It was a combination
of burstsort and multi-key quicksort. To implement burstsort you need to build a tree of buckets.
For each input string you walk through the tree and insert part of the string into the right bucket.
When a bucket fills up, it "bursts" and becomes a new subtree (with new buckets).

Figure G.1: Burstsort data structure

Well, enough about the past. Today John is playing with sorting algorithms again. This time it’s
numbers. He has an idea for a new algorithm, “extreme sort”. It’s extremely fast, performance
levels are OVER NINETHOUSAND. Before he tells anyone any details, he wants to make sure
that it works correctly.
Your task is to help him and verify that the so-called extreme property holds after the first phase
of the algorithm. The extreme property is defined as min (xi,j ) ≥ 0, where
(
aj − ai for 1 ≤ i < j ≤ N
xi,j =
9001 otherwise

Input
The first line contains a single integer N (1 ≤ N ≤ 1024). The second line contains N integers
a1 a2 . . . aN (1 ≤ ai ≤ 1024).

Output
Print one line of output containing “yes” if the extreme property holds for the given input, “no”
otherwise.
Sample Input 1 Sample Output 1
2 yes
1 2

Sample Input 2 Sample Output 2

4 no
2 1 3 4

GCPC 2015 – Problem G: Extreme Sort 13

This page is intentionally left (almost) blank.
 Problem H: Legacy Code
Once again you lost days refactoring code, which never runs in the first place. Enough is enough
– your time is better spent writing a tool that finds unused code!
Your software is divided into packages and executables. A package is a collection of meth-
ods. Executables are packages defining among other methods exactly one method with name
PROGRAM. This method is executed on the start of the corresponding executable. Ordinary
packages have no method named PROGRAM.
Each method is uniquely identified by the combination of package and method names. E.g.
the method with the identifier SuperGame::PROGRAM would be the main method of the
executable SuperGame.
For every method in your software you are given a list of methods directly invoking it. Thus you
can easily identify methods, that are never called from any method. However, your task is more
challenging: you have to find unused methods. These are methods that are never reached by the
control flow of any executable in your software.

Input
The first line of the input contains an integer N , the number of methods in your software
(1 ≤ N ≤ 400).
Each method is described by two lines, totaling in 2 · N lines. The first line consists of the unique
identifier of the method and ki , the number of methods directly invoking this one (0 ≤ ki ≤ N ).
The second line consists of a set of ki identifiers of these calling methods or is empty if there are
no such methods, i.e. ki = 0.
Method identifiers consist of a package name followed by two colons and a method name
like Packagename::Methodname. Both strings, the package and the method name, each
consist of up to 20 lowercase, uppercase characters or digits (a-z, A-Z, 0-9).
There will be exactly N different method identifiers mentioned in the input.

Output
A line containing the number of unused methods in your software.

Sample Input 1 Sample Output 1

2 0
SuperGame::PROGRAM 0

HelpPackage::HelpFunction 2
HelpPackage::HelpFunction SuperGame::PROGRAM

Sample Input 2 Sample Output 2

2 2
Loop::CallA 1
Loop::CallB
Loop::CallB 1
Loop::CallA

GCPC 2015 – Problem H: Legacy Code 15

Sample Input 3 Sample Output 3
2 0
SuperGame::PROGRAM 1
SuperServer42::PROGRAM
SuperServer42::PROGRAM 1
SuperServer42::PROGRAM

GCPC 2015 – Problem H: Legacy Code 16

 Problem I: Milling machines
A fab lab is an open, small-scale workshop where you
can create or fabricate almost anything you want mostly
by using computer controlled tools like a laser cutter
or a 3D printer. The FAU fab lab recently got a CNC
milling machine. Using the milling machine you can
cut or remove material with different tools from the
surface of a workpiece. It is controlled via a computer
program.
I sometimes wondered what happens if multiple differ-
ent shaped workpieces are sent through the same milling Photo by aurelie ghalim on Flickr
program. For simplification assume that we have only
two dimensional workpieces without holes. A milling program consists of multiple steps; each
step describes where the milling machine has to remove material (using different tools) from the
top of the surface.

Input
The first line consists of two integers W and S, where W gives the number of workpieces and
S the number of steps in the milling program (1 ≤ W, S ≤ 104 ). The next line consists of
two integers X and Y , where X gives the width and Y gives the maximal possible height of
workpieces (1 ≤ X, Y ≤ 100).
Then follow W lines, each describing one workpiece. Each workpiece description consists of X
non-negative integers specifying the surface height in that column.
Then follow S lines, each describing one milling step of the milling progam. Each milling
step description consists of X non-negative integers si (0 ≤ si ≤ Y ) specifying the amount of
surface to cut off in each column (relative to the height of the milling area, i.e. Y , not relative to
the top of the workpiece). See Fig. I.1 for details.

Output
For each workpiece, output one line containing X integers specifying the remaining surface
heights (in the same order as in the input).

Figure I.1: Second workpiece in first sample: initial workpiece followed by milling in each
column – the value in the milling program determines the vertical position of the cutter head.

Sample Input 1 Sample Output 1

2 1 2 1 4
3 4 2 1 3
4 4 4
4 2 3
2 3 0

GCPC 2015 – Problem I: Milling machines 17

Sample Input 2 Sample Output 2
1 3 11 0 33 0 42 0 42 0 34 0
10 100
11 22 33 44 55 66 77 88 99 100
1 100 1 100 1 100 1 100 1 100
58 58 58 58 58 58 58 58 58 58
42 42 42 42 42 42 42 42 66 42

GCPC 2015 – Problem I: Milling machines 18

 Problem J: Souvenirs
You are on vacation in a country, where only two types of coins are used: silver and gold. The
relative value of one gold coin compared to the number of silver coins has to be big, because
there are only these two coin types. Although this is quite unhandy for the merchants, they do
not want to deal with a third coin type.
Their idea is that the value of the silver coins is changed in a way that a gold coin is worth less
silver coins. To make a statement they tie up silver coins in packages and will give change only
in gold coins and packaged silver coins but no single silver coins. However, they do not change
their prices to multiples of the silver package values.
So the merchants have to round the change. Different merchants use different rounding methods.
Honest merchants round to the nearest value and up if equal. Greedy merchants always round
downwards. Generous merchants round always upwards. The merchants also did not negotiate
on one package size, so they might all be different. But they are always an integral factor of the
current gold coin value in silver coins.
You have some gold coins left and want to buy as many souvenirs as possible. You already know
the different prices of all merchants at the market (the price is lower than what one gold coin is
worth) and which merchant is greedy, generous and honest as well as their silver coin package
sizes. You only have time to go over the market once, so you need to visit the merchants in the
given order. Furthermore, you do not want to exploit generous merchants. Thus, if you can pay
the exact price, you do so; otherwise you pay with exactly one gold coin. You pay the other
merchants either the exact prize or with exactly one gold coin. You buy at most one souvenir at
each merchant. Then, you unpack the change, i.e. the silver coin packages, so you can use the
coins separately.
For example in the third test case you skip the first merchant and buy at the second one with a
gold coin. Because you cannot pay the third merchant exactly, you use a gold coin again. With
the change of the two purchases (six and eight silver coins) you can pay the souvenirs at the
remaining three merchants.

Input
The first line contains three integers g, c, and n, where g denotes the value of one gold coin in
silver coins, c denotes the number of gold coins you have and n the number of merchants on the
market (1 < g ≤ 100, 1 ≤ c, n ≤ 100).
Then follow n lines each describing one merchant. Each of these lines starts with a string
“greedy”, “honest” or “generous” describing the rounding habit of the merchant. The
string is followed by two integers pi and si , where pi denotes the package size of silver coins
the merchant uses and si specifies the prices of the souvenir at that merchant in silver coins
(1 ≤ pi ≤ g, 1 ≤ si < g).

Output
One line containing the maximal number of souvenirs you can buy.

Sample Input 1 Sample Output 1

42 1 2 2
generous 21 41
honest 6 21

GCPC 2015 – Problem J: Souvenirs 19

Sample Input 2 Sample Output 2
42 1 2 1
honest 21 11
generous 6 23

Sample Input 3 Sample Output 3

12 2 6 5
greedy 1 5
greedy 1 6
generous 4 7
greedy 4 6
greedy 6 6
honest 2 2

GCPC 2015 – Problem J: Souvenirs 20

 Problem K: Upside down primes
Last night, I must have dropped my alarm clock. When the alarm went off in the morning, it
showed 51:80 instead of 08:15. This made me realize that if you rotate a seven segment
display like it is used in digital clocks by 180 degrees, some numbers still are numbers after
turning them upside down.

Figure K.1: Prime number 18115211 on a seven segment display (see third sample).

Figure K.2: 18115211 turned upside down (i.e. rotated by 180 degrees) gives 11251181, which
is not prime.

As you can see,

• , , , and still are , , , and .

• is still readable as (only moved left).

• turns into , while turns into .

• , and are no longer valid numbers ( , and )

My favourite numbers are primes, of course. Your job is to check whether a number is a prime
and still a prime when turned upside down.

Input
One line with the integer N in question (1 ≤ N ≤ 1016 ). N will not have leading zeros.

Output
Print one line of output containing “yes” if the number is a prime and still a prime if turned
upside down, “no” otherwise.

Sample Input 1 Sample Output 1

151 yes

Sample Input 2 Sample Output 2

23 no

Sample Input 3 Sample Output 3

18115211 no

GCPC 2015 – Problem K: Upside down primes 21

This page is intentionally left (almost) blank.
 2015 German Collegiate Programming Contest (GCPC 15) + Poland Problems

Problem L. Treasure
Input file: standard input
Output file: standard output

King Byteasar had hidden a treasure in his castle, and he kept his hiding place in secret. However,
whenever he went to war he was afraid he could die and the treasure would get lost. Therefore he chose
trustworthy guards and confided partial information needed to find the treasure to each of them. Next
he ordered them to go to the underground vaults that lie under the castle and to walk there using the
right-hand rule. The vaults were connected by corridors. The corridors did not cross outside the vaults
but they could run under other corridors. There were no corridors leading to the same vault they led off.
The right-hand rule stated that a guard after entering a vault left it by the next corridor to the right.
The guards were appointed different starting positions at entrances to corridors. It might happen that
many guards started from the same vault, unless they were entering the same corridor.
The king knew that until he fell or returned from war all guards would loyally follow his orders. However,
he was aware that whenever any two or more guards met in some vault they could not resist sharing all
the information they knew about the treasure. The guards were not selfish and they shared information
even if some of them would not learnt anything new. If some guards started from the same vault they
immediately shared the information they initially knew. If they passed one another in corridors, however,
they did not talk.
The king pondered if the treasure would still be secure when he safely returned from war. He wanted to
know which guards might obtain all the information needed to find the treasure.
Write a program which:

• reads from the standard input the description of the castle basement, the starting positions of the
guards and information each of the guards initially knows,

• determines the guards who could ever know all the information needed to find the treasure,

• writes to the standard output the numbers of those guards.

Input
In the first line of the standard input there is one integer n. That is the number of the underground
vaults, 2 ≤ n ≤ 100. The vaults are numbered from 1 to n. In the following n lines corridors connecting
the vaults are described. In the (i + 1)-st line the corridors leading off the i-th vault are described in
clockwise order. In each of those lines there are integers separated by single spaces. The first of those
numbers, ki , is the number of corridors leading off the i-th vault, 1 ≤ ki ≤ n − 1. It is followed, in
the same line, by 2ki integers: each leading off corridor is described by two integers. The former is the
number of the vault the corridor leads to, and the latter is the length of the corridor: an integer in the
range from 1 to 100. The corridors are two-way, i.e. if from a vault a a corridor of length l leads to
a vault b then from the vault b a corridor of length l leads to the vault a. Each pair of vaults may be
connected by at most one corridor. A guard to walk along a corridor needs exactly the amount of time
that is equal to the length of that corridor. We assume the time guards spend in vaults negligible.
In the (n + 2)-nd line there are written two integers k and l, 1 ≤ k, l ≤ 100, where k is the number
of guards, and l is the number of pieces of information needed to find the treasure. The guards are
numbered from 1 to k. The pieces of information concerning the treasure are numbered from 1 to l. The
guards are described in the following k lines (the i-th guard is described in the (i + n + 2)-nd line). Each
of those lines consists of integers separated by single spaces. The first integer in a line is the number of
the vault the corresponding guard starts from. The second number is the number of the vault the guard
goes to first. The third number, mi , is the number of pieces of information concerning the treasure the
i-th guard initially knows, 0 ≤ mi ≤ l. The following mi integers in the line are the numbers of the pieces
of information initially known to the i-th guard.

Page 23 of 25
 2015 German Collegiate Programming Contest (GCPC 15) + Poland Problems

Output
In the first line of the standard output your program should write one integer: the number of guards
who could ever know all the information needed to find the treasure. In the following lines there should
be written the numbers of those guards in ascending order, one number per line.

Sample input and output

standard input standard output
4 2
3 2 3 3 4 4 1 2
2 1 3 3 1 3
3 4 3 1 4 2 1
2 1 1 3 3
3 4
1 4 2 2 3
3 1 2 1 2
3 4 2 3 4

Page 24 of 25
 2015 German Collegiate Programming Contest (GCPC 15) + Poland Problems

Problem M. Sums
Input file: standard input
Output file: standard output

We are given a set of positive integers A. Consider a set of non-negative integers A′ , such that a number
x belongs to A if and only if x is a sum of some elements from A (the elements may be repeated). For
example, if A = {2, 5, 7}, then sample numbers belonging to the set A′ are: 0 (the sum of 0 elements), 2,
4 (2 + 2) and 12(5 + 7 or 7 + 5 or 2 + 2 + 2 + 2 + 2 + 2); and the following do not belong to A′ : 1 and 3.
Write a program which:

• reads from the standard input the description of the set A and the sequence of numbers bi ,

• for each number bi determines whether it belongs to the set A′ ,

• writes the result to the standard output.

Input
In the first line there is one integer n: the number of elements of the set A, 1 ≤ n ≤ 50000. The following
n lines contain the elements of the set A, one per line. In the (i + 1)-st line there is one positive integer
ai , 1 ≤ ai ≤ 50000. A = {a1 , a2 , . . . , an }, a1 < a2 < · · · < an .
In the (n + 2)-nd line there is one integer k, 1 ≤ k ≤ 10000. Each of the following k lines contains one
integer in the range from 0 to 109 , they are respectively the numbers bi .

Output
The output should consist of k lines. The i-th line should contain the word TAK (“yes” in Polish), if bi
belongs to A′ , and it should contain the word NIE (“no”) otherwise.

Sample input and output

standard input standard output
3 TAK
2 NIE
5 TAK
7 TAK
6 NIE
0 TAK
1
4
12
3
2

Page 25 of 25