MatrixStudio/Codeforces-Python-Submissions

96

A

Football

PROGRAMMING

900

[ "implementation", "strings" ]

A. Football

2

256

Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A zero corresponds to players of one team; a one corresponds to players of another team. If there are at least 7 players of some team standing one after another, then the situation is considered dangerous. For example, the situation 00100110111111101 is dangerous and 11110111011101 is not. You are given the current situation. Determine whether it is dangerous or not.

The first input line contains a non-empty string consisting of characters "0" and "1", which represents players. The length of the string does not exceed 100 characters. There's at least one player from each team present on the field.

Print "YES" if the situation is dangerous. Otherwise, print "NO".

[ "001001\n", "1000000001\n" ]

[ "NO\n", "YES\n" ]

none

500

[ { "input": "001001", "output": "NO" }, { "input": "1000000001", "output": "YES" }, { "input": "00100110111111101", "output": "YES" }, { "input": "11110111111111111", "output": "YES" }, { "input": "01", "output": "NO" }, { "input": "10100101", "output": "NO" }, { "input": "1010010100000000010", "output": "YES" }, { "input": "101010101", "output": "NO" }, { "input": "000000000100000000000110101100000", "output": "YES" }, { "input": "100001000000110101100000", "output": "NO" }, { "input": "100001000011010110000", "output": "NO" }, { "input": "010", "output": "NO" }, { "input": "10101011111111111111111111111100", "output": "YES" }, { "input": "1001101100", "output": "NO" }, { "input": "1001101010", "output": "NO" }, { "input": "1111100111", "output": "NO" }, { "input": "00110110001110001111", "output": "NO" }, { "input": "11110001001111110001", "output": "NO" }, { "input": "10001111001011111101", "output": "NO" }, { "input": "10000010100000001000110001010100001001001010011", "output": "YES" }, { "input": "01111011111010111100101100001011001010111110000010", "output": "NO" }, { "input": "00100000100100101110011001011011101110110110010100", "output": "NO" }, { "input": "10110100110001001011110101110010100010000000000100101010111110111110100011", "output": "YES" }, { "input": "00011101010101111001011011001101101011111101000010100000111000011100101011", "output": "NO" }, { "input": "01110000110100110101110100111000101101011101011110110100100111100001110111", "output": "NO" }, { "input": "11110110011000100111100111101101011111110100010101011011111101110110110111", "output": "YES" }, { "input": "100100010101110010001011001110100011100010011110100101100011010001001010001001101111001100", "output": "NO" }, { "input": "111110010001011010010011111100110110001111000010100011011100111101111101110010101111011110000001010", "output": "NO" }, { "input": "111110111100010100000100001010111011101011000111011011011010110010100010000101011111000011010011110", "output": "NO" }, { "input": "1011110110111010110111111010010010100011111011110000011000110010011110111010110100011010100010111000", "output": "NO" }, { "input": "0010100111100010110110000011100111110100111110001010000100111111111010111100101101010101001011010110", "output": "YES" }, { "input": "1111010100010100101011101100101101110011000010100010000001111100010011100101010001101111000001011000", "output": "NO" }, { "input": "0101100011001110001110100111100011010101011000000000110110010010111100101111010111100011101100100101", "output": "YES" }, { "input": "0001101110011101110000000010011111101001101111100001001010110000110001100000010001111011011110001101", "output": "YES" }, { "input": "1000010000100000100010000100001000010000100001000010000100001000010000100001000010000100001000010000", "output": "NO" }, { "input": "1000000000100000000010000000001000000000100000000010000000001000000000100000000010000000001000000000", "output": "YES" }, { "input": "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "YES" }, { "input": "1111111111111111111111111111111111111111011111111111111111111111111111111111111111111111111111111111", "output": "YES" }, { "input": "10100101000", "output": "NO" }, { "input": "11110111011101", "output": "NO" }, { "input": "10000000", "output": "YES" }, { "input": "00000001", "output": "YES" }, { "input": "01111111", "output": "YES" }, { "input": "11111110", "output": "YES" } ]

1,667,223,273

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

62

0

#!/usr/bin/env python3 """ """ listInput = [] listInput[:] = input() zeroCount = 0 oneCount = 0 dangrous = False for i in range(len(listInput) - 1): if listInput[i] == '0': if listInput[i + 1] == '1' and zeroCount == 7: dangrous = True break if listInput[i + 1] == '1' and zeroCount < 7: zeroCount = 0 else: zeroCount += 1 continue if listInput[i] == "1": if listInput[i + 1] == '0' and oneCount == 7: dangrous = True break if listInput[i + 1] == '0' and oneCount < 7: oneCount = 0 else: oneCount += 1 continue if dangrous == True: print("YES") else: print("NO")

Title: Football Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A zero corresponds to players of one team; a one corresponds to players of another team. If there are at least 7 players of some team standing one after another, then the situation is considered dangerous. For example, the situation 00100110111111101 is dangerous and 11110111011101 is not. You are given the current situation. Determine whether it is dangerous or not. Input Specification: The first input line contains a non-empty string consisting of characters "0" and "1", which represents players. The length of the string does not exceed 100 characters. There's at least one player from each team present on the field. Output Specification: Print "YES" if the situation is dangerous. Otherwise, print "NO". Demo Input: ['001001\n', '1000000001\n'] Demo Output: ['NO\n', 'YES\n'] Note: none

```python #!/usr/bin/env python3 """ """ listInput = [] listInput[:] = input() zeroCount = 0 oneCount = 0 dangrous = False for i in range(len(listInput) - 1): if listInput[i] == '0': if listInput[i + 1] == '1' and zeroCount == 7: dangrous = True break if listInput[i + 1] == '1' and zeroCount < 7: zeroCount = 0 else: zeroCount += 1 continue if listInput[i] == "1": if listInput[i + 1] == '0' and oneCount == 7: dangrous = True break if listInput[i + 1] == '0' and oneCount < 7: oneCount = 0 else: oneCount += 1 continue if dangrous == True: print("YES") else: print("NO") ```

0

535

A

Tavas and Nafas

PROGRAMMING

1,000

[ "brute force", "implementation" ]

null

Today Tavas got his test result as an integer score and he wants to share it with his girlfriend, Nafas. His phone operating system is Tavdroid, and its keyboard doesn't have any digits! He wants to share his score with Nafas via text, so he has no choice but to send this number using words. He ate coffee mix without water again, so right now he's really messed up and can't think. Your task is to help him by telling him what to type.

The first and only line of input contains an integer *s* (0<=≤<=*s*<=≤<=99), Tavas's score.

In the first and only line of output, print a single string consisting only from English lowercase letters and hyphens ('-'). Do not use spaces.

[ "6\n", "99\n", "20\n" ]

[ "six\n", "ninety-nine\n", "twenty\n" ]

You can find all you need to know about English numerals in [http://en.wikipedia.org/wiki/English_numerals](https://en.wikipedia.org/wiki/English_numerals) .

500

[ { "input": "6", "output": "six" }, { "input": "99", "output": "ninety-nine" }, { "input": "20", "output": "twenty" }, { "input": "10", "output": "ten" }, { "input": "15", "output": "fifteen" }, { "input": "27", "output": "twenty-seven" }, { "input": "40", "output": "forty" }, { "input": "63", "output": "sixty-three" }, { "input": "0", "output": "zero" }, { "input": "1", "output": "one" }, { "input": "2", "output": "two" }, { "input": "8", "output": "eight" }, { "input": "9", "output": "nine" }, { "input": "11", "output": "eleven" }, { "input": "12", "output": "twelve" }, { "input": "13", "output": "thirteen" }, { "input": "14", "output": "fourteen" }, { "input": "16", "output": "sixteen" }, { "input": "17", "output": "seventeen" }, { "input": "18", "output": "eighteen" }, { "input": "19", "output": "nineteen" }, { "input": "21", "output": "twenty-one" }, { "input": "29", "output": "twenty-nine" }, { "input": "30", "output": "thirty" }, { "input": "32", "output": "thirty-two" }, { "input": "38", "output": "thirty-eight" }, { "input": "43", "output": "forty-three" }, { "input": "47", "output": "forty-seven" }, { "input": "50", "output": "fifty" }, { "input": "54", "output": "fifty-four" }, { "input": "56", "output": "fifty-six" }, { "input": "60", "output": "sixty" }, { "input": "66", "output": "sixty-six" }, { "input": "70", "output": "seventy" }, { "input": "76", "output": "seventy-six" }, { "input": "80", "output": "eighty" }, { "input": "82", "output": "eighty-two" }, { "input": "90", "output": "ninety" }, { "input": "91", "output": "ninety-one" }, { "input": "95", "output": "ninety-five" }, { "input": "71", "output": "seventy-one" }, { "input": "46", "output": "forty-six" }, { "input": "84", "output": "eighty-four" }, { "input": "22", "output": "twenty-two" }, { "input": "23", "output": "twenty-three" }, { "input": "24", "output": "twenty-four" }, { "input": "25", "output": "twenty-five" }, { "input": "26", "output": "twenty-six" }, { "input": "28", "output": "twenty-eight" }, { "input": "31", "output": "thirty-one" }, { "input": "33", "output": "thirty-three" }, { "input": "34", "output": "thirty-four" }, { "input": "35", "output": "thirty-five" }, { "input": "36", "output": "thirty-six" }, { "input": "37", "output": "thirty-seven" }, { "input": "39", "output": "thirty-nine" }, { "input": "65", "output": "sixty-five" }, { "input": "68", "output": "sixty-eight" }, { "input": "41", "output": "forty-one" }, { "input": "42", "output": "forty-two" }, { "input": "44", "output": "forty-four" }, { "input": "45", "output": "forty-five" }, { "input": "48", "output": "forty-eight" }, { "input": "49", "output": "forty-nine" }, { "input": "51", "output": "fifty-one" }, { "input": "52", "output": "fifty-two" }, { "input": "53", "output": "fifty-three" }, { "input": "55", "output": "fifty-five" }, { "input": "57", "output": "fifty-seven" }, { "input": "58", "output": "fifty-eight" }, { "input": "59", "output": "fifty-nine" }, { "input": "61", "output": "sixty-one" }, { "input": "62", "output": "sixty-two" }, { "input": "64", "output": "sixty-four" }, { "input": "67", "output": "sixty-seven" }, { "input": "69", "output": "sixty-nine" }, { "input": "72", "output": "seventy-two" }, { "input": "73", "output": "seventy-three" }, { "input": "74", "output": "seventy-four" }, { "input": "75", "output": "seventy-five" }, { "input": "77", "output": "seventy-seven" }, { "input": "78", "output": "seventy-eight" }, { "input": "79", "output": "seventy-nine" }, { "input": "81", "output": "eighty-one" }, { "input": "83", "output": "eighty-three" }, { "input": "85", "output": "eighty-five" }, { "input": "86", "output": "eighty-six" }, { "input": "87", "output": "eighty-seven" }, { "input": "88", "output": "eighty-eight" }, { "input": "89", "output": "eighty-nine" }, { "input": "92", "output": "ninety-two" }, { "input": "93", "output": "ninety-three" }, { "input": "94", "output": "ninety-four" }, { "input": "96", "output": "ninety-six" }, { "input": "7", "output": "seven" }, { "input": "97", "output": "ninety-seven" }, { "input": "98", "output": "ninety-eight" }, { "input": "3", "output": "three" }, { "input": "4", "output": "four" }, { "input": "5", "output": "five" } ]

1,534,058,406

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

#include<bits/stdc++.h> using namespace std; string ten[] = {"ten", "twenty", "thirty", "fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"}; string spec[] = {"ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"}; string one[]={"zero","one","two","three","four","five","six","seven","eight","nine"}; int main() { int a; scanf("%d", &a); if(a<20&&a>=10){ cout<<spec[a-10]<<endl; return 0; } if (a>=10) { cout<<ten[a/10]; a/=10; if (a){ cout<<"-"; } else{ cout<<endl; return 0; } } cout<<one[a]<<endl; }

Title: Tavas and Nafas Time Limit: None seconds Memory Limit: None megabytes Problem Description: Today Tavas got his test result as an integer score and he wants to share it with his girlfriend, Nafas. His phone operating system is Tavdroid, and its keyboard doesn't have any digits! He wants to share his score with Nafas via text, so he has no choice but to send this number using words. He ate coffee mix without water again, so right now he's really messed up and can't think. Your task is to help him by telling him what to type. Input Specification: The first and only line of input contains an integer *s* (0<=≤<=*s*<=≤<=99), Tavas's score. Output Specification: In the first and only line of output, print a single string consisting only from English lowercase letters and hyphens ('-'). Do not use spaces. Demo Input: ['6\n', '99\n', '20\n'] Demo Output: ['six\n', 'ninety-nine\n', 'twenty\n'] Note: You can find all you need to know about English numerals in [http://en.wikipedia.org/wiki/English_numerals](https://en.wikipedia.org/wiki/English_numerals) .

```python #include<bits/stdc++.h> using namespace std; string ten[] = {"ten", "twenty", "thirty", "fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"}; string spec[] = {"ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"}; string one[]={"zero","one","two","three","four","five","six","seven","eight","nine"}; int main() { int a; scanf("%d", &a); if(a<20&&a>=10){ cout<<spec[a-10]<<endl; return 0; } if (a>=10) { cout<<ten[a/10]; a/=10; if (a){ cout<<"-"; } else{ cout<<endl; return 0; } } cout<<one[a]<<endl; } ```

-1

612

B

HDD is Outdated Technology

PROGRAMMING

1,200

[ "implementation", "math" ]

null

HDD hard drives group data by sectors. All files are split to fragments and each of them are written in some sector of hard drive. Note the fragments can be written in sectors in arbitrary order. One of the problems of HDD hard drives is the following: the magnetic head should move from one sector to another to read some file. Find the time need to read file split to *n* fragments. The *i*-th sector contains the *f**i*-th fragment of the file (1<=≤<=*f**i*<=≤<=*n*). Note different sectors contains the different fragments. At the start the magnetic head is in the position that contains the first fragment. The file are reading in the following manner: at first the first fragment is read, then the magnetic head moves to the sector that contains the second fragment, then the second fragment is read and so on until the *n*-th fragment is read. The fragments are read in the order from the first to the *n*-th. It takes |*a*<=-<=*b*| time units to move the magnetic head from the sector *a* to the sector *b*. Reading a fragment takes no time.

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of fragments. The second line contains *n* different integers *f**i* (1<=≤<=*f**i*<=≤<=*n*) — the number of the fragment written in the *i*-th sector.

Print the only integer — the number of time units needed to read the file.

[ "3\n3 1 2\n", "5\n1 3 5 4 2\n" ]

[ "3\n", "10\n" ]

In the second example the head moves in the following way: - 1->2 means movement from the sector 1 to the sector 5, i.e. it takes 4 time units - 2->3 means movement from the sector 5 to the sector 2, i.e. it takes 3 time units - 3->4 means movement from the sector 2 to the sector 4, i.e. it takes 2 time units - 4->5 means movement from the sector 4 to the sector 3, i.e. it takes 1 time units So the answer to the second example is 4 + 3 + 2 + 1 = 10.

0

[ { "input": "3\n3 1 2", "output": "3" }, { "input": "5\n1 3 5 4 2", "output": "10" }, { "input": "1\n1", "output": "0" }, { "input": "1\n1", "output": "0" }, { "input": "1\n1", "output": "0" }, { "input": "10\n8 2 10 3 4 6 1 7 9 5", "output": "40" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "9" }, { "input": "10\n1 3 5 7 9 10 8 6 4 2", "output": "45" }, { "input": "100\n11 9 35 34 51 74 16 67 26 21 14 80 84 79 7 61 28 3 53 43 42 5 56 36 69 30 22 88 1 27 65 91 46 31 59 50 17 96 25 18 64 55 78 2 63 24 95 48 93 13 38 76 89 94 15 90 45 81 52 87 83 73 44 49 23 82 85 75 86 33 47 19 58 97 37 20 40 10 92 4 6 68 77 54 71 12 62 60 100 39 41 99 72 29 57 8 70 32 66 98", "output": "3580" }, { "input": "100\n1 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 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 93 94 95 96 97 98 99 100", "output": "99" }, { "input": "100\n1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 100 98 96 94 92 90 88 86 84 82 80 78 76 74 72 70 68 66 64 62 60 58 56 54 52 50 48 46 44 42 40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10 8 6 4 2", "output": "4950" } ]

1,451,148,158

2,147,483,647

Python 3

OK

TESTS

24

249

13,414,400

n=int(input()) L=[int(x) for x in input().split()] pos=[0]*n for i in range(n): pos[L[i]-1]=i ans=0 for i in range(n-1): ans+=abs(pos[i]-pos[i+1]) print(ans)

Title: HDD is Outdated Technology Time Limit: None seconds Memory Limit: None megabytes Problem Description: HDD hard drives group data by sectors. All files are split to fragments and each of them are written in some sector of hard drive. Note the fragments can be written in sectors in arbitrary order. One of the problems of HDD hard drives is the following: the magnetic head should move from one sector to another to read some file. Find the time need to read file split to *n* fragments. The *i*-th sector contains the *f**i*-th fragment of the file (1<=≤<=*f**i*<=≤<=*n*). Note different sectors contains the different fragments. At the start the magnetic head is in the position that contains the first fragment. The file are reading in the following manner: at first the first fragment is read, then the magnetic head moves to the sector that contains the second fragment, then the second fragment is read and so on until the *n*-th fragment is read. The fragments are read in the order from the first to the *n*-th. It takes |*a*<=-<=*b*| time units to move the magnetic head from the sector *a* to the sector *b*. Reading a fragment takes no time. Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of fragments. The second line contains *n* different integers *f**i* (1<=≤<=*f**i*<=≤<=*n*) — the number of the fragment written in the *i*-th sector. Output Specification: Print the only integer — the number of time units needed to read the file. Demo Input: ['3\n3 1 2\n', '5\n1 3 5 4 2\n'] Demo Output: ['3\n', '10\n'] Note: In the second example the head moves in the following way: - 1->2 means movement from the sector 1 to the sector 5, i.e. it takes 4 time units - 2->3 means movement from the sector 5 to the sector 2, i.e. it takes 3 time units - 3->4 means movement from the sector 2 to the sector 4, i.e. it takes 2 time units - 4->5 means movement from the sector 4 to the sector 3, i.e. it takes 1 time units So the answer to the second example is 4 + 3 + 2 + 1 = 10.

```python n=int(input()) L=[int(x) for x in input().split()] pos=[0]*n for i in range(n): pos[L[i]-1]=i ans=0 for i in range(n-1): ans+=abs(pos[i]-pos[i+1]) print(ans) ```

3

869

B

The Eternal Immortality

PROGRAMMING

1,100

[ "math" ]

null

Even if the world is full of counterfeits, I still regard it as wonderful. Pile up herbs and incense, and arise again from the flames and ashes of its predecessor — as is known to many, the phoenix does it like this. The phoenix has a rather long lifespan, and reincarnates itself once every *a*! years. Here *a*! denotes the factorial of integer *a*, that is, *a*!<==<=1<=×<=2<=×<=...<=×<=*a*. Specifically, 0!<==<=1. Koyomi doesn't care much about this, but before he gets into another mess with oddities, he is interested in the number of times the phoenix will reincarnate in a timespan of *b*! years, that is, . Note that when *b*<=≥<=*a* this value is always integer. As the answer can be quite large, it would be enough for Koyomi just to know the last digit of the answer in decimal representation. And you're here to provide Koyomi with this knowledge.

The first and only line of input contains two space-separated integers *a* and *b* (0<=≤<=*a*<=≤<=*b*<=≤<=1018).

Output one line containing a single decimal digit — the last digit of the value that interests Koyomi.

[ "2 4\n", "0 10\n", "107 109\n" ]

[ "2\n", "0\n", "2\n" ]

In the first example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/99c47ca8b182f097e38094d12f0c06ce0b081b76.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 2; In the second example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9642ef11a23e7c5a3f3c2b1255c1b1b3533802a4.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 0; In the third example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/844938cef52ee264c183246d2a9df05cca94dc60.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 2.

1,000

[ { "input": "2 4", "output": "2" }, { "input": "0 10", "output": "0" }, { "input": "107 109", "output": "2" }, { "input": "10 13", "output": "6" }, { "input": "998244355 998244359", "output": "4" }, { "input": "999999999000000000 1000000000000000000", "output": "0" }, { "input": "2 3", "output": "3" }, { "input": "3 15", "output": "0" }, { "input": "24 26", "output": "0" }, { "input": "14 60", "output": "0" }, { "input": "11 79", "output": "0" }, { "input": "1230 1232", "output": "2" }, { "input": "2633 2634", "output": "4" }, { "input": "535 536", "output": "6" }, { "input": "344319135 396746843", "output": "0" }, { "input": "696667767 696667767", "output": "1" }, { "input": "419530302 610096911", "output": "0" }, { "input": "238965115 821731161", "output": "0" }, { "input": "414626436 728903812", "output": "0" }, { "input": "274410639 293308324", "output": "0" }, { "input": "650636673091305697 650636673091305702", "output": "0" }, { "input": "651240548333620923 651240548333620924", "output": "4" }, { "input": "500000000000000000 1000000000000000000", "output": "0" }, { "input": "999999999999999999 1000000000000000000", "output": "0" }, { "input": "1000000000000000000 1000000000000000000", "output": "1" }, { "input": "0 4", "output": "4" }, { "input": "50000000062000007 50000000062000011", "output": "0" }, { "input": "0 0", "output": "1" }, { "input": "1 1", "output": "1" }, { "input": "0 2", "output": "2" }, { "input": "10000000000012 10000000000015", "output": "0" }, { "input": "5 5", "output": "1" }, { "input": "12 23", "output": "0" }, { "input": "0 11", "output": "0" }, { "input": "11111234567890 11111234567898", "output": "0" }, { "input": "0 3", "output": "6" }, { "input": "1 2", "output": "2" }, { "input": "999999999999999997 999999999999999999", "output": "2" }, { "input": "4 5", "output": "5" }, { "input": "0 1", "output": "1" }, { "input": "101 1002", "output": "0" }, { "input": "0 100000000000000001", "output": "0" }, { "input": "99999999999999997 99999999999999999", "output": "2" }, { "input": "14 15", "output": "5" }, { "input": "8 19", "output": "0" }, { "input": "12 22", "output": "0" }, { "input": "999999999999996 999999999999999", "output": "4" }, { "input": "1 3", "output": "6" }, { "input": "124 125", "output": "5" }, { "input": "11 32", "output": "0" }, { "input": "0 5", "output": "0" }, { "input": "0 999999", "output": "0" }, { "input": "151151151515 151151151526", "output": "0" }, { "input": "6 107", "output": "0" }, { "input": "5 16", "output": "0" }, { "input": "7 16", "output": "0" }, { "input": "6 19", "output": "0" }, { "input": "11113111111111 13111111111111", "output": "0" }, { "input": "1 1000", "output": "0" }, { "input": "24 25", "output": "5" }, { "input": "0 100000000000", "output": "0" }, { "input": "1 22", "output": "0" }, { "input": "999999999999999996 999999999999999999", "output": "4" } ]

1,680,528,301

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

4

61

0

from math import factorial x,y=list(map(int,input().split())) print(0 if y-x==y else factorial(y-x))

Title: The Eternal Immortality Time Limit: None seconds Memory Limit: None megabytes Problem Description: Even if the world is full of counterfeits, I still regard it as wonderful. Pile up herbs and incense, and arise again from the flames and ashes of its predecessor — as is known to many, the phoenix does it like this. The phoenix has a rather long lifespan, and reincarnates itself once every *a*! years. Here *a*! denotes the factorial of integer *a*, that is, *a*!<==<=1<=×<=2<=×<=...<=×<=*a*. Specifically, 0!<==<=1. Koyomi doesn't care much about this, but before he gets into another mess with oddities, he is interested in the number of times the phoenix will reincarnate in a timespan of *b*! years, that is, . Note that when *b*<=≥<=*a* this value is always integer. As the answer can be quite large, it would be enough for Koyomi just to know the last digit of the answer in decimal representation. And you're here to provide Koyomi with this knowledge. Input Specification: The first and only line of input contains two space-separated integers *a* and *b* (0<=≤<=*a*<=≤<=*b*<=≤<=1018). Output Specification: Output one line containing a single decimal digit — the last digit of the value that interests Koyomi. Demo Input: ['2 4\n', '0 10\n', '107 109\n'] Demo Output: ['2\n', '0\n', '2\n'] Note: In the first example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/99c47ca8b182f097e38094d12f0c06ce0b081b76.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 2; In the second example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9642ef11a23e7c5a3f3c2b1255c1b1b3533802a4.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 0; In the third example, the last digit of <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/844938cef52ee264c183246d2a9df05cca94dc60.png" style="max-width: 100.0%;max-height: 100.0%;"/> is 2.

```python from math import factorial x,y=list(map(int,input().split())) print(0 if y-x==y else factorial(y-x)) ```

0

none

0

[ "none" ]

null

Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to . Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it. He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.

The first and the single line of the input contains 6 space-separated integers *a*1,<=*a*2,<=*a*3,<=*a*4,<=*a*5 and *a*6 (1<=≤<=*a**i*<=≤<=1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.

Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.

[ "1 1 1 1 1 1\n", "1 2 1 2 1 2\n" ]

[ "6\n", "13\n" ]

This is what Gerald's hexagon looks like in the first sample: <img class="tex-graphics" src="https://espresso.codeforces.com/84d193e27b02c38eb1eadc536602a2ec0b9f9519.png" style="max-width: 100.0%;max-height: 100.0%;"/> And that's what it looks like in the second sample: <img class="tex-graphics" src="https://espresso.codeforces.com/e29076a96da8ca864654cc6195654d9bf07d31ce.png" style="max-width: 100.0%;max-height: 100.0%;"/>

0

[ { "input": "1 1 1 1 1 1", "output": "6" }, { "input": "1 2 1 2 1 2", "output": "13" }, { "input": "2 4 5 3 3 6", "output": "83" }, { "input": "45 19 48 18 46 21", "output": "6099" }, { "input": "66 6 65 6 66 5", "output": "5832" }, { "input": "7 5 4 8 4 5", "output": "175" }, { "input": "3 2 1 4 1 2", "output": "25" }, { "input": "7 1 7 3 5 3", "output": "102" }, { "input": "9 2 9 3 8 3", "output": "174" }, { "input": "1 6 1 5 2 5", "output": "58" }, { "input": "41 64 48 61 44 68", "output": "17488" }, { "input": "1 59 2 59 1 60", "output": "3838" }, { "input": "30 36 36 32 34 38", "output": "7052" }, { "input": "50 40 46 38 52 34", "output": "11176" }, { "input": "4 60 4 60 4 60", "output": "4576" }, { "input": "718 466 729 470 714 481", "output": "2102808" }, { "input": "131 425 143 461 95 473", "output": "441966" }, { "input": "125 7 128 8 124 11", "output": "20215" }, { "input": "677 303 685 288 692 296", "output": "1365807" }, { "input": "1 577 7 576 2 582", "output": "342171" }, { "input": "1000 1000 1000 1000 1000 1000", "output": "6000000" }, { "input": "1 1 1000 1 1 1000", "output": "4002" }, { "input": "1000 1000 1 1000 1000 1", "output": "2004000" }, { "input": "1000 1 1000 999 2 999", "output": "2003997" }, { "input": "1 1000 1 1 1000 1", "output": "4002" }, { "input": "888 888 888 887 889 887", "output": "4729487" } ]

1,437,599,697

2,147,483,647

PyPy 3

OK

TESTS

26

124

0

s = list(map(int, input().split())) print((s[0]+s[1]+s[2])**2-s[0]**2-s[2]**2-s[4]**2)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to . Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it. He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles. Input Specification: The first and the single line of the input contains 6 space-separated integers *a*1,<=*a*2,<=*a*3,<=*a*4,<=*a*5 and *a*6 (1<=≤<=*a**i*<=≤<=1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists. Output Specification: Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split. Demo Input: ['1 1 1 1 1 1\n', '1 2 1 2 1 2\n'] Demo Output: ['6\n', '13\n'] Note: This is what Gerald's hexagon looks like in the first sample: <img class="tex-graphics" src="https://espresso.codeforces.com/84d193e27b02c38eb1eadc536602a2ec0b9f9519.png" style="max-width: 100.0%;max-height: 100.0%;"/> And that's what it looks like in the second sample: <img class="tex-graphics" src="https://espresso.codeforces.com/e29076a96da8ca864654cc6195654d9bf07d31ce.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python s = list(map(int, input().split())) print((s[0]+s[1]+s[2])**2-s[0]**2-s[2]**2-s[4]**2) ```

3

596

B

Wilbur and Array

PROGRAMMING

1,100

[ "greedy", "implementation" ]

null

Wilbur the pig is tinkering with arrays again. He has the array *a*1,<=*a*2,<=...,<=*a**n* initially consisting of *n* zeros. At one step, he can choose any index *i* and either add 1 to all elements *a**i*,<=*a**i*<=+<=1,<=... ,<=*a**n* or subtract 1 from all elements *a**i*,<=*a**i*<=+<=1,<=...,<=*a**n*. His goal is to end up with the array *b*1,<=*b*2,<=...,<=*b**n*. Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the length of the array *a**i*. Initially *a**i*<==<=0 for every position *i*, so this array is not given in the input. The second line of the input contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (<=-<=109<=≤<=*b**i*<=≤<=109).

Print the minimum number of steps that Wilbur needs to make in order to achieve *a**i*<==<=*b**i* for all *i*.

[ "5\n1 2 3 4 5\n", "4\n1 2 2 1\n" ]

[ "5", "3" ]

In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes. In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.

1,000

[ { "input": "5\n1 2 3 4 5", "output": "5" }, { "input": "4\n1 2 2 1", "output": "3" }, { "input": "3\n1 2 4", "output": "4" }, { "input": "6\n1 2 3 6 5 4", "output": "8" }, { "input": "10\n2 1 4 3 6 5 8 7 10 9", "output": "19" }, { "input": "7\n12 6 12 13 4 3 2", "output": "36" }, { "input": "15\n15 14 13 1 2 3 12 11 10 4 5 6 9 8 7", "output": "55" }, { "input": "16\n1 2 3 4 13 14 15 16 9 10 11 12 5 6 7 8", "output": "36" }, { "input": "6\n1000 1 2000 1 3000 1", "output": "11995" }, { "input": "1\n0", "output": "0" }, { "input": "5\n1000000000 1 1000000000 1 1000000000", "output": "4999999996" }, { "input": "5\n1000000000 0 1000000000 0 1000000000", "output": "5000000000" }, { "input": "10\n1000000000 0 1000000000 0 1000000000 0 1000000000 0 1000000000 0", "output": "10000000000" }, { "input": "10\n1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000", "output": "19000000000" }, { "input": "7\n0 1000000000 0 1000000000 0 1000000000 0", "output": "6000000000" }, { "input": "4\n1000000000 -1000000000 1000000000 -1000000000", "output": "7000000000" }, { "input": "20\n1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000", "output": "39000000000" }, { "input": "11\n1000000000 0 1000000000 0 1000000000 0 1000000000 0 1000000000 0 1000000000", "output": "11000000000" }, { "input": "5\n1000000000 -1000000000 1000000000 -1000000000 1000000000", "output": "9000000000" }, { "input": "22\n1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000", "output": "43000000000" } ]

1,447,946,695

1,194

Python 3

OK

TESTS

76

218

18,022,400

n = int(input()) a = [0] + list(map(int, input().split())) ans = 0 for i in range(1, n + 1): ans += abs(a[i] - a[i - 1]) print(ans)

Title: Wilbur and Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Wilbur the pig is tinkering with arrays again. He has the array *a*1,<=*a*2,<=...,<=*a**n* initially consisting of *n* zeros. At one step, he can choose any index *i* and either add 1 to all elements *a**i*,<=*a**i*<=+<=1,<=... ,<=*a**n* or subtract 1 from all elements *a**i*,<=*a**i*<=+<=1,<=...,<=*a**n*. His goal is to end up with the array *b*1,<=*b*2,<=...,<=*b**n*. Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value. Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the length of the array *a**i*. Initially *a**i*<==<=0 for every position *i*, so this array is not given in the input. The second line of the input contains *n* integers *b*1,<=*b*2,<=...,<=*b**n* (<=-<=109<=≤<=*b**i*<=≤<=109). Output Specification: Print the minimum number of steps that Wilbur needs to make in order to achieve *a**i*<==<=*b**i* for all *i*. Demo Input: ['5\n1 2 3 4 5\n', '4\n1 2 2 1\n'] Demo Output: ['5', '3'] Note: In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes. In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1.

```python n = int(input()) a = [0] + list(map(int, input().split())) ans = 0 for i in range(1, n + 1): ans += abs(a[i] - a[i - 1]) print(ans) ```

3

677

A

Vanya and Fence

PROGRAMMING

800

[ "implementation" ]

null

Vanya and his friends are walking along the fence of height *h* and they do not want the guard to notice them. In order to achieve this the height of each of the friends should not exceed *h*. If the height of some person is greater than *h* he can bend down and then he surely won't be noticed by the guard. The height of the *i*-th person is equal to *a**i*. Consider the width of the person walking as usual to be equal to 1, while the width of the bent person is equal to 2. Friends want to talk to each other while walking, so they would like to walk in a single row. What is the minimum width of the road, such that friends can walk in a row and remain unattended by the guard?

The first line of the input contains two integers *n* and *h* (1<=≤<=*n*<=≤<=1000, 1<=≤<=*h*<=≤<=1000) — the number of friends and the height of the fence, respectively. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=2*h*), the *i*-th of them is equal to the height of the *i*-th person.

Print a single integer — the minimum possible valid width of the road.

[ "3 7\n4 5 14\n", "6 1\n1 1 1 1 1 1\n", "6 5\n7 6 8 9 10 5\n" ]

[ "4\n", "6\n", "11\n" ]

In the first sample, only person number 3 must bend down, so the required width is equal to 1 + 1 + 2 = 4. In the second sample, all friends are short enough and no one has to bend, so the width 1 + 1 + 1 + 1 + 1 + 1 = 6 is enough. In the third sample, all the persons have to bend, except the last one. The required minimum width of the road is equal to 2 + 2 + 2 + 2 + 2 + 1 = 11.

500

[ { "input": "3 7\n4 5 14", "output": "4" }, { "input": "6 1\n1 1 1 1 1 1", "output": "6" }, { "input": "6 5\n7 6 8 9 10 5", "output": "11" }, { "input": "10 420\n214 614 297 675 82 740 174 23 255 15", "output": "13" }, { "input": "10 561\n657 23 1096 487 785 66 481 554 1000 821", "output": "15" }, { "input": "100 342\n478 143 359 336 162 333 385 515 117 496 310 538 469 539 258 676 466 677 1 296 150 560 26 213 627 221 255 126 617 174 279 178 24 435 70 145 619 46 669 566 300 67 576 251 58 176 441 564 569 194 24 669 73 262 457 259 619 78 400 579 222 626 269 47 80 315 160 194 455 186 315 424 197 246 683 220 68 682 83 233 290 664 273 598 362 305 674 614 321 575 362 120 14 534 62 436 294 351 485 396", "output": "144" }, { "input": "100 290\n244 49 276 77 449 261 468 458 201 424 9 131 300 88 432 394 104 77 13 289 435 259 111 453 168 394 156 412 351 576 178 530 81 271 228 564 125 328 42 372 205 61 180 471 33 360 567 331 222 318 241 117 529 169 188 484 202 202 299 268 246 343 44 364 333 494 59 236 84 485 50 8 428 8 571 227 205 310 210 9 324 472 368 490 114 84 296 305 411 351 569 393 283 120 510 171 232 151 134 366", "output": "145" }, { "input": "1 1\n1", "output": "1" }, { "input": "1 1\n2", "output": "2" }, { "input": "46 71\n30 26 56 138 123 77 60 122 73 45 79 10 130 3 14 1 38 46 128 50 82 16 32 68 28 98 62 106 2 49 131 11 114 39 139 70 40 50 45 137 33 30 35 136 135 19", "output": "63" }, { "input": "20 723\n212 602 293 591 754 91 1135 640 80 495 845 928 1399 498 926 1431 1226 869 814 1386", "output": "31" }, { "input": "48 864\n843 1020 751 1694 18 1429 1395 1174 272 1158 1628 1233 1710 441 765 561 778 748 1501 1200 563 1263 1398 1687 1518 1640 1591 839 500 466 1603 1587 1201 1209 432 868 1159 639 649 628 9 91 1036 147 896 1557 941 518", "output": "75" }, { "input": "26 708\n549 241 821 734 945 1161 566 1268 216 30 1142 730 529 1014 255 168 796 1148 89 113 1328 286 743 871 1259 1397", "output": "41" }, { "input": "75 940\n1620 1745 1599 441 64 1466 1496 1239 1716 1475 778 106 1136 1212 1261 444 781 257 1071 747 626 232 609 1544 682 1326 469 1361 1460 1450 1207 1319 922 625 1737 1057 1698 592 692 80 1016 541 1254 201 682 1007 847 206 1066 809 259 109 240 1611 219 1455 1326 1377 1827 786 42 1002 1382 1592 543 1866 1198 334 1524 1760 340 1566 955 257 1118", "output": "116" } ]

1,694,162,606

2,147,483,647

PyPy 3-64

OK

TESTS

29

62

0

n,h=map(int,input().split()) a=list(map(int,input().split())) res=0 for i in range(len(a)): if a[i]>h: res+=2 else: res+=1 print(res)

Title: Vanya and Fence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vanya and his friends are walking along the fence of height *h* and they do not want the guard to notice them. In order to achieve this the height of each of the friends should not exceed *h*. If the height of some person is greater than *h* he can bend down and then he surely won't be noticed by the guard. The height of the *i*-th person is equal to *a**i*. Consider the width of the person walking as usual to be equal to 1, while the width of the bent person is equal to 2. Friends want to talk to each other while walking, so they would like to walk in a single row. What is the minimum width of the road, such that friends can walk in a row and remain unattended by the guard? Input Specification: The first line of the input contains two integers *n* and *h* (1<=≤<=*n*<=≤<=1000, 1<=≤<=*h*<=≤<=1000) — the number of friends and the height of the fence, respectively. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=2*h*), the *i*-th of them is equal to the height of the *i*-th person. Output Specification: Print a single integer — the minimum possible valid width of the road. Demo Input: ['3 7\n4 5 14\n', '6 1\n1 1 1 1 1 1\n', '6 5\n7 6 8 9 10 5\n'] Demo Output: ['4\n', '6\n', '11\n'] Note: In the first sample, only person number 3 must bend down, so the required width is equal to 1 + 1 + 2 = 4. In the second sample, all friends are short enough and no one has to bend, so the width 1 + 1 + 1 + 1 + 1 + 1 = 6 is enough. In the third sample, all the persons have to bend, except the last one. The required minimum width of the road is equal to 2 + 2 + 2 + 2 + 2 + 1 = 11.

```python n,h=map(int,input().split()) a=list(map(int,input().split())) res=0 for i in range(len(a)): if a[i]>h: res+=2 else: res+=1 print(res) ```

3

846

A

Curriculum Vitae

PROGRAMMING

1,500

[ "brute force", "implementation" ]

null

Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job. During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV. More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one. Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.

The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one.

Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.

[ "4\n1 1 0 1\n", "6\n0 1 0 0 1 0\n", "1\n0\n" ]

[ "3\n", "4\n", "1\n" ]

none

0

[ { "input": "4\n1 1 0 1", "output": "3" }, { "input": "6\n0 1 0 0 1 0", "output": "4" }, { "input": "1\n0", "output": "1" }, { "input": "100\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "100" }, { "input": "100\n0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "80" }, { "input": "1\n1", "output": "1" }, { "input": "100\n1 1 0 1 1 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 1 1 1 1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 0 1 1 1 0 0 1 1 0 0 0 0 1", "output": "53" }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "100" }, { "input": "3\n1 0 0", "output": "2" }, { "input": "10\n1 1 0 0 0 1 1 0 0 0", "output": "6" }, { "input": "90\n1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0", "output": "52" }, { "input": "78\n0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 0 1 0", "output": "42" }, { "input": "4\n1 0 0 1", "output": "3" }, { "input": "2\n0 1", "output": "2" }, { "input": "5\n0 1 0 0 1", "output": "4" }, { "input": "3\n1 0 1", "output": "2" }, { "input": "3\n1 1 0", "output": "2" }, { "input": "16\n1 1 1 1 1 0 0 0 0 0 1 0 1 0 0 1", "output": "9" } ]

1,592,904,896

2,147,483,647

Python 3

OK

TESTS

18

93

6,963,200

n = int(input()) m=list(map(int,input().split())) x=m.count(0) y=n-x a=0 b=0 l=max(x,y) for i in range(n): if m[i]==1: a+=1 c=[] d=0 e=0 for j in range(i+1): if m[j]==1: d+=1 else: e+=1 c.append(e+a-d) l=max(l,max(c)+y-a) else: b+=1 print(l)

Title: Curriculum Vitae Time Limit: None seconds Memory Limit: None megabytes Problem Description: Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job. During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV. More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one. Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV. Input Specification: The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one. Output Specification: Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one. Demo Input: ['4\n1 1 0 1\n', '6\n0 1 0 0 1 0\n', '1\n0\n'] Demo Output: ['3\n', '4\n', '1\n'] Note: none

```python n = int(input()) m=list(map(int,input().split())) x=m.count(0) y=n-x a=0 b=0 l=max(x,y) for i in range(n): if m[i]==1: a+=1 c=[] d=0 e=0 for j in range(i+1): if m[j]==1: d+=1 else: e+=1 c.append(e+a-d) l=max(l,max(c)+y-a) else: b+=1 print(l) ```

3

368

B

Sereja and Suffixes

PROGRAMMING

1,100

[ "data structures", "dp" ]

null

Sereja has an array *a*, consisting of *n* integers *a*1, *a*2, ..., *a**n*. The boy cannot sit and do nothing, he decided to study an array. Sereja took a piece of paper and wrote out *m* integers *l*1,<=*l*2,<=...,<=*l**m* (1<=≤<=*l**i*<=≤<=*n*). For each number *l**i* he wants to know how many distinct numbers are staying on the positions *l**i*, *l**i*<=+<=1, ..., *n*. Formally, he want to find the number of distinct numbers among *a**l**i*,<=*a**l**i*<=+<=1,<=...,<=*a**n*.? Sereja wrote out the necessary array elements but the array was so large and the boy was so pressed for time. Help him, find the answer for the described question for each *l**i*.

The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=105) — the array elements. Next *m* lines contain integers *l*1,<=*l*2,<=...,<=*l**m*. The *i*-th line contains integer *l**i* (1<=≤<=*l**i*<=≤<=*n*).

Print *m* lines — on the *i*-th line print the answer to the number *l**i*.

[ "10 10\n1 2 3 4 1 2 3 4 100000 99999\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n" ]

[ "6\n6\n6\n6\n6\n5\n4\n3\n2\n1\n" ]

none

1,000

[ { "input": "10 10\n1 2 3 4 1 2 3 4 100000 99999\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10", "output": "6\n6\n6\n6\n6\n5\n4\n3\n2\n1" }, { "input": "8 3\n8 6 4 3 4 2 4 8\n6\n4\n2", "output": "3\n4\n5" }, { "input": "7 10\n1 3 8 6 2 2 7\n4\n2\n6\n3\n4\n4\n6\n2\n7\n4", "output": "3\n5\n2\n4\n3\n3\n2\n5\n1\n3" }, { "input": "10 2\n2 6 5 7 2 2 3 2 4 8\n1\n2", "output": "7\n7" }, { "input": "7 1\n68346 10956 76708 23018 84063 34833 80407\n1", "output": "7" }, { "input": "2 2\n8 4\n1\n1", "output": "2\n2" }, { "input": "1 5\n5\n1\n1\n1\n1\n1", "output": "1\n1\n1\n1\n1" }, { "input": "4 7\n3 1 4 2\n4\n1\n2\n3\n2\n4\n4", "output": "1\n4\n3\n2\n3\n1\n1" }, { "input": "4 3\n9 1 7 1\n1\n4\n2", "output": "3\n1\n2" }, { "input": "8 3\n9280 6676 2720 6172 8329 10413 3975 1394\n5\n6\n7", "output": "4\n3\n2" }, { "input": "1 1\n1\n1", "output": "1" } ]

1,668,062,169

2,147,483,647

PyPy 3-64

OK

TESTS

30

982

19,353,600

n,m=[int(a) for a in input().split()] array=[0]+[int(b) for b in input().split()]+[0] aset=set() for j in range(n,0,-1): aset.add(array[j]);array[j]=len(aset) for k in range(1,m+1): l=int(input()) print(array[l])

Title: Sereja and Suffixes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Sereja has an array *a*, consisting of *n* integers *a*1, *a*2, ..., *a**n*. The boy cannot sit and do nothing, he decided to study an array. Sereja took a piece of paper and wrote out *m* integers *l*1,<=*l*2,<=...,<=*l**m* (1<=≤<=*l**i*<=≤<=*n*). For each number *l**i* he wants to know how many distinct numbers are staying on the positions *l**i*, *l**i*<=+<=1, ..., *n*. Formally, he want to find the number of distinct numbers among *a**l**i*,<=*a**l**i*<=+<=1,<=...,<=*a**n*.? Sereja wrote out the necessary array elements but the array was so large and the boy was so pressed for time. Help him, find the answer for the described question for each *l**i*. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=105) — the array elements. Next *m* lines contain integers *l*1,<=*l*2,<=...,<=*l**m*. The *i*-th line contains integer *l**i* (1<=≤<=*l**i*<=≤<=*n*). Output Specification: Print *m* lines — on the *i*-th line print the answer to the number *l**i*. Demo Input: ['10 10\n1 2 3 4 1 2 3 4 100000 99999\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n'] Demo Output: ['6\n6\n6\n6\n6\n5\n4\n3\n2\n1\n'] Note: none

```python n,m=[int(a) for a in input().split()] array=[0]+[int(b) for b in input().split()]+[0] aset=set() for j in range(n,0,-1): aset.add(array[j]);array[j]=len(aset) for k in range(1,m+1): l=int(input()) print(array[l]) ```

3

393

B

Three matrices

PROGRAMMING

0

[]

null

Chubby Yang is studying linear equations right now. He came up with a nice problem. In the problem you are given an *n*<=×<=*n* matrix *W*, consisting of integers, and you should find two *n*<=×<=*n* matrices *A* and *B*, all the following conditions must hold: - *A**ij*<==<=*A**ji*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*); - *B**ij*<==<=<=-<=*B**ji*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*); - *W**ij*<==<=*A**ij*<=+<=*B**ij*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*). Can you solve the problem?

The first line contains an integer *n* (1<=≤<=*n*<=≤<=170). Each of the following *n* lines contains *n* integers. The *j*-th integer in the *i*-th line is *W**ij* (0<=≤<=|*W**ij*|<=<<=1717).

The first *n* lines must contain matrix *A*. The next *n* lines must contain matrix *B*. Print the matrices in the format equal to format of matrix *W* in input. It is guaranteed that the answer exists. If there are multiple answers, you are allowed to print any of them. The answer will be considered correct if the absolute or relative error doesn't exceed 10<=-<=4.

[ "2\n1 4\n3 2\n", "3\n1 2 3\n4 5 6\n7 8 9\n" ]

[ "1.00000000 3.50000000\n3.50000000 2.00000000\n0.00000000 0.50000000\n-0.50000000 0.00000000\n", "1.00000000 3.00000000 5.00000000\n3.00000000 5.00000000 7.00000000\n5.00000000 7.00000000 9.00000000\n0.00000000 -1.00000000 -2.00000000\n1.00000000 0.00000000 -1.00000000\n2.00000000 1.00000000 0.00000000\n" ]

none

1,000

[ { "input": "2\n1 4\n3 2", "output": "1.00000000 3.50000000\n3.50000000 2.00000000\n0.00000000 0.50000000\n-0.50000000 0.00000000" }, { "input": "3\n1 2 3\n4 5 6\n7 8 9", "output": "1.00000000 3.00000000 5.00000000\n3.00000000 5.00000000 7.00000000\n5.00000000 7.00000000 9.00000000\n0.00000000 -1.00000000 -2.00000000\n1.00000000 0.00000000 -1.00000000\n2.00000000 1.00000000 0.00000000" }, { "input": "8\n62 567 1382 1279 728 1267 1262 568\n77 827 717 1696 774 248 822 1266\n563 612 995 424 1643 1197 338 1141\n1579 806 1254 468 184 1571 716 772\n1087 182 1312 772 605 1674 720 1349\n1393 988 873 157 403 301 1519 1192\n1085 625 1395 1087 847 1360 1004 594\n1368 1056 916 839 472 840 53 1238", "output": "62.00000000 322.00000000 972.50000000 1429.00000000 907.50000000 1330.00000000 1173.50000000 968.00000000\n322.00000000 827.00000000 664.50000000 1251.00000000 478.00000000 618.00000000 723.50000000 1161.00000000\n972.50000000 664.50000000 995.00000000 839.00000000 1477.50000000 1035.00000000 866.50000000 1028.50000000\n1429.00000000 1251.00000000 839.00000000 468.00000000 478.00000000 864.00000000 901.50000000 805.50000000\n907.50000000 478.00000000 1477.50000000 478.00000000 605.00000000 1038.50000000 78..." }, { "input": "7\n926 41 1489 72 749 375 940\n464 1148 858 1010 285 1469 1506\n1112 1087 225 917 480 511 1090\n759 945 627 230 220 1456 529\n318 83 203 134 1192 1167 6\n440 1158 1614 683 1358 1140 1196\n1175 900 126 1562 1220 813 148", "output": "926.00000000 252.50000000 1300.50000000 415.50000000 533.50000000 407.50000000 1057.50000000\n252.50000000 1148.00000000 972.50000000 977.50000000 184.00000000 1313.50000000 1203.00000000\n1300.50000000 972.50000000 225.00000000 772.00000000 341.50000000 1062.50000000 608.00000000\n415.50000000 977.50000000 772.00000000 230.00000000 177.00000000 1069.50000000 1045.50000000\n533.50000000 184.00000000 341.50000000 177.00000000 1192.00000000 1262.50000000 613.00000000\n407.50000000 1313.50000000 1062.50000000..." }, { "input": "1\n1", "output": "1.00000000\n0.00000000" }, { "input": "1\n0", "output": "0.00000000\n0.00000000" }, { "input": "2\n0 0\n0 0", "output": "0.00000000 0.00000000\n0.00000000 0.00000000\n0.00000000 0.00000000\n0.00000000 0.00000000" }, { "input": "2\n0 1\n0 1", "output": "0.00000000 0.50000000\n0.50000000 1.00000000\n0.00000000 0.50000000\n-0.50000000 0.00000000" } ]

1,569,428,463

2,147,483,647

Python 3

OK

TESTS

40

233

2,457,600

n = int(input()) W = [] for i in range(0, n): s = input().split(' ') w = list(map(int, s)) W.append(w) a = [] b = [] A = [] B = [] i = 0 #while (i < n - 1): # for j in range(i+1, n): # a.append((W[i][j]+W[j][i])/2) # b.append((W[i][j]-W[j][i])/2) # i += 1 while (i < n): for j in range(0, n): if i == j: a.append(W[i][j]) b.append(0) elif i < j: a.append((W[i][j]+W[j][i])/2) b.append((W[i][j]-W[j][i])/2) else: a.append((W[j][i] + W[i][j]) / 2) b.append((W[i][j] - W[j][i]) / 2) i += 1 #for i in range(0 , n): # A.append([W[i][i]]) # B.append([0]) s = [] for i in range(0, len(a)): if (i + 1) % n == 0: s.append(a[i]) print(*s, sep=' ') s = [] else: s.append(a[i]) s = [] for i in range(0, len(b)): if (i + 1) % n == 0: s.append(b[i]) print(*s, sep=' ') s = [] else: s.append(b[i])

Title: Three matrices Time Limit: None seconds Memory Limit: None megabytes Problem Description: Chubby Yang is studying linear equations right now. He came up with a nice problem. In the problem you are given an *n*<=×<=*n* matrix *W*, consisting of integers, and you should find two *n*<=×<=*n* matrices *A* and *B*, all the following conditions must hold: - *A**ij*<==<=*A**ji*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*); - *B**ij*<==<=<=-<=*B**ji*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*); - *W**ij*<==<=*A**ij*<=+<=*B**ij*, for all *i*,<=*j* (1<=≤<=*i*,<=*j*<=≤<=*n*). Can you solve the problem? Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=170). Each of the following *n* lines contains *n* integers. The *j*-th integer in the *i*-th line is *W**ij* (0<=≤<=|*W**ij*|<=<<=1717). Output Specification: The first *n* lines must contain matrix *A*. The next *n* lines must contain matrix *B*. Print the matrices in the format equal to format of matrix *W* in input. It is guaranteed that the answer exists. If there are multiple answers, you are allowed to print any of them. The answer will be considered correct if the absolute or relative error doesn't exceed 10<=-<=4. Demo Input: ['2\n1 4\n3 2\n', '3\n1 2 3\n4 5 6\n7 8 9\n'] Demo Output: ['1.00000000 3.50000000\n3.50000000 2.00000000\n0.00000000 0.50000000\n-0.50000000 0.00000000\n', '1.00000000 3.00000000 5.00000000\n3.00000000 5.00000000 7.00000000\n5.00000000 7.00000000 9.00000000\n0.00000000 -1.00000000 -2.00000000\n1.00000000 0.00000000 -1.00000000\n2.00000000 1.00000000 0.00000000\n'] Note: none

```python n = int(input()) W = [] for i in range(0, n): s = input().split(' ') w = list(map(int, s)) W.append(w) a = [] b = [] A = [] B = [] i = 0 #while (i < n - 1): # for j in range(i+1, n): # a.append((W[i][j]+W[j][i])/2) # b.append((W[i][j]-W[j][i])/2) # i += 1 while (i < n): for j in range(0, n): if i == j: a.append(W[i][j]) b.append(0) elif i < j: a.append((W[i][j]+W[j][i])/2) b.append((W[i][j]-W[j][i])/2) else: a.append((W[j][i] + W[i][j]) / 2) b.append((W[i][j] - W[j][i]) / 2) i += 1 #for i in range(0 , n): # A.append([W[i][i]]) # B.append([0]) s = [] for i in range(0, len(a)): if (i + 1) % n == 0: s.append(a[i]) print(*s, sep=' ') s = [] else: s.append(a[i]) s = [] for i in range(0, len(b)): if (i + 1) % n == 0: s.append(b[i]) print(*s, sep=' ') s = [] else: s.append(b[i]) ```

3

34

A

Reconnaissance 2

PROGRAMMING

800

[ "implementation" ]

A. Reconnaissance 2

2

256

*n* soldiers stand in a circle. For each soldier his height *a**i* is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |*a**i*<=-<=*a**j*| is minimal. So each of them will be less noticeable with the other. Output any pair of soldiers that can form a reconnaissance unit.

The first line contains integer *n* (2<=≤<=*n*<=≤<=100) — amount of soldiers. Then follow the heights of the soldiers in their order in the circle — *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000). The soldier heights are given in clockwise or counterclockwise direction.

Output two integers — indexes of neighbouring soldiers, who should form a reconnaissance unit. If there are many optimum solutions, output any of them. Remember, that the soldiers stand in a circle.

[ "5\n10 12 13 15 10\n", "4\n10 20 30 40\n" ]

[ "5 1\n", "1 2\n" ]

none

500

[ { "input": "5\n10 12 13 15 10", "output": "5 1" }, { "input": "4\n10 20 30 40", "output": "1 2" }, { "input": "6\n744 359 230 586 944 442", "output": "2 3" }, { "input": "5\n826 747 849 687 437", "output": "1 2" }, { "input": "5\n999 999 993 969 999", "output": "1 2" }, { "input": "5\n4 24 6 1 15", "output": "3 4" }, { "input": "2\n511 32", "output": "1 2" }, { "input": "3\n907 452 355", "output": "2 3" }, { "input": "4\n303 872 764 401", "output": "4 1" }, { "input": "10\n684 698 429 694 956 812 594 170 937 764", "output": "1 2" }, { "input": "20\n646 840 437 946 640 564 936 917 487 752 844 734 468 969 674 646 728 642 514 695", "output": "7 8" }, { "input": "30\n996 999 998 984 989 1000 996 993 1000 983 992 999 999 1000 979 992 987 1000 996 1000 1000 989 981 996 995 999 999 989 999 1000", "output": "12 13" }, { "input": "50\n93 27 28 4 5 78 59 24 19 134 31 128 118 36 90 32 32 1 44 32 33 13 31 10 12 25 38 50 25 12 4 22 28 53 48 83 4 25 57 31 71 24 8 7 28 86 23 80 101 58", "output": "16 17" }, { "input": "88\n1000 1000 1000 1000 1000 998 998 1000 1000 1000 1000 999 999 1000 1000 1000 999 1000 997 999 997 1000 999 998 1000 999 1000 1000 1000 999 1000 999 999 1000 1000 999 1000 999 1000 1000 998 1000 1000 1000 998 998 1000 1000 999 1000 1000 1000 1000 1000 1000 1000 998 1000 1000 1000 999 1000 1000 999 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 998 1000 1000 1000 998 1000 1000 998 1000 999 1000 1000 1000 1000", "output": "1 2" }, { "input": "99\n4 4 21 6 5 3 13 2 6 1 3 4 1 3 1 9 11 1 6 17 4 5 20 4 1 9 5 11 3 4 14 1 3 3 1 4 3 5 27 1 1 2 10 7 11 4 19 7 11 6 11 13 3 1 10 7 2 1 16 1 9 4 29 13 2 12 14 2 21 1 9 8 26 12 12 5 2 14 7 8 8 8 9 4 12 2 6 6 7 16 8 14 2 10 20 15 3 7 4", "output": "1 2" }, { "input": "100\n713 572 318 890 577 657 646 146 373 783 392 229 455 871 20 593 573 336 26 381 280 916 907 732 820 713 111 840 570 446 184 711 481 399 788 647 492 15 40 530 549 506 719 782 126 20 778 996 712 761 9 74 812 418 488 175 103 585 900 3 604 521 109 513 145 708 990 361 682 827 791 22 596 780 596 385 450 643 158 496 876 975 319 783 654 895 891 361 397 81 682 899 347 623 809 557 435 279 513 438", "output": "86 87" }, { "input": "100\n31 75 86 68 111 27 22 22 26 30 54 163 107 75 160 122 14 23 17 26 27 20 43 58 59 71 21 148 9 32 43 91 133 286 132 70 90 156 84 14 77 93 23 18 13 72 18 131 33 28 72 175 30 86 249 20 14 208 28 57 63 199 6 10 24 30 62 267 43 479 60 28 138 1 45 3 19 47 7 166 116 117 50 140 28 14 95 85 93 43 61 15 2 70 10 51 7 95 9 25", "output": "7 8" }, { "input": "100\n896 898 967 979 973 709 961 968 806 967 896 967 826 975 936 903 986 856 851 931 852 971 786 837 949 978 686 936 952 909 965 749 908 916 943 973 983 975 939 886 964 928 960 976 907 788 994 773 949 871 947 980 945 985 726 981 887 943 907 990 931 874 840 867 948 951 961 904 888 901 976 967 994 921 828 970 972 722 755 970 860 855 914 869 714 899 969 978 898 862 642 939 904 936 819 934 884 983 955 964", "output": "1 2" }, { "input": "100\n994 927 872 970 815 986 952 996 965 1000 877 986 978 999 950 990 936 997 993 960 921 860 895 869 943 998 983 968 973 953 999 990 995 871 853 979 973 963 953 938 997 989 993 964 960 973 946 975 1000 962 920 746 989 957 904 965 920 979 966 961 1000 993 975 952 846 971 991 979 985 969 984 973 956 1000 952 778 983 974 956 927 995 997 980 997 1000 970 960 970 988 983 947 904 935 972 1000 863 992 996 932 967", "output": "81 82" }, { "input": "100\n48 108 63 21 27 8 49 21 75 8 24 42 149 18 8 28 21 18 25 35 59 70 59 33 40 1 67 34 120 82 4 115 72 87 3 15 15 63 37 12 40 27 83 14 38 20 14 58 93 10 31 3 39 6 197 77 54 16 31 146 9 49 14 8 77 82 5 11 80 116 8 61 50 24 7 103 29 11 3 3 1 12 46 24 21 131 39 29 36 2 107 40 16 99 31 41 29 48 17 17", "output": "36 37" } ]

1,638,109,448

2,147,483,647

Python 3

OK

TESTS

20

92

0

n = int(input()) lst = list(map(int ,input().split())) val = 99999 for i in range(n-1): x = abs(lst[i]-lst[i+1]) if x<val: a = i+1 b= i+2 val = x if abs(lst[-1]-lst[0])<val: a = n b = 1 print(f"{a} {b}")

Title: Reconnaissance 2 Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: *n* soldiers stand in a circle. For each soldier his height *a**i* is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |*a**i*<=-<=*a**j*| is minimal. So each of them will be less noticeable with the other. Output any pair of soldiers that can form a reconnaissance unit. Input Specification: The first line contains integer *n* (2<=≤<=*n*<=≤<=100) — amount of soldiers. Then follow the heights of the soldiers in their order in the circle — *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000). The soldier heights are given in clockwise or counterclockwise direction. Output Specification: Output two integers — indexes of neighbouring soldiers, who should form a reconnaissance unit. If there are many optimum solutions, output any of them. Remember, that the soldiers stand in a circle. Demo Input: ['5\n10 12 13 15 10\n', '4\n10 20 30 40\n'] Demo Output: ['5 1\n', '1 2\n'] Note: none

```python n = int(input()) lst = list(map(int ,input().split())) val = 99999 for i in range(n-1): x = abs(lst[i]-lst[i+1]) if x<val: a = i+1 b= i+2 val = x if abs(lst[-1]-lst[0])<val: a = n b = 1 print(f"{a} {b}") ```

3.977

486

A

Calculating Function

PROGRAMMING

800

[ "implementation", "math" ]

null

For a positive integer *n* let's define a function *f*: *f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n* Your task is to calculate *f*(*n*) for a given integer *n*.

The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015).

Print *f*(*n*) in a single line.

[ "4\n", "5\n" ]

[ "2\n", "-3\n" ]

*f*(4) = - 1 + 2 - 3 + 4 = 2 *f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3

500

[ { "input": "4", "output": "2" }, { "input": "5", "output": "-3" }, { "input": "1000000000", "output": "500000000" }, { "input": "1000000001", "output": "-500000001" }, { "input": "1000000000000000", "output": "500000000000000" }, { "input": "100", "output": "50" }, { "input": "101", "output": "-51" }, { "input": "102", "output": "51" }, { "input": "103", "output": "-52" }, { "input": "104", "output": "52" }, { "input": "105", "output": "-53" }, { "input": "106", "output": "53" }, { "input": "107", "output": "-54" }, { "input": "108", "output": "54" }, { "input": "109", "output": "-55" }, { "input": "208170109961052", "output": "104085054980526" }, { "input": "46017661651072", "output": "23008830825536" }, { "input": "4018154546667", "output": "-2009077273334" }, { "input": "288565475053", "output": "-144282737527" }, { "input": "3052460231", "output": "-1526230116" }, { "input": "29906716", "output": "14953358" }, { "input": "87897701693326", "output": "43948850846663" }, { "input": "8240", "output": "4120" }, { "input": "577935", "output": "-288968" }, { "input": "62", "output": "31" }, { "input": "1", "output": "-1" }, { "input": "2", "output": "1" }, { "input": "9999999999999", "output": "-5000000000000" }, { "input": "1000000000000", "output": "500000000000" }, { "input": "99999999999999", "output": "-50000000000000" }, { "input": "999999999999999", "output": "-500000000000000" }, { "input": "42191359342", "output": "21095679671" }, { "input": "100000000000000", "output": "50000000000000" }, { "input": "145645214654154", "output": "72822607327077" }, { "input": "4294967296", "output": "2147483648" }, { "input": "3037000499", "output": "-1518500250" }, { "input": "10000000000001", "output": "-5000000000001" }, { "input": "100000017040846", "output": "50000008520423" }, { "input": "98979894985999", "output": "-49489947493000" } ]

1,699,610,808

2,147,483,647

Python 3

OK

TESTS

39

46

0

f=int(input()) print(f//2-f*(f%2))

Title: Calculating Function Time Limit: None seconds Memory Limit: None megabytes Problem Description: For a positive integer *n* let's define a function *f*: *f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n* Your task is to calculate *f*(*n*) for a given integer *n*. Input Specification: The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015). Output Specification: Print *f*(*n*) in a single line. Demo Input: ['4\n', '5\n'] Demo Output: ['2\n', '-3\n'] Note: *f*(4) = - 1 + 2 - 3 + 4 = 2 *f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3

```python f=int(input()) print(f//2-f*(f%2)) ```

3

554

A

Kyoya and Photobooks

PROGRAMMING

900

[ "brute force", "math", "strings" ]

null

Kyoya Ootori is selling photobooks of the Ouran High School Host Club. He has 26 photos, labeled "a" to "z", and he has compiled them into a photo booklet with some photos in some order (possibly with some photos being duplicated). A photo booklet can be described as a string of lowercase letters, consisting of the photos in the booklet in order. He now wants to sell some "special edition" photobooks, each with one extra photo inserted anywhere in the book. He wants to make as many distinct photobooks as possible, so he can make more money. He asks Haruhi, how many distinct photobooks can he make by inserting one extra photo into the photobook he already has? Please help Haruhi solve this problem.

The first line of input will be a single string *s* (1<=≤<=|*s*|<=≤<=20). String *s* consists only of lowercase English letters.

Output a single integer equal to the number of distinct photobooks Kyoya Ootori can make.

[ "a\n", "hi\n" ]

[ "51\n", "76\n" ]

In the first case, we can make 'ab','ac',...,'az','ba','ca',...,'za', and 'aa', producing a total of 51 distinct photo booklets.

250

[ { "input": "a", "output": "51" }, { "input": "hi", "output": "76" }, { "input": "y", "output": "51" }, { "input": "kgan", "output": "126" }, { "input": "zoabkyuvus", "output": "276" }, { "input": "spyemhyznjieyhhbk", "output": "451" }, { "input": "xulsyfkuizjauadjjopu", "output": "526" }, { "input": "e", "output": "51" }, { "input": "zv", "output": "76" }, { "input": "jgv", "output": "101" }, { "input": "zsfo", "output": "126" }, { "input": "jselr", "output": "151" }, { "input": "dwemig", "output": "176" }, { "input": "mddoxsf", "output": "201" }, { "input": "jgirkrmi", "output": "226" }, { "input": "spkxurcum", "output": "251" }, { "input": "fykkiubdkt", "output": "276" }, { "input": "fznbcxsxygs", "output": "301" }, { "input": "qcrvrdqcbtou", "output": "326" }, { "input": "qktrbjzrqgmlr", "output": "351" }, { "input": "foamodbvptlxxg", "output": "376" }, { "input": "ydzpjhsidipricw", "output": "401" }, { "input": "lpfpndmjfvqejdgf", "output": "426" }, { "input": "ofkvparuvjtggnmab", "output": "451" }, { "input": "xxncfutrtxcwdzwbgs", "output": "476" }, { "input": "zovhffccflkgqncsdte", "output": "501" }, { "input": "cskgsxywlvfeicoueglr", "output": "526" }, { "input": "gggggggggggggggggggg", "output": "526" }, { "input": "qdqdddqddqqddqddqdqd", "output": "526" }, { "input": "takttttaakaaktakttkt", "output": "526" }, { "input": "coccoooogogcgocccmcg", "output": "526" }, { "input": "kskkskkkssksssk", "output": "401" }, { "input": "lllllllllllllll", "output": "401" } ]

1,454,683,036

2,147,483,647

Python 3

OK

TESTS

33

61

0

s = input() n = len(s) o = (26*(n+1))-n print(o)

Title: Kyoya and Photobooks Time Limit: None seconds Memory Limit: None megabytes Problem Description: Kyoya Ootori is selling photobooks of the Ouran High School Host Club. He has 26 photos, labeled "a" to "z", and he has compiled them into a photo booklet with some photos in some order (possibly with some photos being duplicated). A photo booklet can be described as a string of lowercase letters, consisting of the photos in the booklet in order. He now wants to sell some "special edition" photobooks, each with one extra photo inserted anywhere in the book. He wants to make as many distinct photobooks as possible, so he can make more money. He asks Haruhi, how many distinct photobooks can he make by inserting one extra photo into the photobook he already has? Please help Haruhi solve this problem. Input Specification: The first line of input will be a single string *s* (1<=≤<=|*s*|<=≤<=20). String *s* consists only of lowercase English letters. Output Specification: Output a single integer equal to the number of distinct photobooks Kyoya Ootori can make. Demo Input: ['a\n', 'hi\n'] Demo Output: ['51\n', '76\n'] Note: In the first case, we can make 'ab','ac',...,'az','ba','ca',...,'za', and 'aa', producing a total of 51 distinct photo booklets.

```python s = input() n = len(s) o = (26*(n+1))-n print(o) ```

3

71

A

Way Too Long Words

PROGRAMMING

800

[ "strings" ]

A. Way Too Long Words

1

256

Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.

Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.

[ "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n" ]

[ "word\nl10n\ni18n\np43s\n" ]

none

500

[ { "input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis", "output": "word\nl10n\ni18n\np43s" }, { "input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm", "output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m" }, { "input": "3\nnjfngnrurunrgunrunvurn\njfvnjfdnvjdbfvsbdubruvbubvkdb\nksdnvidnviudbvibd", "output": "n20n\nj27b\nk15d" }, { "input": "1\ntcyctkktcctrcyvbyiuhihhhgyvyvyvyvjvytchjckt", "output": "t41t" }, { "input": "24\nyou\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nunofficially\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings", "output": "you\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nu10y\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings" }, { "input": "1\na", "output": "a" }, { "input": "26\na\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz", "output": "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz" }, { "input": "1\nabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij", "output": "a98j" }, { "input": "10\ngyartjdxxlcl\nfzsck\nuidwu\nxbymclornemdmtj\nilppyoapitawgje\ncibzc\ndrgbeu\nhezplmsdekhhbo\nfeuzlrimbqbytdu\nkgdco", "output": "g10l\nfzsck\nuidwu\nx13j\ni13e\ncibzc\ndrgbeu\nh12o\nf13u\nkgdco" }, { "input": "20\nlkpmx\nkovxmxorlgwaomlswjxlpnbvltfv\nhykasjxqyjrmybejnmeumzha\ntuevlumpqbbhbww\nqgqsphvrmupxxc\ntrissbaf\nqfgrlinkzvzqdryckaizutd\nzzqtoaxkvwoscyx\noswytrlnhpjvvnwookx\nlpuzqgec\ngyzqfwxggtvpjhzmzmdw\nrlxjgmvdftvrmvbdwudra\nvsntnjpepnvdaxiporggmglhagv\nxlvcqkqgcrbgtgglj\nlyxwxbiszyhlsrgzeedzprbmcpduvq\nyrmqqvrkqskqukzqrwukpsifgtdc\nxpuohcsjhhuhvr\nvvlfrlxpvqejngwrbfbpmqeirxlw\nsvmasocxdvadmaxtrpakysmeaympy\nyuflqboqfdt", "output": "lkpmx\nk26v\nh22a\nt13w\nq12c\ntrissbaf\nq21d\nz13x\no17x\nlpuzqgec\ng18w\nr19a\nv25v\nx15j\nl28q\ny26c\nx12r\nv26w\ns27y\ny9t" }, { "input": "100\nm\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr", "output": "m\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr" } ]

1,681,133,199

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

15

0

user_input = input().split("\n ") for i in user_input(): if user_input.isalpha(): if len(user_input) < 10: print(user_input) else: print(f"{user_input[0]}{len(user_input)-2}{user_input[-1]}")

Title: Way Too Long Words Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters. Output Specification: Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data. Demo Input: ['4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n'] Demo Output: ['word\nl10n\ni18n\np43s\n'] Note: none

```python user_input = input().split("\n ") for i in user_input(): if user_input.isalpha(): if len(user_input) < 10: print(user_input) else: print(f"{user_input[0]}{len(user_input)-2}{user_input[-1]}") ```

-1

61

A

Ultra-Fast Mathematician

PROGRAMMING

800

[ "implementation" ]

A. Ultra-Fast Mathematician

2

256

Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 1018 numbers in a single second. One day in 230 AD Shapur was trying to find out if any one can possibly do calculations faster than him. As a result he made a very great contest and asked every one to come and take part. In his contest he gave the contestants many different pairs of numbers. Each number is made from digits 0 or 1. The contestants should write a new number corresponding to the given pair of numbers. The rule is simple: The *i*-th digit of the answer is 1 if and only if the *i*-th digit of the two given numbers differ. In the other case the *i*-th digit of the answer is 0. Shapur made many numbers and first tried his own speed. He saw that he can perform these operations on numbers of length ∞ (length of a number is number of digits in it) in a glance! He always gives correct answers so he expects the contestants to give correct answers, too. He is a good fellow so he won't give anyone very big numbers and he always gives one person numbers of same length. Now you are going to take part in Shapur's contest. See if you are faster and more accurate.

There are two lines in each input. Each of them contains a single number. It is guaranteed that the numbers are made from 0 and 1 only and that their length is same. The numbers may start with 0. The length of each number doesn't exceed 100.

Write one line — the corresponding answer. Do not omit the leading 0s.

[ "1010100\n0100101\n", "000\n111\n", "1110\n1010\n", "01110\n01100\n" ]

[ "1110001\n", "111\n", "0100\n", "00010\n" ]

none

500

[ { "input": "1010100\n0100101", "output": "1110001" }, { "input": "000\n111", "output": "111" }, { "input": "1110\n1010", "output": "0100" }, { "input": "01110\n01100", "output": "00010" }, { "input": "011101\n000001", "output": "011100" }, { "input": "10\n01", "output": "11" }, { "input": "00111111\n11011101", "output": "11100010" }, { "input": "011001100\n101001010", "output": "110000110" }, { "input": "1100100001\n0110101100", "output": "1010001101" }, { "input": "00011101010\n10010100101", "output": "10001001111" }, { "input": "100000101101\n111010100011", "output": "011010001110" }, { "input": "1000001111010\n1101100110001", "output": "0101101001011" }, { "input": "01011111010111\n10001110111010", "output": "11010001101101" }, { "input": "110010000111100\n001100101011010", "output": "111110101100110" }, { "input": "0010010111110000\n0000000011010110", "output": "0010010100100110" }, { "input": "00111110111110000\n01111100001100000", "output": "01000010110010000" }, { "input": "101010101111010001\n001001111101111101", "output": "100011010010101100" }, { "input": "0110010101111100000\n0011000101000000110", "output": "0101010000111100110" }, { "input": "11110100011101010111\n00001000011011000000", "output": "11111100000110010111" }, { "input": "101010101111101101001\n111010010010000011111", "output": "010000111101101110110" }, { "input": "0000111111100011000010\n1110110110110000001010", "output": "1110001001010011001000" }, { "input": "10010010101000110111000\n00101110100110111000111", "output": "10111100001110001111111" }, { "input": "010010010010111100000111\n100100111111100011001110", "output": "110110101101011111001001" }, { "input": "0101110100100111011010010\n0101100011010111001010001", "output": "0000010111110000010000011" }, { "input": "10010010100011110111111011\n10000110101100000001000100", "output": "00010100001111110110111111" }, { "input": "000001111000000100001000000\n011100111101111001110110001", "output": "011101000101111101111110001" }, { "input": "0011110010001001011001011100\n0000101101000011101011001010", "output": "0011011111001010110010010110" }, { "input": "11111000000000010011001101111\n11101110011001010100010000000", "output": "00010110011001000111011101111" }, { "input": "011001110000110100001100101100\n001010000011110000001000101001", "output": "010011110011000100000100000101" }, { "input": "1011111010001100011010110101111\n1011001110010000000101100010101", "output": "0000110100011100011111010111010" }, { "input": "10111000100001000001010110000001\n10111000001100101011011001011000", "output": "00000000101101101010001111011001" }, { "input": "000001010000100001000000011011100\n111111111001010100100001100000111", "output": "111110101001110101100001111011011" }, { "input": "1101000000000010011011101100000110\n1110000001100010011010000011011110", "output": "0011000001100000000001101111011000" }, { "input": "01011011000010100001100100011110001\n01011010111000001010010100001110000", "output": "00000001111010101011110000010000001" }, { "input": "000011111000011001000110111100000100\n011011000110000111101011100111000111", "output": "011000111110011110101101011011000011" }, { "input": "1001000010101110001000000011111110010\n0010001011010111000011101001010110000", "output": "1011001001111001001011101010101000010" }, { "input": "00011101011001100101111111000000010101\n10010011011011001011111000000011101011", "output": "10001110000010101110000111000011111110" }, { "input": "111011100110001001101111110010111001010\n111111101101111001110010000101101000100", "output": "000100001011110000011101110111010001110" }, { "input": "1111001001101000001000000010010101001010\n0010111100111110001011000010111110111001", "output": "1101110101010110000011000000101011110011" }, { "input": "00100101111000000101011111110010100011010\n11101110001010010101001000111110101010100", "output": "11001011110010010000010111001100001001110" }, { "input": "101011001110110100101001000111010101101111\n100111100110101011010100111100111111010110", "output": "001100101000011111111101111011101010111001" }, { "input": "1111100001100101000111101001001010011100001\n1000110011000011110010001011001110001000001", "output": "0111010010100110110101100010000100010100000" }, { "input": "01100111011111010101000001101110000001110101\n10011001011111110000000101011001001101101100", "output": "11111110000000100101000100110111001100011001" }, { "input": "110010100111000100100101100000011100000011001\n011001111011100110000110111001110110100111011", "output": "101011011100100010100011011001101010100100010" }, { "input": "0001100111111011010110100100111000000111000110\n1100101011000000000001010010010111001100110001", "output": "1101001100111011010111110110101111001011110111" }, { "input": "00000101110110110001110010100001110100000100000\n10010000110011110001101000111111101010011010001", "output": "10010101000101000000011010011110011110011110001" }, { "input": "110000100101011100100011001111110011111110010001\n101011111001011100110110111101110011010110101100", "output": "011011011100000000010101110010000000101000111101" }, { "input": "0101111101011111010101011101000011101100000000111\n0000101010110110001110101011011110111001010100100", "output": "0101010111101001011011110110011101010101010100011" }, { "input": "11000100010101110011101000011111001010110111111100\n00001111000111001011111110000010101110111001000011", "output": "11001011010010111000010110011101100100001110111111" }, { "input": "101000001101111101101111111000001110110010101101010\n010011100111100001100000010001100101000000111011011", "output": "111011101010011100001111101001101011110010010110001" }, { "input": "0011111110010001010100010110111000110011001101010100\n0111000000100010101010000100101000000100101000111001", "output": "0100111110110011111110010010010000110111100101101101" }, { "input": "11101010000110000011011010000001111101000111011111100\n10110011110001010100010110010010101001010111100100100", "output": "01011001110111010111001100010011010100010000111011000" }, { "input": "011000100001000001101000010110100110011110100111111011\n111011001000001001110011001111011110111110110011011111", "output": "100011101001001000011011011001111000100000010100100100" }, { "input": "0111010110010100000110111011010110100000000111110110000\n1011100100010001101100000100111111101001110010000100110", "output": "1100110010000101101010111111101001001001110101110010110" }, { "input": "10101000100111000111010001011011011011110100110101100011\n11101111000000001100100011111000100100000110011001101110", "output": "01000111100111001011110010100011111111110010101100001101" }, { "input": "000000111001010001000000110001001011100010011101010011011\n110001101000010010000101000100001111101001100100001010010", "output": "110001010001000011000101110101000100001011111001011001001" }, { "input": "0101011100111010000111110010101101111111000000111100011100\n1011111110000010101110111001000011100000100111111111000111", "output": "1110100010111000101001001011101110011111100111000011011011" }, { "input": "11001000001100100111100111100100101011000101001111001001101\n10111110100010000011010100110100100011101001100000001110110", "output": "01110110101110100100110011010000001000101100101111000111011" }, { "input": "010111011011101000000110000110100110001110100001110110111011\n101011110011101011101101011111010100100001100111100100111011", "output": "111100101000000011101011011001110010101111000110010010000000" }, { "input": "1001011110110110000100011001010110000100011010010111010101110\n1101111100001000010111110011010101111010010100000001000010111", "output": "0100100010111110010011101010000011111110001110010110010111001" }, { "input": "10000010101111100111110101111000010100110111101101111111111010\n10110110101100101010011001011010100110111011101100011001100111", "output": "00110100000011001101101100100010110010001100000001100110011101" }, { "input": "011111010011111000001010101001101001000010100010111110010100001\n011111001011000011111001000001111001010110001010111101000010011", "output": "000000011000111011110011101000010000010100101000000011010110010" }, { "input": "1111000000110001011101000100100100001111011100001111001100011111\n1101100110000101100001100000001001011011111011010101000101001010", "output": "0010100110110100111100100100101101010100100111011010001001010101" }, { "input": "01100000101010010011001110100110110010000110010011011001100100011\n10110110010110111100100111000111000110010000000101101110000010111", "output": "11010110111100101111101001100001110100010110010110110111100110100" }, { "input": "001111111010000100001100001010011001111110011110010111110001100111\n110000101001011000100010101100100110000111100000001101001110010111", "output": "111111010011011100101110100110111111111001111110011010111111110000" }, { "input": "1011101011101101011110101101011101011000010011100101010101000100110\n0001000001001111010111100100111101100000000001110001000110000000110", "output": "1010101010100010001001001001100000111000010010010100010011000100000" }, { "input": "01000001011001010011011100010000100100110101111011011011110000001110\n01011110000110011011000000000011000111100001010000000011111001110000", "output": "00011111011111001000011100010011100011010100101011011000001001111110" }, { "input": "110101010100110101000001111110110100010010000100111110010100110011100\n111010010111111011100110101011001011001110110111110100000110110100111", "output": "001111000011001110100111010101111111011100110011001010010010000111011" }, { "input": "1001101011000001011111100110010010000011010001001111011100010100110001\n1111100111110101001111010001010000011001001001010110001111000000100101", "output": "0110001100110100010000110111000010011010011000011001010011010100010100" }, { "input": "00000111110010110001110110001010010101000111011001111111100110011110010\n00010111110100000100110101000010010001100001100011100000001100010100010", "output": "00010000000110110101000011001000000100100110111010011111101010001010000" }, { "input": "100101011100101101000011010001011001101110101110001100010001010111001110\n100001111100101011011111110000001111000111001011111110000010101110111001", "output": "000100100000000110011100100001010110101001100101110010010011111001110111" }, { "input": "1101100001000111001101001011101000111000011110000001001101101001111011010\n0101011101010100011011010110101000010010110010011110101100000110110001000", "output": "1000111100010011010110011101000000101010101100011111100001101111001010010" }, { "input": "01101101010011110101100001110101111011100010000010001101111000011110111111\n00101111001101001100111010000101110000100101101111100111101110010100011011", "output": "01000010011110111001011011110000001011000111101101101010010110001010100100" }, { "input": "101100101100011001101111110110110010100110110010100001110010110011001101011\n000001011010101011110011111101001110000111000010001101000010010000010001101", "output": "101101110110110010011100001011111100100001110000101100110000100011011100110" }, { "input": "0010001011001010001100000010010011110110011000100000000100110000101111001110\n1100110100111000110100001110111001011101001100001010100001010011100110110001", "output": "1110111111110010111000001100101010101011010100101010100101100011001001111111" }, { "input": "00101101010000000101011001101011001100010001100000101011101110000001111001000\n10010110010111000000101101000011101011001010000011011101101011010000000011111", "output": "10111011000111000101110100101000100111011011100011110110000101010001111010111" }, { "input": "111100000100100000101001100001001111001010001000001000000111010000010101101011\n001000100010100101111011111011010110101100001111011000010011011011100010010110", "output": "110100100110000101010010011010011001100110000111010000010100001011110111111101" }, { "input": "0110001101100100001111110101101000100101010010101010011001101001001101110000000\n0111011000000010010111011110010000000001000110001000011001101000000001110100111", "output": "0001010101100110011000101011111000100100010100100010000000000001001100000100111" }, { "input": "10001111111001000101001011110101111010100001011010101100111001010001010010001000\n10000111010010011110111000111010101100000011110001101111001000111010100000000001", "output": "00001000101011011011110011001111010110100010101011000011110001101011110010001001" }, { "input": "100110001110110000100101001110000011110110000110000000100011110100110110011001101\n110001110101110000000100101001101011111100100100001001000110000001111100011110110", "output": "010111111011000000100001100111101000001010100010001001100101110101001010000111011" }, { "input": "0000010100100000010110111100011111111010011101000000100000011001001101101100111010\n0100111110011101010110101011110110010111001111000110101100101110111100101000111111", "output": "0100101010111101000000010111101001101101010010000110001100110111110001000100000101" }, { "input": "11000111001010100001110000001001011010010010110000001110100101000001010101100110111\n11001100100100100001101010110100000111100011101110011010110100001001000011011011010", "output": "00001011101110000000011010111101011101110001011110010100010001001000010110111101101" }, { "input": "010110100010001000100010101001101010011010111110100001000100101000111011100010100001\n110000011111101101010011111000101010111010100001001100001001100101000000111000000000", "output": "100110111101100101110001010001000000100000011111101101001101001101111011011010100001" }, { "input": "0000011110101110010101110110110101100001011001101010101001000010000010000000101001101\n1100111111011100000110000111101110011111100111110001011001000010011111100001001100011", "output": "1100100001110010010011110001011011111110111110011011110000000000011101100001100101110" }, { "input": "10100000101101110001100010010010100101100011010010101000110011100000101010110010000000\n10001110011011010010111011011101101111000111110000111000011010010101001100000001010011", "output": "00101110110110100011011001001111001010100100100010010000101001110101100110110011010011" }, { "input": "001110000011111101101010011111000101010111010100001001100001001100101000000111000000000\n111010000000000000101001110011001000111011001100101010011001000011101001001011110000011", "output": "110100000011111101000011101100001101101100011000100011111000001111000001001100110000011" }, { "input": "1110111100111011010101011011001110001010010010110011110010011111000010011111010101100001\n1001010101011001001010100010101100000110111101011000100010101111111010111100001110010010", "output": "0111101001100010011111111001100010001100101111101011010000110000111000100011011011110011" }, { "input": "11100010001100010011001100001100010011010001101110011110100101110010101101011101000111111\n01110000000110111010110100001010000101011110100101010011000110101110101101110111011110001", "output": "10010010001010101001111000000110010110001111001011001101100011011100000000101010011001110" }, { "input": "001101011001100101101100110000111000101011001001100100000100101000100000110100010111111101\n101001111110000010111101111110001001111001111101111010000110111000100100110010010001011111", "output": "100100100111100111010001001110110001010010110100011110000010010000000100000110000110100010" }, { "input": "1010110110010101000110010010110101011101010100011001101011000110000000100011100100011000000\n0011011111100010001111101101000111001011101110100000110111100100101111010110101111011100011", "output": "1001101001110111001001111111110010010110111010111001011100100010101111110101001011000100011" }, { "input": "10010010000111010111011111110010100101100000001100011100111011100010000010010001011100001100\n00111010100010110010000100010111010001111110100100100011101000101111111111001101101100100100", "output": "10101000100101100101011011100101110100011110101000111111010011001101111101011100110000101000" }, { "input": "010101110001010101100000010111010000000111110011001101100011001000000011001111110000000010100\n010010111011100101010101111110110000000111000100001101101001001000001100101110001010000100001", "output": "000111001010110000110101101001100000000000110111000000001010000000001111100001111010000110101" }, { "input": "1100111110011001000111101001001011000110011010111111100010111111001100111111011101100111101011\n1100000011001000110100110111000001011001010111101000010010100011000001100100111101101000010110", "output": "0000111101010001110011011110001010011111001101010111110000011100001101011011100000001111111101" }, { "input": "00011000100100110111100101100100000000010011110111110010101110110011100001010111010011110100101\n00011011111011111011100101100111100101001110010111000010000111000100100100000001110101111011011", "output": "00000011011111001100000000000011100101011101100000110000101001110111000101010110100110001111110" }, { "input": "000101011001001100000111100010110101111011110101111101000110001101011010111110110011100100000001\n011000101010011111011000111000100000000011011000000001111110001000001111101010110000011100001111", "output": "011101110011010011011111011010010101111000101101111100111000000101010101010100000011111000001110" }, { "input": "1000101001011010000100100100010010011101011001110101111011101111111110010101001101010001010101001\n0110110010011100011111011111110111000000010001110100001010111110101011010011111011111110000110000", "output": "1110011011000110011011111011100101011101001000000001110001010001010101000110110110101111010011001" }, { "input": "01111010010101100111110111111011011010100001011101010000111100101101101110111011001100101011100111\n00001100110110100001111011000010001001001100000010111101000001111011100000010111010010000011000010", "output": "01110110100011000110001100111001010011101101011111101101111101010110001110101100011110101000100101" }, { "input": "111101011101111000001011001101111010110111001101110100100011111011011101001101010101011010111000110\n101111100101101101001100110011000001111010011101110111110110101110011011110011111100001001110101101", "output": "010010111000010101000111111110111011001101010000000011010101010101000110111110101001010011001101011" }, { "input": "1010000011010110011101001101110001110010000111011101110010110110111111001001110100101100010101010001\n0111101000111100101100000101111010100100001000011101010100110011100011010011010101000100101011100011", "output": "1101101011101010110001001000001011010110001111000000100110000101011100011010100001101000111110110010" }, { "input": "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001\n1111111010111111101011111110101111111010111111101011111110101111111010111111101011111110101111111010", "output": "1111111010111111101011111110101111111010111111101011111110101111111010111111101011111110101111111011" }, { "input": "0\n0", "output": "0" }, { "input": "0\n1", "output": "1" } ]

1,695,408,789

2,147,483,647

Python 3

OK

TESTS

102

46

0

x = list(input()) y = list(input()) z = [] for i in range(len(x)): if int(x[i]) ^ int(y[i]): z.append(1) else: z.append(0) print(''.join(str(item) for item in z))

Title: Ultra-Fast Mathematician Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Shapur was an extremely gifted student. He was great at everything including Combinatorics, Algebra, Number Theory, Geometry, Calculus, etc. He was not only smart but extraordinarily fast! He could manage to sum 1018 numbers in a single second. One day in 230 AD Shapur was trying to find out if any one can possibly do calculations faster than him. As a result he made a very great contest and asked every one to come and take part. In his contest he gave the contestants many different pairs of numbers. Each number is made from digits 0 or 1. The contestants should write a new number corresponding to the given pair of numbers. The rule is simple: The *i*-th digit of the answer is 1 if and only if the *i*-th digit of the two given numbers differ. In the other case the *i*-th digit of the answer is 0. Shapur made many numbers and first tried his own speed. He saw that he can perform these operations on numbers of length ∞ (length of a number is number of digits in it) in a glance! He always gives correct answers so he expects the contestants to give correct answers, too. He is a good fellow so he won't give anyone very big numbers and he always gives one person numbers of same length. Now you are going to take part in Shapur's contest. See if you are faster and more accurate. Input Specification: There are two lines in each input. Each of them contains a single number. It is guaranteed that the numbers are made from 0 and 1 only and that their length is same. The numbers may start with 0. The length of each number doesn't exceed 100. Output Specification: Write one line — the corresponding answer. Do not omit the leading 0s. Demo Input: ['1010100\n0100101\n', '000\n111\n', '1110\n1010\n', '01110\n01100\n'] Demo Output: ['1110001\n', '111\n', '0100\n', '00010\n'] Note: none

```python x = list(input()) y = list(input()) z = [] for i in range(len(x)): if int(x[i]) ^ int(y[i]): z.append(1) else: z.append(0) print(''.join(str(item) for item in z)) ```

3.9885

129

A

Cookies

PROGRAMMING

900

[ "implementation" ]

null

Olga came to visit the twins Anna and Maria and saw that they have many cookies. The cookies are distributed into bags. As there are many cookies, Olga decided that it's no big deal if she steals a bag. However, she doesn't want the sisters to quarrel because of nothing when they divide the cookies. That's why Olga wants to steal a bag with cookies so that the number of cookies in the remaining bags was even, that is, so that Anna and Maria could evenly divide it into two (even 0 remaining cookies will do, just as any other even number). How many ways there are to steal exactly one cookie bag so that the total number of cookies in the remaining bags was even?

The first line contains the only integer *n* (1<=≤<=*n*<=≤<=100) — the number of cookie bags Anna and Maria have. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=100) — the number of cookies in the *i*-th bag.

Print in the only line the only number — the sought number of ways. If there are no such ways print 0.

[ "1\n1\n", "10\n1 2 2 3 4 4 4 2 2 2\n", "11\n2 2 2 2 2 2 2 2 2 2 99\n" ]

[ "1\n", "8\n", "1\n" ]

In the first sample Olga should take the only bag so that the twins ended up with the even number of cookies. In the second sample Olga can take any of five bags with two cookies or any of three bags with four cookies — 5 + 3 = 8 ways in total. In the third sample, no matter which bag with two cookies Olga chooses, the twins are left with 2 * 9 + 99 = 117 cookies. Thus, Olga has only one option: to take the bag with 99 cookies.

500

[ { "input": "1\n1", "output": "1" }, { "input": "10\n1 2 2 3 4 4 4 2 2 2", "output": "8" }, { "input": "11\n2 2 2 2 2 2 2 2 2 2 99", "output": "1" }, { "input": "2\n1 1", "output": "0" }, { "input": "2\n2 2", "output": "2" }, { "input": "2\n1 2", "output": "1" }, { "input": "7\n7 7 7 7 7 7 7", "output": "7" }, { "input": "8\n1 2 3 4 5 6 7 8", "output": "4" }, { "input": "100\n1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2", "output": "50" }, { "input": "99\n99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99 100 99", "output": "49" }, { "input": "82\n43 44 96 33 23 42 33 66 53 87 8 90 43 91 40 88 51 18 48 62 59 10 22 20 54 6 13 63 2 56 31 52 98 42 54 32 26 77 9 24 33 91 16 30 39 34 78 82 73 90 12 15 67 76 30 18 44 86 84 98 65 54 100 79 28 34 40 56 11 43 72 35 86 59 89 40 30 33 7 19 44 15", "output": "50" }, { "input": "17\n50 14 17 77 74 74 38 76 41 27 45 29 66 98 38 73 38", "output": "7" }, { "input": "94\n81 19 90 99 26 11 86 44 78 36 80 59 99 90 78 72 71 20 94 56 42 40 71 84 10 85 10 70 52 27 39 55 90 16 48 25 7 79 99 100 38 10 99 56 3 4 78 9 16 57 14 40 52 54 57 70 30 86 56 84 97 60 59 69 49 66 23 92 90 46 86 73 53 47 1 83 14 20 24 66 13 45 41 14 86 75 55 88 48 95 82 24 47 87", "output": "39" }, { "input": "88\n64 95 12 90 40 65 98 45 52 54 79 7 81 25 98 19 68 82 41 53 35 50 5 22 32 21 8 39 8 6 72 27 81 30 12 79 21 42 60 2 66 87 46 93 62 78 52 71 76 32 78 94 86 85 55 15 34 76 41 20 32 26 94 81 89 45 74 49 11 40 40 39 49 46 80 85 90 23 80 40 86 58 70 26 48 93 23 53", "output": "37" }, { "input": "84\n95 9 43 43 13 84 60 90 1 8 97 99 54 34 59 83 33 15 51 26 40 12 66 65 19 30 29 78 92 60 25 13 19 84 71 73 12 24 54 49 16 41 11 40 57 59 34 40 39 9 71 83 1 77 79 53 94 47 78 55 77 85 29 52 80 90 53 77 97 97 27 79 28 23 83 25 26 22 49 86 63 56 3 32", "output": "51" }, { "input": "47\n61 97 76 94 91 22 2 68 62 73 90 47 16 79 44 71 98 68 43 6 53 52 40 27 68 67 43 96 14 91 60 61 96 24 97 13 32 65 85 96 81 77 34 18 23 14 80", "output": "21" }, { "input": "69\n71 1 78 74 58 89 30 6 100 90 22 61 11 59 14 74 27 25 78 61 45 19 25 33 37 4 52 43 53 38 9 100 56 67 69 38 76 91 63 60 93 52 28 61 9 98 8 14 57 63 89 64 98 51 36 66 36 86 13 82 50 91 52 64 86 78 78 83 81", "output": "37" }, { "input": "52\n38 78 36 75 19 3 56 1 39 97 24 79 84 16 93 55 96 64 12 24 1 86 80 29 12 32 36 36 73 39 76 65 53 98 30 20 28 8 86 43 70 22 75 69 62 65 81 25 53 40 71 59", "output": "28" }, { "input": "74\n81 31 67 97 26 75 69 81 11 13 13 74 77 88 52 20 52 64 66 75 72 28 41 54 26 75 41 91 75 15 18 36 13 83 63 61 14 48 53 63 19 67 35 48 23 65 73 100 44 55 92 88 99 17 73 25 83 7 31 89 12 80 98 39 42 75 14 29 81 35 77 87 33 94", "output": "47" }, { "input": "44\n46 56 31 31 37 71 94 2 14 100 45 72 36 72 80 3 38 54 42 98 50 32 31 42 62 31 45 50 95 100 18 17 64 22 18 25 52 56 70 57 43 40 81 28", "output": "15" }, { "input": "22\n28 57 40 74 51 4 45 84 99 12 95 14 92 60 47 81 84 51 31 91 59 42", "output": "11" }, { "input": "59\n73 45 94 76 41 49 65 13 74 66 36 25 47 75 40 23 92 72 11 32 32 8 81 26 68 56 41 8 76 47 96 55 70 11 84 14 83 18 70 22 30 39 28 100 48 11 92 45 78 69 86 1 54 90 98 91 13 17 35", "output": "33" }, { "input": "63\n20 18 44 94 68 57 16 43 74 55 68 24 21 95 76 84 50 50 47 86 86 12 58 55 28 72 86 18 34 45 81 88 3 72 41 9 60 90 81 93 12 6 9 6 2 41 1 7 9 29 81 14 64 80 20 36 67 54 7 5 35 81 22", "output": "37" }, { "input": "28\n49 84 48 19 44 91 11 82 96 95 88 90 71 82 87 25 31 23 18 13 98 45 26 65 35 12 31 14", "output": "15" }, { "input": "61\n34 18 28 64 28 45 9 77 77 20 63 92 79 16 16 100 86 2 91 91 57 15 31 95 10 88 84 5 82 83 53 98 59 17 97 80 76 80 81 3 91 81 87 93 61 46 10 49 6 22 21 75 63 89 21 81 30 19 67 38 77", "output": "35" }, { "input": "90\n41 90 43 1 28 75 90 50 3 70 76 64 81 63 25 69 83 82 29 91 59 66 21 61 7 55 72 49 38 69 72 20 64 58 30 81 61 29 96 14 39 5 100 20 29 98 75 29 44 78 97 45 26 77 73 59 22 99 41 6 3 96 71 20 9 18 96 18 90 62 34 78 54 5 41 6 73 33 2 54 26 21 18 6 45 57 43 73 95 75", "output": "42" }, { "input": "45\n93 69 4 27 20 14 71 48 79 3 32 26 49 30 57 88 13 56 49 61 37 32 47 41 41 70 45 68 82 18 8 6 25 20 15 13 71 99 28 6 52 34 19 59 26", "output": "23" }, { "input": "33\n29 95 48 49 91 10 83 71 47 25 66 36 51 12 34 10 54 74 41 96 89 26 89 1 42 33 1 62 9 32 49 65 78", "output": "15" }, { "input": "34\n98 24 42 36 41 82 28 58 89 34 77 70 76 44 74 54 66 100 13 79 4 88 21 1 11 45 91 29 87 100 29 54 82 78", "output": "13" }, { "input": "29\n91 84 26 84 9 63 52 9 65 56 90 2 36 7 67 33 91 14 65 38 53 36 81 83 85 14 33 95 51", "output": "17" }, { "input": "100\n2 88 92 82 87 100 78 28 84 43 78 32 43 33 97 19 15 52 29 84 57 72 54 13 99 28 82 79 40 70 34 92 91 53 9 88 27 43 14 92 72 37 26 37 20 95 19 34 49 64 33 37 34 27 80 79 9 54 99 68 25 4 68 73 46 66 24 78 3 87 26 52 50 84 4 95 23 83 39 58 86 36 33 16 98 2 84 19 53 12 69 60 10 11 78 17 79 92 77 59", "output": "45" }, { "input": "100\n2 95 45 73 9 54 20 97 57 82 88 26 18 71 25 27 75 54 31 11 58 85 69 75 72 91 76 5 25 80 45 49 4 73 8 81 81 38 5 12 53 77 7 96 90 35 28 80 73 94 19 69 96 17 94 49 69 9 32 19 5 12 46 29 26 40 59 59 6 95 82 50 72 2 45 69 12 5 72 29 39 72 23 96 81 28 28 56 68 58 37 41 30 1 90 84 15 24 96 43", "output": "53" }, { "input": "100\n27 72 35 91 13 10 35 45 24 55 83 84 63 96 29 79 34 67 63 92 48 83 18 77 28 27 49 66 29 88 55 15 6 58 14 67 94 36 77 7 7 64 61 52 71 18 36 99 76 6 50 67 16 13 41 7 89 73 61 51 78 22 78 32 76 100 3 31 89 71 63 53 15 85 77 54 89 33 68 74 3 23 57 5 43 89 75 35 9 86 90 11 31 46 48 37 74 17 77 8", "output": "40" }, { "input": "100\n69 98 69 88 11 49 55 8 25 91 17 81 47 26 15 73 96 71 18 42 42 61 48 14 92 78 35 72 4 27 62 75 83 79 17 16 46 80 96 90 82 54 37 69 85 21 67 70 96 10 46 63 21 59 56 92 54 88 77 30 75 45 44 29 86 100 51 11 65 69 66 56 82 63 27 1 51 51 13 10 3 55 26 85 34 16 87 72 13 100 81 71 90 95 86 50 83 55 55 54", "output": "53" }, { "input": "100\n34 35 99 64 2 66 78 93 20 48 12 79 19 10 87 7 42 92 60 79 5 2 24 89 57 48 63 92 74 4 16 51 7 12 90 48 87 17 18 73 51 58 97 97 25 38 15 97 96 73 67 91 6 75 14 13 87 79 75 3 15 55 35 95 71 45 10 13 20 37 82 26 2 22 13 83 97 84 39 79 43 100 54 59 98 8 61 34 7 65 75 44 24 77 73 88 34 95 44 77", "output": "55" }, { "input": "100\n15 86 3 1 51 26 74 85 37 87 64 58 10 6 57 26 30 47 85 65 24 72 50 40 12 35 91 47 91 60 47 87 95 34 80 91 26 3 36 39 14 86 28 70 51 44 28 21 72 79 57 61 16 71 100 94 57 67 36 74 24 21 89 85 25 2 97 67 76 53 76 80 97 64 35 13 8 32 21 52 62 61 67 14 74 73 66 44 55 76 24 3 43 42 99 61 36 80 38 66", "output": "52" }, { "input": "100\n45 16 54 54 80 94 74 93 75 85 58 95 79 30 81 2 84 4 57 23 92 64 78 1 50 36 13 27 56 54 10 77 87 1 5 38 85 74 94 82 30 45 72 83 82 30 81 82 82 3 69 82 7 92 39 60 94 42 41 5 3 17 67 21 79 44 79 96 28 3 53 68 79 89 63 83 1 44 4 31 84 15 73 77 19 66 54 6 73 1 67 24 91 11 86 45 96 82 20 89", "output": "51" }, { "input": "100\n84 23 50 32 90 71 92 43 58 70 6 82 7 55 85 19 70 89 12 26 29 56 74 30 2 27 4 39 63 67 91 81 11 33 75 10 82 88 39 43 43 80 68 35 55 67 53 62 73 65 86 74 43 51 14 48 42 92 83 57 22 33 24 99 5 27 78 96 7 28 11 15 8 38 85 67 5 92 24 96 57 59 14 95 91 4 9 18 45 33 74 83 64 85 14 51 51 94 29 2", "output": "53" }, { "input": "100\n77 56 56 45 73 55 32 37 39 50 30 95 79 21 44 34 51 43 86 91 39 30 85 15 35 93 100 14 57 31 80 79 38 40 88 4 91 54 7 95 76 26 62 84 17 33 67 47 6 82 69 51 17 2 59 24 11 12 31 90 12 11 55 38 72 49 30 50 42 46 5 97 9 9 30 45 86 23 19 82 40 42 5 40 35 98 35 32 60 60 5 28 84 35 21 49 68 53 68 23", "output": "48" }, { "input": "100\n78 38 79 61 45 86 83 83 86 90 74 69 2 84 73 39 2 5 20 71 24 80 54 89 58 34 77 40 39 62 2 47 28 53 97 75 88 98 94 96 33 71 44 90 47 36 19 89 87 98 90 87 5 85 34 79 82 3 42 88 89 63 35 7 89 30 40 48 12 41 56 76 83 60 80 80 39 56 77 4 72 96 30 55 57 51 7 19 11 1 66 1 91 87 11 62 95 85 79 25", "output": "48" }, { "input": "100\n5 34 23 20 76 75 19 51 17 82 60 13 83 6 65 16 20 43 66 54 87 10 87 73 50 24 16 98 33 28 80 52 54 82 26 92 14 13 84 92 94 29 61 21 60 20 48 94 24 20 75 70 58 27 68 45 86 89 29 8 67 38 83 48 18 100 11 22 46 84 52 97 70 19 50 75 3 7 52 53 72 41 18 31 1 38 49 53 11 64 99 76 9 87 48 12 100 32 44 71", "output": "58" }, { "input": "100\n76 89 68 78 24 72 73 95 98 72 58 15 2 5 56 32 9 65 50 70 94 31 29 54 89 52 31 93 43 56 26 35 72 95 51 55 78 70 11 92 17 5 54 94 81 31 78 95 73 91 95 37 59 9 53 48 65 55 84 8 45 97 64 37 96 34 36 53 66 17 72 48 99 23 27 18 92 84 44 73 60 78 53 29 68 99 19 39 61 40 69 6 77 12 47 29 15 4 8 45", "output": "53" }, { "input": "100\n82 40 31 53 8 50 85 93 3 84 54 17 96 59 51 42 18 19 35 84 79 31 17 46 54 82 72 49 35 73 26 89 61 73 3 50 12 29 25 77 88 21 58 24 22 89 96 54 82 29 96 56 77 16 1 68 90 93 20 23 57 22 31 18 92 90 51 14 50 72 31 54 12 50 66 62 2 34 17 45 68 50 87 97 23 71 1 72 17 82 42 15 20 78 4 49 66 59 10 17", "output": "54" }, { "input": "100\n32 82 82 24 39 53 48 5 29 24 9 37 91 37 91 95 1 97 84 52 12 56 93 47 22 20 14 17 40 22 79 34 24 2 69 30 69 29 3 89 21 46 60 92 39 29 18 24 49 18 40 22 60 13 77 50 39 64 50 70 99 8 66 31 90 38 20 54 7 21 5 56 41 68 69 20 54 89 69 62 9 53 43 89 81 97 15 2 52 78 89 65 16 61 59 42 56 25 32 52", "output": "49" }, { "input": "100\n72 54 23 24 97 14 99 87 15 25 7 23 17 87 72 31 71 87 34 82 51 77 74 85 62 38 24 7 84 48 98 21 29 71 70 84 25 58 67 92 18 44 32 9 81 15 53 29 63 18 86 16 7 31 38 99 70 32 89 16 23 11 66 96 69 82 97 59 6 9 49 80 85 19 6 9 52 51 85 74 53 46 73 55 31 63 78 61 34 80 77 65 87 77 92 52 89 8 52 31", "output": "44" }, { "input": "100\n56 88 8 19 7 15 11 54 35 50 19 57 63 72 51 43 50 19 57 90 40 100 8 92 11 96 30 32 59 65 93 47 62 3 50 41 30 50 72 83 61 46 83 60 20 46 33 1 5 18 83 22 34 16 41 95 63 63 7 59 55 95 91 29 64 60 64 81 45 45 10 9 88 37 69 85 21 82 41 76 42 34 47 78 51 83 65 100 13 22 59 76 63 1 26 86 36 94 99 74", "output": "46" }, { "input": "100\n27 89 67 60 62 80 43 50 28 88 72 5 94 11 63 91 18 78 99 3 71 26 12 97 74 62 23 24 22 3 100 72 98 7 94 32 12 75 61 88 42 48 10 14 45 9 48 56 73 76 70 70 79 90 35 39 96 37 81 11 19 65 99 39 23 79 34 61 35 74 90 37 73 23 46 21 94 84 73 58 11 89 13 9 10 85 42 78 73 32 53 39 49 90 43 5 28 31 97 75", "output": "53" }, { "input": "100\n33 24 97 96 1 14 99 51 13 65 67 20 46 88 42 44 20 49 5 89 98 83 15 40 74 83 58 3 10 79 34 2 69 28 37 100 55 52 14 8 44 94 97 89 6 42 11 28 30 33 55 56 20 57 52 25 75 1 87 42 62 41 37 12 54 85 95 80 42 36 94 96 28 76 54 36 4 17 26 24 62 15 17 79 84 36 92 78 74 91 96 77 54 92 81 91 62 98 37 37", "output": "43" }, { "input": "100\n86 24 61 15 11 85 1 31 47 36 23 36 59 34 3 27 16 29 82 28 58 52 52 66 71 61 98 39 60 20 67 41 67 90 73 29 92 17 70 95 58 98 58 32 21 73 46 56 87 72 80 75 40 27 94 31 59 92 93 37 14 99 96 21 97 23 81 91 52 52 96 94 92 28 38 29 52 16 57 27 17 24 91 21 79 55 96 98 95 94 23 78 79 12 77 35 32 75 100 82", "output": "51" }, { "input": "100\n88 85 41 37 69 21 7 69 36 5 92 26 64 75 22 46 67 20 70 22 62 66 38 24 47 49 68 30 90 31 67 86 86 82 9 51 43 45 48 42 73 44 31 94 45 60 54 66 20 87 11 94 34 32 87 66 56 28 75 39 37 90 72 93 55 72 31 42 30 71 87 61 4 12 12 81 23 61 56 98 71 32 30 33 96 63 92 16 8 78 47 91 47 54 49 3 81 82 41 5", "output": "47" }, { "input": "1\n2", "output": "1" }, { "input": "5\n1 1 3 2 2", "output": "3" } ]

1,647,051,152

2,147,483,647

PyPy 3-64

OK

TESTS

52

154

512,000

l=int(input()) x=input() x=x.split() for i in range(l): x[i]=int(x[i]) d=0 e=0 a=0 for i in range(l): a+=x[i] for i in range(l): if x[i]%2==0: d+=1 else: e+=1 if a%2==0: print(d) else: print(e)

Title: Cookies Time Limit: None seconds Memory Limit: None megabytes Problem Description: Olga came to visit the twins Anna and Maria and saw that they have many cookies. The cookies are distributed into bags. As there are many cookies, Olga decided that it's no big deal if she steals a bag. However, she doesn't want the sisters to quarrel because of nothing when they divide the cookies. That's why Olga wants to steal a bag with cookies so that the number of cookies in the remaining bags was even, that is, so that Anna and Maria could evenly divide it into two (even 0 remaining cookies will do, just as any other even number). How many ways there are to steal exactly one cookie bag so that the total number of cookies in the remaining bags was even? Input Specification: The first line contains the only integer *n* (1<=≤<=*n*<=≤<=100) — the number of cookie bags Anna and Maria have. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=100) — the number of cookies in the *i*-th bag. Output Specification: Print in the only line the only number — the sought number of ways. If there are no such ways print 0. Demo Input: ['1\n1\n', '10\n1 2 2 3 4 4 4 2 2 2\n', '11\n2 2 2 2 2 2 2 2 2 2 99\n'] Demo Output: ['1\n', '8\n', '1\n'] Note: In the first sample Olga should take the only bag so that the twins ended up with the even number of cookies. In the second sample Olga can take any of five bags with two cookies or any of three bags with four cookies — 5 + 3 = 8 ways in total. In the third sample, no matter which bag with two cookies Olga chooses, the twins are left with 2 * 9 + 99 = 117 cookies. Thus, Olga has only one option: to take the bag with 99 cookies.

```python l=int(input()) x=input() x=x.split() for i in range(l): x[i]=int(x[i]) d=0 e=0 a=0 for i in range(l): a+=x[i] for i in range(l): if x[i]%2==0: d+=1 else: e+=1 if a%2==0: print(d) else: print(e) ```

3

200

B

Drinks

PROGRAMMING

800

[ "implementation", "math" ]

null

Little Vasya loves orange juice very much. That's why any food and drink in his kitchen necessarily contains orange juice. There are *n* drinks in his fridge, the volume fraction of orange juice in the *i*-th drink equals *p**i* percent. One day Vasya decided to make himself an orange cocktail. He took equal proportions of each of the *n* drinks and mixed them. Then he wondered, how much orange juice the cocktail has. Find the volume fraction of orange juice in the final drink.

The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of orange-containing drinks in Vasya's fridge. The second line contains *n* integers *p**i* (0<=≤<=*p**i*<=≤<=100) — the volume fraction of orange juice in the *i*-th drink, in percent. The numbers are separated by a space.

Print the volume fraction in percent of orange juice in Vasya's cocktail. The answer will be considered correct if the absolute or relative error does not exceed 10<=<=-<=4.

[ "3\n50 50 100\n", "4\n0 25 50 75\n" ]

[ "66.666666666667\n", "37.500000000000\n" ]

Note to the first sample: let's assume that Vasya takes *x* milliliters of each drink from the fridge. Then the volume of pure juice in the cocktail will equal <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c1fac6e64d3a8ee6a5ac138cbe51e60039b22473.png" style="max-width: 100.0%;max-height: 100.0%;"/> milliliters. The total cocktail's volume equals 3·*x* milliliters, so the volume fraction of the juice in the cocktail equals <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/ceb0664e55a1f9f5fa1243ec74680a4665a4d58d.png" style="max-width: 100.0%;max-height: 100.0%;"/>, that is, 66.(6) percent.

500

[ { "input": "3\n50 50 100", "output": "66.666666666667" }, { "input": "4\n0 25 50 75", "output": "37.500000000000" }, { "input": "3\n0 1 8", "output": "3.000000000000" }, { "input": "5\n96 89 93 95 70", "output": "88.600000000000" }, { "input": "7\n62 41 78 4 38 39 75", "output": "48.142857142857" }, { "input": "13\n2 22 7 0 1 17 3 17 11 2 21 26 22", "output": "11.615384615385" }, { "input": "21\n5 4 11 7 0 5 45 21 0 14 51 6 0 16 10 19 8 9 7 12 18", "output": "12.761904761905" }, { "input": "26\n95 70 93 74 94 70 91 70 39 79 80 57 87 75 37 93 48 67 51 90 85 26 23 64 66 84", "output": "69.538461538462" }, { "input": "29\n84 99 72 96 83 92 95 98 97 93 76 84 99 93 81 76 93 99 99 100 95 100 96 95 97 100 71 98 94", "output": "91.551724137931" }, { "input": "33\n100 99 100 100 99 99 99 100 100 100 99 99 99 100 100 100 100 99 100 99 100 100 97 100 100 100 100 100 100 100 98 98 100", "output": "99.515151515152" }, { "input": "34\n14 9 10 5 4 26 18 23 0 1 0 20 18 15 2 2 3 5 14 1 9 4 2 15 7 1 7 19 10 0 0 11 0 2", "output": "8.147058823529" }, { "input": "38\n99 98 100 100 99 92 99 99 98 84 88 94 86 99 93 100 98 99 65 98 85 84 64 97 96 89 79 96 91 84 99 93 72 96 94 97 96 93", "output": "91.921052631579" }, { "input": "52\n100 94 99 98 99 99 99 95 97 97 98 100 100 98 97 100 98 90 100 99 97 94 90 98 100 100 90 99 100 95 98 95 94 85 97 94 96 94 99 99 99 98 100 100 94 99 99 100 98 87 100 100", "output": "97.019230769231" }, { "input": "58\n10 70 12 89 1 82 100 53 40 100 21 69 92 91 67 66 99 77 25 48 8 63 93 39 46 79 82 14 44 42 1 79 0 69 56 73 67 17 59 4 65 80 20 60 77 52 3 61 16 76 33 18 46 100 28 59 9 6", "output": "50.965517241379" }, { "input": "85\n7 8 1 16 0 15 1 7 0 11 15 6 2 12 2 8 9 8 2 0 3 7 15 7 1 8 5 7 2 26 0 3 11 1 8 10 31 0 7 6 1 8 1 0 9 14 4 8 7 16 9 1 0 16 10 9 6 1 1 4 2 7 4 5 4 1 20 6 16 16 1 1 10 17 8 12 14 19 3 8 1 7 10 23 10", "output": "7.505882352941" }, { "input": "74\n5 3 0 7 13 10 12 10 18 5 0 18 2 13 7 17 2 7 5 2 40 19 0 2 2 3 0 45 4 20 0 4 2 8 1 19 3 9 17 1 15 0 16 1 9 4 0 9 32 2 6 18 11 18 1 15 16 12 7 19 5 3 9 28 26 8 3 10 33 29 4 13 28 6", "output": "10.418918918919" }, { "input": "98\n42 9 21 11 9 11 22 12 52 20 10 6 56 9 26 27 1 29 29 14 38 17 41 21 7 45 15 5 29 4 51 20 6 8 34 17 13 53 30 45 0 10 16 41 4 5 6 4 14 2 31 6 0 11 13 3 3 43 13 36 51 0 7 16 28 23 8 36 30 22 8 54 21 45 39 4 50 15 1 30 17 8 18 10 2 20 16 50 6 68 15 6 38 7 28 8 29 41", "output": "20.928571428571" }, { "input": "99\n60 65 40 63 57 44 30 84 3 10 39 53 40 45 72 20 76 11 61 32 4 26 97 55 14 57 86 96 34 69 52 22 26 79 31 4 21 35 82 47 81 28 72 70 93 84 40 4 69 39 83 58 30 7 32 73 74 12 92 23 61 88 9 58 70 32 75 40 63 71 46 55 39 36 14 97 32 16 95 41 28 20 85 40 5 50 50 50 75 6 10 64 38 19 77 91 50 72 96", "output": "49.191919191919" }, { "input": "99\n100 88 40 30 81 80 91 98 69 73 88 96 79 58 14 100 87 84 52 91 83 88 72 83 99 35 54 80 46 79 52 72 85 32 99 39 79 79 45 83 88 50 75 75 50 59 65 75 97 63 92 58 89 46 93 80 89 33 69 86 99 99 66 85 72 74 79 98 85 95 46 63 77 97 49 81 89 39 70 76 68 91 90 56 31 93 51 87 73 95 74 69 87 95 57 68 49 95 92", "output": "73.484848484848" }, { "input": "100\n18 15 17 0 3 3 0 4 1 8 2 22 7 21 5 0 0 8 3 16 1 0 2 9 9 3 10 8 17 20 5 4 8 12 2 3 1 1 3 2 23 0 1 0 5 7 4 0 1 3 3 4 25 2 2 14 8 4 9 3 0 11 0 3 12 3 14 16 7 7 14 1 17 9 0 35 42 12 3 1 25 9 3 8 5 3 2 8 22 14 11 6 3 9 6 8 7 7 4 6", "output": "7.640000000000" }, { "input": "100\n88 77 65 87 100 63 91 96 92 89 77 95 76 80 84 83 100 71 85 98 26 54 74 78 69 59 96 86 88 91 95 26 52 88 64 70 84 81 76 84 94 82 100 66 97 98 43 94 59 94 100 80 98 73 69 83 94 70 74 79 91 31 62 88 69 55 62 97 40 64 62 83 87 85 50 90 69 72 67 49 100 51 69 96 81 90 83 91 86 34 79 69 100 66 97 98 47 97 74 100", "output": "77.660000000000" }, { "input": "100\n91 92 90 91 98 84 85 96 83 98 99 87 94 70 87 75 86 90 89 88 82 83 91 94 88 86 90 99 100 98 97 75 95 99 95 100 91 92 76 93 95 97 88 93 95 81 96 89 88 100 98 87 90 96 100 99 58 90 96 77 92 82 100 100 93 93 98 99 79 88 97 95 98 66 96 83 96 100 99 92 98 98 92 93 100 97 98 100 98 97 100 100 94 90 99 100 98 79 80 81", "output": "91.480000000000" }, { "input": "1\n0", "output": "0.000000000000" }, { "input": "1\n100", "output": "100.000000000000" }, { "input": "1\n78", "output": "78.000000000000" }, { "input": "2\n0 100", "output": "50.000000000000" }, { "input": "2\n100 100", "output": "100.000000000000" }, { "input": "5\n0 0 0 0 1", "output": "0.200000000000" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 99", "output": "99.990000000000" }, { "input": "100\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1", "output": "0.010000000000" }, { "input": "5\n100 100 100 100 100", "output": "100.000000000000" } ]

1,695,117,840

2,147,483,647

Python 3

OK

TESTS

31

92

409,600

from decimal import Decimal n = int(input()) total = 0 juice = map(int,input().split()) for i in juice : total = total + i output = Decimal(total / n) formatted_output = '{:.12f}'.format(output) print(formatted_output)

Title: Drinks Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Vasya loves orange juice very much. That's why any food and drink in his kitchen necessarily contains orange juice. There are *n* drinks in his fridge, the volume fraction of orange juice in the *i*-th drink equals *p**i* percent. One day Vasya decided to make himself an orange cocktail. He took equal proportions of each of the *n* drinks and mixed them. Then he wondered, how much orange juice the cocktail has. Find the volume fraction of orange juice in the final drink. Input Specification: The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of orange-containing drinks in Vasya's fridge. The second line contains *n* integers *p**i* (0<=≤<=*p**i*<=≤<=100) — the volume fraction of orange juice in the *i*-th drink, in percent. The numbers are separated by a space. Output Specification: Print the volume fraction in percent of orange juice in Vasya's cocktail. The answer will be considered correct if the absolute or relative error does not exceed 10<=<=-<=4. Demo Input: ['3\n50 50 100\n', '4\n0 25 50 75\n'] Demo Output: ['66.666666666667\n', '37.500000000000\n'] Note: Note to the first sample: let's assume that Vasya takes *x* milliliters of each drink from the fridge. Then the volume of pure juice in the cocktail will equal <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c1fac6e64d3a8ee6a5ac138cbe51e60039b22473.png" style="max-width: 100.0%;max-height: 100.0%;"/> milliliters. The total cocktail's volume equals 3·*x* milliliters, so the volume fraction of the juice in the cocktail equals <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/ceb0664e55a1f9f5fa1243ec74680a4665a4d58d.png" style="max-width: 100.0%;max-height: 100.0%;"/>, that is, 66.(6) percent.

```python from decimal import Decimal n = int(input()) total = 0 juice = map(int,input().split()) for i in juice : total = total + i output = Decimal(total / n) formatted_output = '{:.12f}'.format(output) print(formatted_output) ```

3

518

A

Vitaly and Strings

PROGRAMMING

1,600

[ "constructive algorithms", "strings" ]

null

Vitaly is a diligent student who never missed a lesson in his five years of studying in the university. He always does his homework on time and passes his exams in time. During the last lesson the teacher has provided two strings *s* and *t* to Vitaly. The strings have the same length, they consist of lowercase English letters, string *s* is lexicographically smaller than string *t*. Vitaly wondered if there is such string that is lexicographically larger than string *s* and at the same is lexicographically smaller than string *t*. This string should also consist of lowercase English letters and have the length equal to the lengths of strings *s* and *t*. Let's help Vitaly solve this easy problem!

The first line contains string *s* (1<=≤<=|*s*|<=≤<=100), consisting of lowercase English letters. Here, |*s*| denotes the length of the string. The second line contains string *t* (|*t*|<==<=|*s*|), consisting of lowercase English letters. It is guaranteed that the lengths of strings *s* and *t* are the same and string *s* is lexicographically less than string *t*.

If the string that meets the given requirements doesn't exist, print a single string "No such string" (without the quotes). If such string exists, print it. If there are multiple valid strings, you may print any of them.

[ "a\nc\n", "aaa\nzzz\n", "abcdefg\nabcdefh\n" ]

[ "b\n", "kkk\n", "No such string\n" ]

String *s* = *s*1*s*2... *s**n* is said to be lexicographically smaller than *t* = *t*1*t*2... *t**n*, if there exists such *i*, that *s*1 = *t*1, *s*2 = *t*2, ... *s**i* - 1 = *t**i* - 1, *s**i* < *t**i*.

500

[ { "input": "a\nc", "output": "b" }, { "input": "aaa\nzzz", "output": "kkk" }, { "input": "abcdefg\nabcdefh", "output": "No such string" }, { "input": "abcdefg\nabcfefg", "output": "abcdefh" }, { "input": "frt\nfru", "output": "No such string" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab" }, { "input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzx\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzy" }, { "input": "q\nz", "output": "r" }, { "input": "pnzcl\npnzdf", "output": "pnzcm" }, { "input": "vklldrxnfgyorgfpfezvhbouyzzzzz\nvklldrxnfgyorgfpfezvhbouzaaadv", "output": "vklldrxnfgyorgfpfezvhbouzaaaaa" }, { "input": "pkjlxzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\npkjlyaaaaaaaaaaaaaaaaaaaaaaaaaaaahr", "output": "pkjlyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "exoudpymnspkocwszzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\nexoudpymnspkocwtaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabml", "output": "exoudpymnspkocwtaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "anarzvsklmwvovozwnmhklkpcseeogdgauoppmzrukynbjjoxytuvsiecuzfquxnowewebhtuoxepocyeamqfrblpwqiokbcubil\nanarzvsklmwvovozwnmhklkpcseeogdgauoppmzrukynbjjoxytuvsiecuzfquxnowewebhtuoxepocyeamqfrblpwqiokbcubim", "output": "No such string" }, { "input": "uqyugulumzwlxsjnxxkutzqayskrbjoaaekbhckjryhjjllzzz\nuqyugulumzwlxsjnxxkutzqayskrbjoaaekbhckjryhjjlmaaa", "output": "No such string" }, { "input": "esfaeyxpblcrriizhnhfrxnbopqvhwtetgjqavlqdlxexaifgvkqfwzneibhxxdacbzzzzzzzzzzzzzz\nesfaeyxpblcrriizhnhfrxnbopqvhwtetgjqavlqdlxexaifgvkqfwzneibhxxdaccaaaaaaaaaaaatf", "output": "esfaeyxpblcrriizhnhfrxnbopqvhwtetgjqavlqdlxexaifgvkqfwzneibhxxdaccaaaaaaaaaaaaaa" }, { "input": "oisjtilteipnzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\noisjtilteipoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaao", "output": "oisjtilteipoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "svpoxbsudndfnnpugbouawegyxgtmvqzbewxpcwhopdbwscimgzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\nsvpoxbsudndfnnpugbouawegyxgtmvqzbewxpcwhopdbwscimhaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "No such string" }, { "input": "ddzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\ndeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaao", "output": "deaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "xqzbhslocdbifnyzyjenlpctocieaccsycmwlcebkqqkeibatfvylbqlutvjijgjhdetqsjqnoipqbmjhhzxggdobyvpczdavdzz\nxqzbhslocdbifnyzyjenlpctocieaccsycmwlcebkqqkeibatfvylbqlutvjijgjhdetqsjqnoipqbmjhhzxggdobyvpczdavilj", "output": "xqzbhslocdbifnyzyjenlpctocieaccsycmwlcebkqqkeibatfvylbqlutvjijgjhdetqsjqnoipqbmjhhzxggdobyvpczdaveaa" }, { "input": "poflpxucohdobeisxfsnkbdzwizjjhgngufssqhmfgmydmmrnuminrvxxamoebhczlwsfefdtnchaisfxkfcovxmvppxnrfawfoq\npoflpxucohdobeisxfsnkbdzwizjjhgngufssqhmfgmydmmrnuminrvxxamoebhczlwsfefdtnchaisfxkfcovxmvppxnrfawujg", "output": "poflpxucohdobeisxfsnkbdzwizjjhgngufssqhmfgmydmmrnuminrvxxamoebhczlwsfefdtnchaisfxkfcovxmvppxnrfawfor" }, { "input": "vonggnmokmvmguwtobkxoqgxkuxtyjmxrygyliohlhwxuxjmlkqcfuxboxjnzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\nvonggnmokmvmguwtobkxoqgxkuxtyjmxrygyliohlhwxuxjmlkqcfuxboxjoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac", "output": "vonggnmokmvmguwtobkxoqgxkuxtyjmxrygyliohlhwxuxjmlkqcfuxboxjoaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "bqycw\nquhod", "output": "bqycx" }, { "input": "hceslswecf\nnmxshuymaa", "output": "hceslswecg" }, { "input": "awqtzslxowuaefe\nvujscakjpvxviki", "output": "awqtzslxowuaeff" }, { "input": "lerlcnaogdravnogfogcyoxgi\nojrbithvjdqtempegvqxmgmmw", "output": "lerlcnaogdravnogfogcyoxgj" }, { "input": "jbrhvicytqaivheqeourrlosvnsujsxdinryyawgalidsaufxv\noevvkhujmhagaholrmsatdjjyfmyblvgetpnxgjcilugjsncjs", "output": "jbrhvicytqaivheqeourrlosvnsujsxdinryyawgalidsaufxw" }, { "input": "jrpogrcuhqdpmyzpuabuhaptlxaeiqjxhqkmuzsjbhqxvdtoocrkusaeasqdwlunomwzww\nspvgaswympzlscnumemgiznngnxqgccbubmxgqmaakbnyngkxlxjjsafricchhpecdjgxw", "output": "jrpogrcuhqdpmyzpuabuhaptlxaeiqjxhqkmuzsjbhqxvdtoocrkusaeasqdwlunomwzwx" }, { "input": "mzmhjmfxaxaplzjmjkbyadeweltagyyuzpvrmnyvirjpdmebxyzjvdoezhnayfrvtnccryhkvhcvakcf\nohhhhkujfpjbgouebtmmbzizuhuumvrsqfniwpmxdtzhyiaivdyxhywnqzagicydixjtvbqbevhbqttu", "output": "mzmhjmfxaxaplzjmjkbyadeweltagyyuzpvrmnyvirjpdmebxyzjvdoezhnayfrvtnccryhkvhcvakcg" }, { "input": "cdmwmzutsicpzhcokbbhwktqbomozxvvjlhwdgtiledgurxsfreisgczdwgupzxmjnfyjxcpdwzkggludkcmgppndl\nuvuqvyrnhtyubpevizhjxdvmpueittksrnosmfuuzbimnqussasdjufrthrgjbyzomauaxbvwferfvtmydmwmjaoxg", "output": "cdmwmzutsicpzhcokbbhwktqbomozxvvjlhwdgtiledgurxsfreisgczdwgupzxmjnfyjxcpdwzkggludkcmgppndm" }, { "input": "dpnmrwpbgzvcmrcodwgvvfwpyagdwlngmhrazyvalszhruprxzmwltftxmujfyrrnwzvphgqlcphreumqkytswxziugburwrlyay\nqibcfxdfovoejutaeetbbwrgexdrvqywwmhipxgfrvhzovxkfawpfnpjvlhkyahessodqcclangxefcaixysqijnitevwmpalkzd", "output": "dpnmrwpbgzvcmrcodwgvvfwpyagdwlngmhrazyvalszhruprxzmwltftxmujfyrrnwzvphgqlcphreumqkytswxziugburwrlyaz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", "output": "No such string" }, { "input": "phdvmuwqmvzyurtnshitcypuzbhpceovkibzbhhjwxkdtvqmbpoumeoiztxtvkvsjrlnhowsdmgftuiulzebdigmun\nphdvmuwqmvzyurtnshitcypuzbhpceovkibzbhhjwxkdtvqmbpoumeoiztxtvkvsjrlnhowsdmgftuiulzebdigmuo", "output": "No such string" }, { "input": "hrsantdquixzjyjtqytcmnflnyehzbibkbgkqffgqpkgeuqmbmxzhbjwsnfkizvbcyoghyvnxxjavoahlqjxomtsouzoog\nhrsantdquixzjyjtqytcmnflnyehzbibkbgkqffgqpkgeuqmbmxzhbjwsnfkizvbcyoghyvnxxjavoahlqjxomtsouzooh", "output": "No such string" }, { "input": "kexdbtpkjbwwyibjndbtmwqzolopqitgkomqggojevoankiepxirrcidxldlzsppehmoazdywltmjbxgsxgihwnwpmczjrcwpywl\nkexdbtpkjbwwyibjndbtmwqzolopqitgkomqggojevoankiepxirrcidxldlzsppehmoazdywltmjbxgsxgihwnwpmczjrcwpywm", "output": "No such string" }, { "input": "yijdysvzfcnaedvnecswgoylhzgguxecmucepgstjbdkbjyfdlxxxejkrrxfiuwjpdmdhhqhlqeqzjwudtdryrfkpwfxdjlkowmk\nyijdysvzfcnaedvnecswgoylhzgguxecmucepgstjbdkbjyfdlxxxejkrrxfiuwjpdmdhhqhlqeqzjwudtdryrfkpwfxdjlkowml", "output": "No such string" }, { "input": "a\nb", "output": "No such string" }, { "input": "x\nz", "output": "y" }, { "input": "a\nz", "output": "b" }, { "input": "y\nz", "output": "No such string" }, { "input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzy\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "No such string" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab" }, { "input": "yzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "zaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyz" }, { "input": "aaa\naac", "output": "aab" }, { "input": "aaa\naab", "output": "No such string" }, { "input": "zzx\nzzz", "output": "zzy" }, { "input": "zzy\nzzz", "output": "No such string" }, { "input": "aba\naca", "output": "abb" }, { "input": "aaa\nbbb", "output": "aab" }, { "input": "azzz\ncaaa", "output": "baaa" } ]

1,621,941,088

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

9

46

0

s,t=list(input()),input() i=len(s)-1 while s[i]=='z': print(s[i]) s[i]='a' i-=1 s[i]=chr(ord(s[i])+1) s=''.join(s) if s>=t: print('No such string') else: print(s)

Title: Vitaly and Strings Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vitaly is a diligent student who never missed a lesson in his five years of studying in the university. He always does his homework on time and passes his exams in time. During the last lesson the teacher has provided two strings *s* and *t* to Vitaly. The strings have the same length, they consist of lowercase English letters, string *s* is lexicographically smaller than string *t*. Vitaly wondered if there is such string that is lexicographically larger than string *s* and at the same is lexicographically smaller than string *t*. This string should also consist of lowercase English letters and have the length equal to the lengths of strings *s* and *t*. Let's help Vitaly solve this easy problem! Input Specification: The first line contains string *s* (1<=≤<=|*s*|<=≤<=100), consisting of lowercase English letters. Here, |*s*| denotes the length of the string. The second line contains string *t* (|*t*|<==<=|*s*|), consisting of lowercase English letters. It is guaranteed that the lengths of strings *s* and *t* are the same and string *s* is lexicographically less than string *t*. Output Specification: If the string that meets the given requirements doesn't exist, print a single string "No such string" (without the quotes). If such string exists, print it. If there are multiple valid strings, you may print any of them. Demo Input: ['a\nc\n', 'aaa\nzzz\n', 'abcdefg\nabcdefh\n'] Demo Output: ['b\n', 'kkk\n', 'No such string\n'] Note: String *s* = *s*1*s*2... *s**n* is said to be lexicographically smaller than *t* = *t*1*t*2... *t**n*, if there exists such *i*, that *s*1 = *t*1, *s*2 = *t*2, ... *s**i* - 1 = *t**i* - 1, *s**i* < *t**i*.

```python s,t=list(input()),input() i=len(s)-1 while s[i]=='z': print(s[i]) s[i]='a' i-=1 s[i]=chr(ord(s[i])+1) s=''.join(s) if s>=t: print('No such string') else: print(s) ```

0

1,003

A

Polycarp's Pockets

PROGRAMMING

800

[ "implementation" ]

null

Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket. For example, if Polycarp has got six coins represented as an array $a = [1, 2, 4, 3, 3, 2]$, he can distribute the coins into two pockets as follows: $[1, 2, 3], [2, 3, 4]$. Polycarp wants to distribute all the coins with the minimum number of used pockets. Help him to do that.

The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the number of coins. The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$) — values of coins.

Print only one integer — the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket.

[ "6\n1 2 4 3 3 2\n", "1\n100\n" ]

[ "2\n", "1\n" ]

none

0

[ { "input": "6\n1 2 4 3 3 2", "output": "2" }, { "input": "1\n100", "output": "1" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "100" }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "100" }, { "input": "100\n59 47 39 47 47 71 47 28 58 47 35 79 58 47 38 47 47 47 47 27 47 43 29 95 47 49 46 71 47 74 79 47 47 32 45 67 47 47 30 37 47 47 16 67 22 76 47 86 84 10 5 47 47 47 47 47 1 51 47 54 47 8 47 47 9 47 47 47 47 28 47 47 26 47 47 47 47 47 47 92 47 47 77 47 47 24 45 47 10 47 47 89 47 27 47 89 47 67 24 71", "output": "51" }, { "input": "100\n45 99 10 27 16 85 39 38 17 32 15 23 67 48 50 97 42 70 62 30 44 81 64 73 34 22 46 5 83 52 58 60 33 74 47 88 18 61 78 53 25 95 94 31 3 75 1 57 20 54 59 9 68 7 77 43 21 87 86 24 4 80 11 49 2 72 36 84 71 8 65 55 79 100 41 14 35 89 66 69 93 37 56 82 90 91 51 19 26 92 6 96 13 98 12 28 76 40 63 29", "output": "1" }, { "input": "100\n45 29 5 2 6 50 22 36 14 15 9 48 46 20 8 37 7 47 12 50 21 38 18 27 33 19 40 10 5 49 38 42 34 37 27 30 35 24 10 3 40 49 41 3 4 44 13 25 28 31 46 36 23 1 1 23 7 22 35 26 21 16 48 42 32 8 11 16 34 11 39 32 47 28 43 41 39 4 14 19 26 45 13 18 15 25 2 44 17 29 17 33 43 6 12 30 9 20 31 24", "output": "2" }, { "input": "50\n7 7 3 3 7 4 5 6 4 3 7 5 6 4 5 4 4 5 6 7 7 7 4 5 5 5 3 7 6 3 4 6 3 6 4 4 5 4 6 6 3 5 6 3 5 3 3 7 7 6", "output": "10" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 99 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "99" }, { "input": "7\n1 2 3 3 3 1 2", "output": "3" }, { "input": "5\n1 2 3 4 5", "output": "1" }, { "input": "7\n1 2 3 4 5 6 7", "output": "1" }, { "input": "8\n1 2 3 4 5 6 7 8", "output": "1" }, { "input": "9\n1 2 3 4 5 6 7 8 9", "output": "1" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "1" }, { "input": "3\n2 1 1", "output": "2" }, { "input": "11\n1 2 3 4 5 6 7 8 9 1 1", "output": "3" }, { "input": "12\n1 2 1 1 1 1 1 1 1 1 1 1", "output": "11" }, { "input": "13\n1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "13" }, { "input": "14\n1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "14" }, { "input": "15\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "15" }, { "input": "16\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "16" }, { "input": "3\n1 1 1", "output": "3" }, { "input": "3\n1 2 3", "output": "1" }, { "input": "10\n1 1 1 1 2 2 1 1 9 10", "output": "6" }, { "input": "2\n1 1", "output": "2" }, { "input": "56\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "56" }, { "input": "99\n35 96 73 72 70 83 22 93 98 75 45 32 81 82 45 54 25 7 53 72 29 2 94 19 21 98 34 28 39 99 55 85 44 23 6 47 98 2 33 34 19 57 49 35 67 4 60 4 4 23 55 6 57 66 16 68 34 45 84 79 48 63 4 9 46 88 98 13 19 27 83 12 4 63 57 22 44 77 44 62 28 52 44 64 9 24 55 22 48 4 2 9 80 76 45 1 56 22 92", "output": "6" }, { "input": "10\n1 2 2 3 3 3 4 4 4 4", "output": "4" }, { "input": "99\n97 44 33 56 42 10 61 85 64 26 40 39 82 34 75 9 51 51 39 73 58 38 74 31 13 99 58 1 28 89 76 19 52 7 40 56 12 27 72 72 67 75 62 46 22 55 35 16 18 39 60 63 92 42 85 69 34 61 73 50 57 95 30 4 45 63 76 58 32 35 48 81 10 78 95 79 55 97 21 21 22 94 30 17 78 57 89 93 100 44 16 89 68 55 19 46 42 73 21", "output": "3" }, { "input": "5\n5 5 5 5 1", "output": "4" }, { "input": "6\n2 3 2 5 2 6", "output": "3" }, { "input": "3\n58 59 58", "output": "2" }, { "input": "9\n1 2 3 4 5 6 7 8 8", "output": "2" }, { "input": "97\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "97" }, { "input": "3\n95 95 4", "output": "2" }, { "input": "3\n2 2 5", "output": "2" } ]

1,667,394,038

2,147,483,647

Python 3

OK

TESTS

37

46

0

n = int(input()) lists = list(map(int, input().split())) sets= set(lists) maks=0 for i in range (n): sk = lists.count(lists[i]) if sk > maks: maks=sk print(maks)

Title: Polycarp's Pockets Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket. For example, if Polycarp has got six coins represented as an array $a = [1, 2, 4, 3, 3, 2]$, he can distribute the coins into two pockets as follows: $[1, 2, 3], [2, 3, 4]$. Polycarp wants to distribute all the coins with the minimum number of used pockets. Help him to do that. Input Specification: The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the number of coins. The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$) — values of coins. Output Specification: Print only one integer — the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket. Demo Input: ['6\n1 2 4 3 3 2\n', '1\n100\n'] Demo Output: ['2\n', '1\n'] Note: none

```python n = int(input()) lists = list(map(int, input().split())) sets= set(lists) maks=0 for i in range (n): sk = lists.count(lists[i]) if sk > maks: maks=sk print(maks) ```

3

339

A

Helpful Maths

PROGRAMMING

800

[ "greedy", "implementation", "sortings", "strings" ]

null

Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation. The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3. You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.

The first line contains a non-empty string *s* — the sum Xenia needs to count. String *s* contains no spaces. It only contains digits and characters "+". Besides, string *s* is a correct sum of numbers 1, 2 and 3. String *s* is at most 100 characters long.

Print the new sum that Xenia can count.

[ "3+2+1\n", "1+1+3+1+3\n", "2\n" ]

[ "1+2+3\n", "1+1+1+3+3\n", "2\n" ]

none

500

[ { "input": "3+2+1", "output": "1+2+3" }, { "input": "1+1+3+1+3", "output": "1+1+1+3+3" }, { "input": "2", "output": "2" }, { "input": "2+2+1+1+3", "output": "1+1+2+2+3" }, { "input": "2+1+2+2+2+3+1+3+1+2", "output": "1+1+1+2+2+2+2+2+3+3" }, { "input": "1+2+1+2+2+2+2+1+3+3", "output": "1+1+1+2+2+2+2+2+3+3" }, { "input": "2+3+3+1+2+2+2+1+1+2+1+3+2+2+3+3+2+2+3+3+3+1+1+1+3+3+3+2+1+3+2+3+2+1+1+3+3+3+1+2+2+1+2+2+1+2+1+3+1+1", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "1", "output": "1" }, { "input": "2+1+2+2+1+3+2+3+1+1+2+1+2+2+3+1+1+3+3+3+2+2+3+2+2+2+1+2+1+2+3+2+2+2+1+3+1+3+3+3+1+2+1+2+2+2+2+3+1+1", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "2+2+1+1+1+3+1+1+3+3+2+3+1+3+1+1+3+1+1+2+2+2+2+1+2+1+2+1+1+1+3+1+3+2+3+2+3+3+1+1+1+2+3+2+1+3+1+3+2+2", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "3+2+3+3+2+2+1+2+1+2+3+1+2+3+2+3+2+1+2+2+1+1+2+2+3+2+1+3+1+1+3+2+2+2+2+3+3+2+2+3+3+1+1+2+3+3+2+3+3+3", "output": "1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "3", "output": "3" }, { "input": "1+1", "output": "1+1" }, { "input": "1+2", "output": "1+2" }, { "input": "1+3", "output": "1+3" }, { "input": "2+1", "output": "1+2" }, { "input": "2+2", "output": "2+2" }, { "input": "2+3", "output": "2+3" }, { "input": "3+1", "output": "1+3" }, { "input": "3+2", "output": "2+3" }, { "input": "3+3", "output": "3+3" } ]

1,698,174,445

2,147,483,647

Python 3

OK

TESTS

21

92

0

s= input() numbers= s.split('+') num_l= [int(num) for num in numbers] num_l.sort() num_s=[str(num) for num in num_l] output= '+'.join(num_s) print(output)

Title: Helpful Maths Time Limit: None seconds Memory Limit: None megabytes Problem Description: Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation. The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3. You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum. Input Specification: The first line contains a non-empty string *s* — the sum Xenia needs to count. String *s* contains no spaces. It only contains digits and characters "+". Besides, string *s* is a correct sum of numbers 1, 2 and 3. String *s* is at most 100 characters long. Output Specification: Print the new sum that Xenia can count. Demo Input: ['3+2+1\n', '1+1+3+1+3\n', '2\n'] Demo Output: ['1+2+3\n', '1+1+1+3+3\n', '2\n'] Note: none

```python s= input() numbers= s.split('+') num_l= [int(num) for num in numbers] num_l.sort() num_s=[str(num) for num in num_l] output= '+'.join(num_s) print(output) ```

3

721

B

Passwords

PROGRAMMING

1,100

[ "implementation", "math", "sortings", "strings" ]

null

Vanya is managed to enter his favourite site Codehorses. Vanya uses *n* distinct passwords for sites at all, however he can't remember which one exactly he specified during Codehorses registration. Vanya will enter passwords in order of non-decreasing their lengths, and he will enter passwords of same length in arbitrary order. Just when Vanya will have entered the correct password, he is immediately authorized on the site. Vanya will not enter any password twice. Entering any passwords takes one second for Vanya. But if Vanya will enter wrong password *k* times, then he is able to make the next try only 5 seconds after that. Vanya makes each try immediately, that is, at each moment when Vanya is able to enter password, he is doing that. Determine how many seconds will Vanya need to enter Codehorses in the best case for him (if he spends minimum possible number of second) and in the worst case (if he spends maximum possible amount of seconds).

The first line of the input contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=100) — the number of Vanya's passwords and the number of failed tries, after which the access to the site is blocked for 5 seconds. The next *n* lines contains passwords, one per line — pairwise distinct non-empty strings consisting of latin letters and digits. Each password length does not exceed 100 characters. The last line of the input contains the Vanya's Codehorses password. It is guaranteed that the Vanya's Codehorses password is equal to some of his *n* passwords.

Print two integers — time (in seconds), Vanya needs to be authorized to Codehorses in the best case for him and in the worst case respectively.

[ "5 2\ncba\nabc\nbb1\nabC\nABC\nabc\n", "4 100\n11\n22\n1\n2\n22\n" ]

[ "1 15\n", "3 4\n" ]

Consider the first sample case. As soon as all passwords have the same length, Vanya can enter the right password at the first try as well as at the last try. If he enters it at the first try, he spends exactly 1 second. Thus in the best case the answer is 1. If, at the other hand, he enters it at the last try, he enters another 4 passwords before. He spends 2 seconds to enter first 2 passwords, then he waits 5 seconds as soon as he made 2 wrong tries. Then he spends 2 more seconds to enter 2 wrong passwords, again waits 5 seconds and, finally, enters the correct password spending 1 more second. In summary in the worst case he is able to be authorized in 15 seconds. Consider the second sample case. There is no way of entering passwords and get the access to the site blocked. As soon as the required password has length of 2, Vanya enters all passwords of length 1 anyway, spending 2 seconds for that. Then, in the best case, he immediately enters the correct password and the answer for the best case is 3, but in the worst case he enters wrong password of length 2 and only then the right one, spending 4 seconds at all.

1,000

[ { "input": "5 2\ncba\nabc\nbb1\nabC\nABC\nabc", "output": "1 15" }, { "input": "4 100\n11\n22\n1\n2\n22", "output": "3 4" }, { "input": "1 1\na1\na1", "output": "1 1" }, { "input": "1 100\na1\na1", "output": "1 1" }, { "input": "2 1\nabc\nAbc\nAbc", "output": "1 7" }, { "input": "2 2\nabc\nAbc\nabc", "output": "1 2" }, { "input": "2 1\nab\nabc\nab", "output": "1 1" }, { "input": "2 2\nab\nabc\nab", "output": "1 1" }, { "input": "2 1\nab\nabc\nabc", "output": "7 7" }, { "input": "2 2\nab\nabc\nabc", "output": "2 2" }, { "input": "10 3\nOIbV1igi\no\nZS\nQM\n9woLzI\nWreboD\nQ7yl\nA5Rb\nS9Lno72TkP\nfT97o\no", "output": "1 1" }, { "input": "10 3\nHJZNMsT\nLaPcH2C\nlrhqIO\n9cxw\noTC1XwjW\nGHL9Ul6\nUyIs\nPuzwgR4ZKa\nyIByoKR5\nd3QA\nPuzwgR4ZKa", "output": "25 25" }, { "input": "20 5\nvSyC787KlIL8kZ2Uv5sw\nWKWOP\n7i8J3E8EByIq\nNW2VyGweL\nmyR2sRNu\nmXusPP0\nf4jgGxra\n4wHRzRhOCpEt\npPz9kybGb\nOtSpePCRoG5nkjZ2VxRy\nwHYsSttWbJkg\nKBOP9\nQfiOiFyHPPsw3GHo8J8\nxB8\nqCpehZEeEhdq\niOLjICK6\nQ91\nHmCsfMGTFKoFFnv238c\nJKjhg\ngkEUh\nKBOP9", "output": "3 11" }, { "input": "15 2\nw6S9WyU\nMVh\nkgUhQHW\nhGQNOF\nUuym\n7rGQA\nBM8vLPRB\n9E\nDs32U\no\nz1aV2C5T\n8\nzSXjrqQ\n1FO\n3kIt\nBM8vLPRB", "output": "44 50" }, { "input": "20 2\ni\n5Rp6\nE4vsr\nSY\nORXx\nh13C\nk6tzC\ne\nN\nKQf4C\nWZcdL\ndiA3v\n0InQT\nuJkAr\nGCamp\nBuIRd\nY\nM\nxZYx7\n0a5A\nWZcdL", "output": "36 65" }, { "input": "20 2\naWLQ6\nSgQ9r\nHcPdj\n2BNaO\n3TjNb\nnvwFM\nqsKt7\nFnb6N\nLoc0p\njxuLq\nBKAjf\nEKgZB\nBfOSa\nsMIvr\nuIWcR\nIura3\nLAqSf\ntXq3G\n8rQ8I\n8otAO\nsMIvr", "output": "1 65" }, { "input": "20 15\n0ZpQugVlN7\nm0SlKGnohN\nRFXTqhNGcn\n1qm2ZbB\nQXtJWdf78P\nbc2vH\nP21dty2Z1P\nm2c71LFhCk\n23EuP1Dvh3\nanwri5RhQN\n55v6HYv288\n1u5uKOjM5r\n6vg0GC1\nDAPYiA3ns1\nUZaaJ3Gmnk\nwB44x7V4Zi\n4hgB2oyU8P\npYFQpy8gGK\ndbz\nBv\n55v6HYv288", "output": "6 25" }, { "input": "3 1\na\nb\naa\naa", "output": "13 13" }, { "input": "6 3\nab\nac\nad\nabc\nabd\nabe\nabc", "output": "9 11" }, { "input": "4 2\n1\n2\n11\n22\n22", "output": "8 9" }, { "input": "2 1\n1\n12\n12", "output": "7 7" }, { "input": "3 1\nab\nabc\nabd\nabc", "output": "7 13" }, { "input": "2 1\na\nab\nab", "output": "7 7" }, { "input": "5 2\na\nb\nc\nab\naa\naa", "output": "9 15" }, { "input": "6 1\n1\n2\n11\n22\n111\n2222\n22", "output": "13 19" }, { "input": "3 1\n1\n2\n11\n11", "output": "13 13" }, { "input": "10 4\na\nb\nc\nd\ne\nf\nab\ncd\nac\nad\nac", "output": "12 20" }, { "input": "4 2\na\nb\nc\nd\na", "output": "1 9" }, { "input": "4 1\n1\n2\n3\n4\n4", "output": "1 19" }, { "input": "5 1\na\nb\nc\nd\nef\nef", "output": "25 25" }, { "input": "6 4\n1\n2\n22\n33\n44\n555\n555", "output": "11 11" }, { "input": "5 2\na\nb\nc\nd\nab\nab", "output": "15 15" }, { "input": "6 2\n1\n2\n3\n4\n5\n23\n23", "output": "16 16" }, { "input": "4 2\na\nb\naa\nbb\naa", "output": "8 9" }, { "input": "5 4\na\nbb\ncc\ndd\nee\nbb", "output": "2 10" }, { "input": "4 1\na\nb\nc\nab\nab", "output": "19 19" }, { "input": "7 100\na\nb\nc\nd\ne\ng\nab\nab", "output": "7 7" }, { "input": "6 1\na\nb\nc\nd\ne\naa\naa", "output": "31 31" }, { "input": "4 1\na\nas\nasd\nasde\nasde", "output": "19 19" }, { "input": "5 2\n1\n2\n3\n11\n22\n22", "output": "9 15" }, { "input": "10 2\na\nb\nc\nd\nee\nff\ngg\nhh\nii\njj\nii", "output": "15 30" }, { "input": "3 1\na\nab\nbc\nab", "output": "7 13" }, { "input": "6 4\na\nb\nc\nbb\nbc\ncc\ncc", "output": "4 11" } ]

1,570,517,977

2,147,483,647

Python 3

OK

TESTS

66

109

0

def solution(passwords, correct_pass, k) -> None: # Init n = len(correct_pass) n1 = n2 = 0 for x in passwords: l = len(x) if l < n: n1 += 1 elif l == n: n2 += 1 # Work res = (n1 // k) * (k + 5) extra = (n1 % k) # Best case best = res + extra + 1 other = extra + n2 - 1 # Worst case worst = (other // k) * (k + 5) worst += res + (other % k) + 1 print("{} {}".format(best, worst)) def main(): p, q = map(int, input().split()) passwords = [] for i in range(p): passwords.append(input()) correct_pass = input() solution(passwords, correct_pass, q) if __name__ == "__main__": main()

Title: Passwords Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vanya is managed to enter his favourite site Codehorses. Vanya uses *n* distinct passwords for sites at all, however he can't remember which one exactly he specified during Codehorses registration. Vanya will enter passwords in order of non-decreasing their lengths, and he will enter passwords of same length in arbitrary order. Just when Vanya will have entered the correct password, he is immediately authorized on the site. Vanya will not enter any password twice. Entering any passwords takes one second for Vanya. But if Vanya will enter wrong password *k* times, then he is able to make the next try only 5 seconds after that. Vanya makes each try immediately, that is, at each moment when Vanya is able to enter password, he is doing that. Determine how many seconds will Vanya need to enter Codehorses in the best case for him (if he spends minimum possible number of second) and in the worst case (if he spends maximum possible amount of seconds). Input Specification: The first line of the input contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=100) — the number of Vanya's passwords and the number of failed tries, after which the access to the site is blocked for 5 seconds. The next *n* lines contains passwords, one per line — pairwise distinct non-empty strings consisting of latin letters and digits. Each password length does not exceed 100 characters. The last line of the input contains the Vanya's Codehorses password. It is guaranteed that the Vanya's Codehorses password is equal to some of his *n* passwords. Output Specification: Print two integers — time (in seconds), Vanya needs to be authorized to Codehorses in the best case for him and in the worst case respectively. Demo Input: ['5 2\ncba\nabc\nbb1\nabC\nABC\nabc\n', '4 100\n11\n22\n1\n2\n22\n'] Demo Output: ['1 15\n', '3 4\n'] Note: Consider the first sample case. As soon as all passwords have the same length, Vanya can enter the right password at the first try as well as at the last try. If he enters it at the first try, he spends exactly 1 second. Thus in the best case the answer is 1. If, at the other hand, he enters it at the last try, he enters another 4 passwords before. He spends 2 seconds to enter first 2 passwords, then he waits 5 seconds as soon as he made 2 wrong tries. Then he spends 2 more seconds to enter 2 wrong passwords, again waits 5 seconds and, finally, enters the correct password spending 1 more second. In summary in the worst case he is able to be authorized in 15 seconds. Consider the second sample case. There is no way of entering passwords and get the access to the site blocked. As soon as the required password has length of 2, Vanya enters all passwords of length 1 anyway, spending 2 seconds for that. Then, in the best case, he immediately enters the correct password and the answer for the best case is 3, but in the worst case he enters wrong password of length 2 and only then the right one, spending 4 seconds at all.

```python def solution(passwords, correct_pass, k) -> None: # Init n = len(correct_pass) n1 = n2 = 0 for x in passwords: l = len(x) if l < n: n1 += 1 elif l == n: n2 += 1 # Work res = (n1 // k) * (k + 5) extra = (n1 % k) # Best case best = res + extra + 1 other = extra + n2 - 1 # Worst case worst = (other // k) * (k + 5) worst += res + (other % k) + 1 print("{} {}".format(best, worst)) def main(): p, q = map(int, input().split()) passwords = [] for i in range(p): passwords.append(input()) correct_pass = input() solution(passwords, correct_pass, q) if __name__ == "__main__": main() ```

3

937

A

Olympiad

PROGRAMMING

800

[ "implementation", "sortings" ]

null

The recent All-Berland Olympiad in Informatics featured *n* participants with each scoring a certain amount of points. As the head of the programming committee, you are to determine the set of participants to be awarded with diplomas with respect to the following criteria: - At least one participant should get a diploma. - None of those with score equal to zero should get awarded. - When someone is awarded, all participants with score not less than his score should also be awarded. Determine the number of ways to choose a subset of participants that will receive the diplomas.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of participants. The next line contains a sequence of *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=600) — participants' scores. It's guaranteed that at least one participant has non-zero score.

Print a single integer — the desired number of ways.

[ "4\n1 3 3 2\n", "3\n1 1 1\n", "4\n42 0 0 42\n" ]

[ "3\n", "1\n", "1\n" ]

There are three ways to choose a subset in sample case one. 1. Only participants with 3 points will get diplomas. 1. Participants with 2 or 3 points will get diplomas. 1. Everyone will get a diploma! The only option in sample case two is to award everyone. Note that in sample case three participants with zero scores cannot get anything.

500

[ { "input": "4\n1 3 3 2", "output": "3" }, { "input": "3\n1 1 1", "output": "1" }, { "input": "4\n42 0 0 42", "output": "1" }, { "input": "10\n1 0 1 0 1 0 0 0 0 1", "output": "1" }, { "input": "10\n572 471 540 163 50 30 561 510 43 200", "output": "10" }, { "input": "100\n122 575 426 445 172 81 247 429 97 202 175 325 382 384 417 356 132 502 328 537 57 339 518 211 479 306 140 168 268 16 140 263 593 249 391 310 555 468 231 180 157 18 334 328 276 155 21 280 322 545 111 267 467 274 291 304 235 34 365 180 21 95 501 552 325 331 302 353 296 22 289 399 7 466 32 302 568 333 75 192 284 10 94 128 154 512 9 480 243 521 551 492 420 197 207 125 367 117 438 600", "output": "94" }, { "input": "100\n600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600 600", "output": "1" }, { "input": "78\n5 4 13 2 5 6 2 10 10 1 2 6 7 9 6 3 5 7 1 10 2 2 7 0 2 11 11 3 1 13 3 10 6 2 0 3 0 5 0 1 4 11 1 1 7 0 12 7 5 12 0 2 12 9 8 3 4 3 4 11 4 10 2 3 10 12 5 6 1 11 2 0 8 7 9 1 3 12", "output": "13" }, { "input": "34\n220 387 408 343 184 447 197 307 337 414 251 319 426 322 347 242 208 412 188 185 241 235 216 259 331 372 322 284 444 384 214 297 389 391", "output": "33" }, { "input": "100\n1 2 1 0 3 0 2 0 0 1 2 0 1 3 0 3 3 1 3 0 0 2 1 2 2 1 3 3 3 3 3 2 0 0 2 1 2 3 2 3 0 1 1 3 3 2 0 3 1 0 2 2 2 1 2 3 2 1 0 3 0 2 0 3 0 2 1 0 3 1 0 2 2 1 3 1 3 0 2 3 3 1 1 3 1 3 0 3 2 0 2 3 3 0 2 0 2 0 1 3", "output": "3" }, { "input": "100\n572 471 540 163 50 30 561 510 43 200 213 387 500 424 113 487 357 333 294 337 435 202 447 494 485 465 161 344 470 559 104 356 393 207 224 213 511 514 60 386 149 216 392 229 429 173 165 401 395 150 127 579 344 390 529 296 225 425 318 79 465 447 177 110 367 212 459 270 41 500 277 567 125 436 178 9 214 342 203 112 144 24 79 155 495 556 40 549 463 281 241 316 2 246 1 396 510 293 332 55", "output": "93" }, { "input": "99\n5 4 13 2 5 6 2 10 10 1 2 6 7 9 6 3 5 7 1 10 2 2 7 0 2 11 11 3 1 13 3 10 6 2 0 3 0 5 0 1 4 11 1 1 7 0 12 7 5 12 0 2 12 9 8 3 4 3 4 11 4 10 2 3 10 12 5 6 1 11 2 0 8 7 9 1 3 12 2 3 9 3 7 13 7 13 0 11 8 12 2 5 9 4 0 6 6 2 13", "output": "13" }, { "input": "99\n1 0 1 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 0 0 0 1 0 0 1 1 1 1 1 1 0 0 0 0 1 0 1 0 1 0 1 1 1 1 0 0 1 1 0 0 0 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 1 1 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0 1", "output": "1" }, { "input": "99\n21 74 25 44 71 80 46 28 96 1 74 24 81 83 16 55 31 1 27 36 56 38 17 10 78 5 39 67 67 15 39 62 92 48 90 9 54 67 30 79 56 17 33 27 75 54 20 79 21 44 10 66 66 73 90 3 34 33 64 79 20 94 0 51 24 30 1 52 95 21 88 98 6 65 31 1 67 32 74 91 83 9 93 27 53 11 8 79 42 20 50 91 19 96 6 24 66 16 37", "output": "61" }, { "input": "2\n0 1", "output": "1" }, { "input": "2\n0 600", "output": "1" }, { "input": "4\n1 1 1 2", "output": "2" }, { "input": "4\n0 0 1 2", "output": "2" }, { "input": "1\n5", "output": "1" }, { "input": "2\n0 5", "output": "1" }, { "input": "5\n1 0 0 1 2", "output": "2" } ]

1,565,547,328

2,147,483,647

Python 3

OK

TESTS

21

109

0

n = int(input()) participants = set(input().split()) ways = len(participants) if ('0' in participants): print(ways - 1) else: print(ways)

Title: Olympiad Time Limit: None seconds Memory Limit: None megabytes Problem Description: The recent All-Berland Olympiad in Informatics featured *n* participants with each scoring a certain amount of points. As the head of the programming committee, you are to determine the set of participants to be awarded with diplomas with respect to the following criteria: - At least one participant should get a diploma. - None of those with score equal to zero should get awarded. - When someone is awarded, all participants with score not less than his score should also be awarded. Determine the number of ways to choose a subset of participants that will receive the diplomas. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of participants. The next line contains a sequence of *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=600) — participants' scores. It's guaranteed that at least one participant has non-zero score. Output Specification: Print a single integer — the desired number of ways. Demo Input: ['4\n1 3 3 2\n', '3\n1 1 1\n', '4\n42 0 0 42\n'] Demo Output: ['3\n', '1\n', '1\n'] Note: There are three ways to choose a subset in sample case one. 1. Only participants with 3 points will get diplomas. 1. Participants with 2 or 3 points will get diplomas. 1. Everyone will get a diploma! The only option in sample case two is to award everyone. Note that in sample case three participants with zero scores cannot get anything.

```python n = int(input()) participants = set(input().split()) ways = len(participants) if ('0' in participants): print(ways - 1) else: print(ways) ```

3

577

A

Multiplication Table

PROGRAMMING

1,000

[ "implementation", "number theory" ]

null

Let's consider a table consisting of *n* rows and *n* columns. The cell located at the intersection of *i*-th row and *j*-th column contains number *i*<=×<=*j*. The rows and columns are numbered starting from 1. You are given a positive integer *x*. Your task is to count the number of cells in a table that contain number *x*.

The single line contains numbers *n* and *x* (1<=≤<=*n*<=≤<=105, 1<=≤<=*x*<=≤<=109) — the size of the table and the number that we are looking for in the table.

Print a single number: the number of times *x* occurs in the table.

[ "10 5\n", "6 12\n", "5 13\n" ]

[ "2\n", "4\n", "0\n" ]

A table for the second sample test is given below. The occurrences of number 12 are marked bold.

500

[ { "input": "10 5", "output": "2" }, { "input": "6 12", "output": "4" }, { "input": "5 13", "output": "0" }, { "input": "1 1", "output": "1" }, { "input": "2 1", "output": "1" }, { "input": "100000 1", "output": "1" }, { "input": "1 1000000000", "output": "0" }, { "input": "100000 1000000000", "output": "16" }, { "input": "100000 362880", "output": "154" }, { "input": "1 4", "output": "0" }, { "input": "9 12", "output": "4" }, { "input": "10 123", "output": "0" }, { "input": "9551 975275379", "output": "0" }, { "input": "17286 948615687", "output": "0" }, { "input": "58942 936593001", "output": "0" }, { "input": "50000 989460910", "output": "4" }, { "input": "22741 989460910", "output": "0" }, { "input": "22740 989460910", "output": "0" }, { "input": "100000 989460910", "output": "4" }, { "input": "100000 98280", "output": "128" }, { "input": "100000 997920", "output": "222" }, { "input": "100000 720720", "output": "226" }, { "input": "100000 2162160", "output": "282" }, { "input": "100000 4324320", "output": "320" }, { "input": "100000 8648640", "output": "348" }, { "input": "100000 183783600", "output": "438" }, { "input": "100000 551350800", "output": "392" }, { "input": "40000 551350800", "output": "150" }, { "input": "20000 400000000", "output": "1" }, { "input": "19999 400000000", "output": "0" }, { "input": "19999 399960001", "output": "1" }, { "input": "31621 999887641", "output": "1" }, { "input": "31622 999887641", "output": "1" }, { "input": "31620 999887641", "output": "0" }, { "input": "100000 999887641", "output": "3" }, { "input": "100000 25", "output": "3" }, { "input": "100000 1", "output": "1" }, { "input": "100000 3628800", "output": "220" }, { "input": "100000 39916800", "output": "328" }, { "input": "100000 479001600", "output": "254" }, { "input": "4 9", "output": "1" }, { "input": "2 6", "output": "0" }, { "input": "20 100", "output": "3" }, { "input": "10 3", "output": "2" }, { "input": "4 4", "output": "3" }, { "input": "2 4", "output": "1" }, { "input": "89874 1", "output": "1" } ]

1,689,268,261

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

3

93

0

[n,x]=list(map(int,input().split(" "))) count=0 for i in range(1,int(x**0.5)+1): if x % i == 0 and i <= n and x//i <=n: count=count+2 print(count)

Title: Multiplication Table Time Limit: None seconds Memory Limit: None megabytes Problem Description: Let's consider a table consisting of *n* rows and *n* columns. The cell located at the intersection of *i*-th row and *j*-th column contains number *i*<=×<=*j*. The rows and columns are numbered starting from 1. You are given a positive integer *x*. Your task is to count the number of cells in a table that contain number *x*. Input Specification: The single line contains numbers *n* and *x* (1<=≤<=*n*<=≤<=105, 1<=≤<=*x*<=≤<=109) — the size of the table and the number that we are looking for in the table. Output Specification: Print a single number: the number of times *x* occurs in the table. Demo Input: ['10 5\n', '6 12\n', '5 13\n'] Demo Output: ['2\n', '4\n', '0\n'] Note: A table for the second sample test is given below. The occurrences of number 12 are marked bold.

```python [n,x]=list(map(int,input().split(" "))) count=0 for i in range(1,int(x**0.5)+1): if x % i == 0 and i <= n and x//i <=n: count=count+2 print(count) ```

0

80

A

Panoramix's Prediction

PROGRAMMING

800

[ "brute force" ]

A. Panoramix's Prediction

2

256

A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not. The next prime number after *x* is the smallest prime number greater than *x*. For example, the next prime number after 2 is 3, and the next prime number after 3 is 5. Note that there is exactly one next prime number after each number. So 5 is not the next prime number for 2. One cold April morning Panoramix predicted that soon Kakofonix will break free from his straitjacket, and this will be a black day for the residents of the Gallic countryside. Panoramix's prophecy tells that if some day Asterix and Obelix beat exactly *x* Roman soldiers, where *x* is a prime number, and next day they beat exactly *y* Roman soldiers, where *y* is the next prime number after *x*, then it's time to wait for Armageddon, for nothing can shut Kakofonix up while he sings his infernal song. Yesterday the Gauls beat *n* Roman soldiers and it turned out that the number *n* was prime! Today their victims were a troop of *m* Romans (*m*<=><=*n*). Determine whether the Gauls should wait for the black day after today's victory of Asterix and Obelix?

The first and only input line contains two positive integers — *n* and *m* (2<=≤<=*n*<=<<=*m*<=≤<=50). It is guaranteed that *n* is prime. Pretests contain all the cases with restrictions 2<=≤<=*n*<=<<=*m*<=≤<=4.

Print YES, if *m* is the next prime number after *n*, or NO otherwise.

[ "3 5\n", "7 11\n", "7 9\n" ]

[ "YES", "YES", "NO" ]

none

500

[ { "input": "3 5", "output": "YES" }, { "input": "7 11", "output": "YES" }, { "input": "7 9", "output": "NO" }, { "input": "2 3", "output": "YES" }, { "input": "2 4", "output": "NO" }, { "input": "3 4", "output": "NO" }, { "input": "3 5", "output": "YES" }, { "input": "5 7", "output": "YES" }, { "input": "7 11", "output": "YES" }, { "input": "11 13", "output": "YES" }, { "input": "13 17", "output": "YES" }, { "input": "17 19", "output": "YES" }, { "input": "19 23", "output": "YES" }, { "input": "23 29", "output": "YES" }, { "input": "29 31", "output": "YES" }, { "input": "31 37", "output": "YES" }, { "input": "37 41", "output": "YES" }, { "input": "41 43", "output": "YES" }, { "input": "43 47", "output": "YES" }, { "input": "2 5", "output": "NO" }, { "input": "2 7", "output": "NO" }, { "input": "2 6", "output": "NO" }, { "input": "2 11", "output": "NO" }, { "input": "3 6", "output": "NO" }, { "input": "3 7", "output": "NO" }, { "input": "3 9", "output": "NO" }, { "input": "5 6", "output": "NO" }, { "input": "5 9", "output": "NO" }, { "input": "5 11", "output": "NO" }, { "input": "5 13", "output": "NO" }, { "input": "5 15", "output": "NO" }, { "input": "7 8", "output": "NO" }, { "input": "7 13", "output": "NO" }, { "input": "13 15", "output": "NO" }, { "input": "13 17", "output": "YES" }, { "input": "19 21", "output": "NO" }, { "input": "13 20", "output": "NO" }, { "input": "41 49", "output": "NO" }, { "input": "43 49", "output": "NO" }, { "input": "47 50", "output": "NO" }, { "input": "47 49", "output": "NO" }, { "input": "47 48", "output": "NO" }, { "input": "23 25", "output": "NO" }, { "input": "2 50", "output": "NO" }, { "input": "31 33", "output": "NO" } ]

1,568,202,038

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

3

248

0

from math import sqrt a, b = map(int, input().split()) def is_prime(n): c = 0 for i in range(2, int(sqrt(n))+1): if n % i == 0: c += 1 if c == 0: return True else: return False if is_prime(b): if (b-a) == 2 or (b-a) == 4: print("YES") else: print("NO") else: print("NO")

Title: Panoramix's Prediction Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not. The next prime number after *x* is the smallest prime number greater than *x*. For example, the next prime number after 2 is 3, and the next prime number after 3 is 5. Note that there is exactly one next prime number after each number. So 5 is not the next prime number for 2. One cold April morning Panoramix predicted that soon Kakofonix will break free from his straitjacket, and this will be a black day for the residents of the Gallic countryside. Panoramix's prophecy tells that if some day Asterix and Obelix beat exactly *x* Roman soldiers, where *x* is a prime number, and next day they beat exactly *y* Roman soldiers, where *y* is the next prime number after *x*, then it's time to wait for Armageddon, for nothing can shut Kakofonix up while he sings his infernal song. Yesterday the Gauls beat *n* Roman soldiers and it turned out that the number *n* was prime! Today their victims were a troop of *m* Romans (*m*<=><=*n*). Determine whether the Gauls should wait for the black day after today's victory of Asterix and Obelix? Input Specification: The first and only input line contains two positive integers — *n* and *m* (2<=≤<=*n*<=<<=*m*<=≤<=50). It is guaranteed that *n* is prime. Pretests contain all the cases with restrictions 2<=≤<=*n*<=<<=*m*<=≤<=4. Output Specification: Print YES, if *m* is the next prime number after *n*, or NO otherwise. Demo Input: ['3 5\n', '7 11\n', '7 9\n'] Demo Output: ['YES', 'YES', 'NO'] Note: none

```python from math import sqrt a, b = map(int, input().split()) def is_prime(n): c = 0 for i in range(2, int(sqrt(n))+1): if n % i == 0: c += 1 if c == 0: return True else: return False if is_prime(b): if (b-a) == 2 or (b-a) == 4: print("YES") else: print("NO") else: print("NO") ```

0

682

A

Alyona and Numbers

PROGRAMMING

1,100

[ "constructive algorithms", "math", "number theory" ]

null

After finishing eating her bun, Alyona came up with two integers *n* and *m*. She decided to write down two columns of integers — the first column containing integers from 1 to *n* and the second containing integers from 1 to *m*. Now the girl wants to count how many pairs of integers she can choose, one from the first column and the other from the second column, such that their sum is divisible by 5. Formally, Alyona wants to count the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and equals 0. As usual, Alyona has some troubles and asks you to help.

The only line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1<=000<=000).

Print the only integer — the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and (*x*<=+<=*y*) is divisible by 5.

[ "6 12\n", "11 14\n", "1 5\n", "3 8\n", "5 7\n", "21 21\n" ]

[ "14\n", "31\n", "1\n", "5\n", "7\n", "88\n" ]

Following pairs are suitable in the first sample case: - for *x* = 1 fits *y* equal to 4 or 9; - for *x* = 2 fits *y* equal to 3 or 8; - for *x* = 3 fits *y* equal to 2, 7 or 12; - for *x* = 4 fits *y* equal to 1, 6 or 11; - for *x* = 5 fits *y* equal to 5 or 10; - for *x* = 6 fits *y* equal to 4 or 9. Only the pair (1, 4) is suitable in the third sample case.

500

[ { "input": "6 12", "output": "14" }, { "input": "11 14", "output": "31" }, { "input": "1 5", "output": "1" }, { "input": "3 8", "output": "5" }, { "input": "5 7", "output": "7" }, { "input": "21 21", "output": "88" }, { "input": "10 15", "output": "30" }, { "input": "1 1", "output": "0" }, { "input": "1 1000000", "output": "200000" }, { "input": "1000000 1", "output": "200000" }, { "input": "1000000 1000000", "output": "200000000000" }, { "input": "944 844", "output": "159348" }, { "input": "368 984", "output": "72423" }, { "input": "792 828", "output": "131155" }, { "input": "920 969", "output": "178296" }, { "input": "640 325", "output": "41600" }, { "input": "768 170", "output": "26112" }, { "input": "896 310", "output": "55552" }, { "input": "320 154", "output": "9856" }, { "input": "744 999", "output": "148652" }, { "input": "630 843", "output": "106218" }, { "input": "54 688", "output": "7431" }, { "input": "478 828", "output": "79157" }, { "input": "902 184", "output": "33194" }, { "input": "31 29", "output": "180" }, { "input": "751 169", "output": "25384" }, { "input": "879 14", "output": "2462" }, { "input": "7 858", "output": "1201" }, { "input": "431 702", "output": "60512" }, { "input": "855 355", "output": "60705" }, { "input": "553 29", "output": "3208" }, { "input": "721767 525996", "output": "75929310986" }, { "input": "805191 74841", "output": "12052259926" }, { "input": "888615 590981", "output": "105030916263" }, { "input": "4743 139826", "output": "132638943" }, { "input": "88167 721374", "output": "12720276292" }, { "input": "171591 13322", "output": "457187060" }, { "input": "287719 562167", "output": "32349225415" }, { "input": "371143 78307", "output": "5812618980" }, { "input": "487271 627151", "output": "61118498984" }, { "input": "261436 930642", "output": "48660664382" }, { "input": "377564 446782", "output": "33737759810" }, { "input": "460988 28330", "output": "2611958008" }, { "input": "544412 352983", "output": "38433636199" }, { "input": "660540 869123", "output": "114818101284" }, { "input": "743964 417967", "output": "62190480238" }, { "input": "827388 966812", "output": "159985729411" }, { "input": "910812 515656", "output": "93933134534" }, { "input": "26940 64501", "output": "347531388" }, { "input": "110364 356449", "output": "7867827488" }, { "input": "636358 355531", "output": "45248999219" }, { "input": "752486 871672", "output": "131184195318" }, { "input": "803206 420516", "output": "67552194859" }, { "input": "919334 969361", "output": "178233305115" }, { "input": "35462 261309", "output": "1853307952" }, { "input": "118887 842857", "output": "20040948031" }, { "input": "202311 358998", "output": "14525848875" }, { "input": "285735 907842", "output": "51880446774" }, { "input": "401863 456686", "output": "36705041203" }, { "input": "452583 972827", "output": "88056992428" }, { "input": "235473 715013", "output": "33673251230" }, { "input": "318897 263858", "output": "16828704925" }, { "input": "402321 812702", "output": "65393416268" }, { "input": "518449 361546", "output": "37488632431" }, { "input": "634577 910391", "output": "115542637921" }, { "input": "685297 235043", "output": "32214852554" }, { "input": "801425 751183", "output": "120403367155" }, { "input": "884849 300028", "output": "53095895155" }, { "input": "977 848872", "output": "165869588" }, { "input": "51697 397716", "output": "4112144810" }, { "input": "834588 107199", "output": "17893399803" }, { "input": "918012 688747", "output": "126455602192" }, { "input": "1436 237592", "output": "68236422" }, { "input": "117564 753732", "output": "17722349770" }, { "input": "200988 302576", "output": "12162829017" }, { "input": "284412 818717", "output": "46570587880" }, { "input": "400540 176073", "output": "14104855884" }, { "input": "483964 724917", "output": "70166746198" }, { "input": "567388 241058", "output": "27354683301" }, { "input": "650812 789902", "output": "102815540084" }, { "input": "400999 756281", "output": "60653584944" }, { "input": "100 101", "output": "2020" }, { "input": "100 102", "output": "2040" }, { "input": "103 100", "output": "2060" }, { "input": "100 104", "output": "2080" }, { "input": "3 4", "output": "3" }, { "input": "11 23", "output": "50" }, { "input": "8 14", "output": "23" }, { "input": "23423 34234", "output": "160372597" }, { "input": "1 4", "output": "1" }, { "input": "999999 999999", "output": "199999600001" }, { "input": "82 99", "output": "1624" }, { "input": "21 18", "output": "75" }, { "input": "234 234", "output": "10952" }, { "input": "4 4", "output": "4" }, { "input": "6 13", "output": "15" }, { "input": "3 9", "output": "6" }, { "input": "99999 99999", "output": "1999960001" }, { "input": "34 33", "output": "225" }, { "input": "2 2", "output": "0" }, { "input": "333 1", "output": "66" }, { "input": "3 3", "output": "2" }, { "input": "8 2", "output": "3" }, { "input": "2179 2218", "output": "966605" }, { "input": "1000000 999999", "output": "199999800000" }, { "input": "873828 774207", "output": "135304750879" }, { "input": "13 19", "output": "50" }, { "input": "1648 576469", "output": "190004183" }, { "input": "11 13", "output": "28" }, { "input": "5 8", "output": "8" }, { "input": "650074 943659", "output": "122689636154" }, { "input": "1 3", "output": "0" }, { "input": "54 43", "output": "465" }, { "input": "14 9", "output": "26" }, { "input": "2 3", "output": "1" }, { "input": "543 534", "output": "57993" }, { "input": "321 123", "output": "7896" }, { "input": "21 3", "output": "12" }, { "input": "2 1", "output": "0" }, { "input": "4 3", "output": "3" }, { "input": "47474 74747", "output": "709707816" }, { "input": "4 9", "output": "8" }, { "input": "7 4", "output": "6" }, { "input": "9 4", "output": "8" }, { "input": "12414 4214", "output": "10462520" }, { "input": "2 9", "output": "4" }, { "input": "253 821", "output": "41542" }, { "input": "2 4", "output": "2" } ]

1,597,786,746

2,147,483,647

Python 3

OK

TESTS

128

748

0

n, m = map(int, input().split()) res = 0 for k in range(1, 400001): y = k * 5 Max = y - 1 a = min(Max, n) b = min(Max, m) point = y - a res+= max(0, b - point + 1) print(res)

Title: Alyona and Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: After finishing eating her bun, Alyona came up with two integers *n* and *m*. She decided to write down two columns of integers — the first column containing integers from 1 to *n* and the second containing integers from 1 to *m*. Now the girl wants to count how many pairs of integers she can choose, one from the first column and the other from the second column, such that their sum is divisible by 5. Formally, Alyona wants to count the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and equals 0. As usual, Alyona has some troubles and asks you to help. Input Specification: The only line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1<=000<=000). Output Specification: Print the only integer — the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and (*x*<=+<=*y*) is divisible by 5. Demo Input: ['6 12\n', '11 14\n', '1 5\n', '3 8\n', '5 7\n', '21 21\n'] Demo Output: ['14\n', '31\n', '1\n', '5\n', '7\n', '88\n'] Note: Following pairs are suitable in the first sample case: - for *x* = 1 fits *y* equal to 4 or 9; - for *x* = 2 fits *y* equal to 3 or 8; - for *x* = 3 fits *y* equal to 2, 7 or 12; - for *x* = 4 fits *y* equal to 1, 6 or 11; - for *x* = 5 fits *y* equal to 5 or 10; - for *x* = 6 fits *y* equal to 4 or 9. Only the pair (1, 4) is suitable in the third sample case.

```python n, m = map(int, input().split()) res = 0 for k in range(1, 400001): y = k * 5 Max = y - 1 a = min(Max, n) b = min(Max, m) point = y - a res+= max(0, b - point + 1) print(res) ```

3

41

A

Translation

PROGRAMMING

800

[ "implementation", "strings" ]

A. Translation

2

256

The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly.

The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols.

If the word *t* is a word *s*, written reversely, print YES, otherwise print NO.

[ "code\nedoc\n", "abb\naba\n", "code\ncode\n" ]

[ "YES\n", "NO\n", "NO\n" ]

none

500

[ { "input": "code\nedoc", "output": "YES" }, { "input": "abb\naba", "output": "NO" }, { "input": "code\ncode", "output": "NO" }, { "input": "abacaba\nabacaba", "output": "YES" }, { "input": "q\nq", "output": "YES" }, { "input": "asrgdfngfnmfgnhweratgjkk\nasrgdfngfnmfgnhweratgjkk", "output": "NO" }, { "input": "z\na", "output": "NO" }, { "input": "asd\ndsa", "output": "YES" }, { "input": "abcdef\nfecdba", "output": "NO" }, { "input": "ywjjbirapvskozubvxoemscfwl\ngnduubaogtfaiowjizlvjcu", "output": "NO" }, { "input": "mfrmqxtzvgaeuleubcmcxcfqyruwzenguhgrmkuhdgnhgtgkdszwqyd\nmfxufheiperjnhyczclkmzyhcxntdfskzkzdwzzujdinf", "output": "NO" }, { "input": "bnbnemvybqizywlnghlykniaxxxlkhftppbdeqpesrtgkcpoeqowjwhrylpsziiwcldodcoonpimudvrxejjo\ntiynnekmlalogyvrgptbinkoqdwzuiyjlrldxhzjmmp", "output": "NO" }, { "input": "pwlpubwyhzqvcitemnhvvwkmwcaawjvdiwtoxyhbhbxerlypelevasmelpfqwjk\nstruuzebbcenziscuoecywugxncdwzyfozhljjyizpqcgkyonyetarcpwkqhuugsqjuixsxptmbnlfupdcfigacdhhrzb", "output": "NO" }, { "input": "gdvqjoyxnkypfvdxssgrihnwxkeojmnpdeobpecytkbdwujqfjtxsqspxvxpqioyfagzjxupqqzpgnpnpxcuipweunqch\nkkqkiwwasbhezqcfeceyngcyuogrkhqecwsyerdniqiocjehrpkljiljophqhyaiefjpavoom", "output": "NO" }, { "input": "umeszdawsvgkjhlqwzents\nhxqhdungbylhnikwviuh", "output": "NO" }, { "input": "juotpscvyfmgntshcealgbsrwwksgrwnrrbyaqqsxdlzhkbugdyx\nibqvffmfktyipgiopznsqtrtxiijntdbgyy", "output": "NO" }, { "input": "zbwueheveouatecaglziqmudxemhrsozmaujrwlqmppzoumxhamwugedikvkblvmxwuofmpafdprbcftew\nulczwrqhctbtbxrhhodwbcxwimncnexosksujlisgclllxokrsbnozthajnnlilyffmsyko", "output": "NO" }, { "input": "nkgwuugukzcv\nqktnpxedwxpxkrxdvgmfgoxkdfpbzvwsduyiybynbkouonhvmzakeiruhfmvrktghadbfkmwxduoqv", "output": "NO" }, { "input": "incenvizhqpcenhjhehvjvgbsnfixbatrrjstxjzhlmdmxijztphxbrldlqwdfimweepkggzcxsrwelodpnryntepioqpvk\ndhjbjjftlvnxibkklxquwmzhjfvnmwpapdrslioxisbyhhfymyiaqhlgecpxamqnocizwxniubrmpyubvpenoukhcobkdojlybxd", "output": "NO" }, { "input": "w\nw", "output": "YES" }, { "input": "vz\nzv", "output": "YES" }, { "input": "ry\nyr", "output": "YES" }, { "input": "xou\nuox", "output": "YES" }, { "input": "axg\ngax", "output": "NO" }, { "input": "zdsl\nlsdz", "output": "YES" }, { "input": "kudl\nldku", "output": "NO" }, { "input": "zzlzwnqlcl\nlclqnwzlzz", "output": "YES" }, { "input": "vzzgicnzqooejpjzads\nsdazjpjeooqzncigzzv", "output": "YES" }, { "input": "raqhmvmzuwaykjpyxsykr\nxkysrypjkyawuzmvmhqar", "output": "NO" }, { "input": "ngedczubzdcqbxksnxuavdjaqtmdwncjnoaicvmodcqvhfezew\nwezefhvqcdomvciaonjcnwdmtqajdvauxnskxbqcdzbuzcdegn", "output": "YES" }, { "input": "muooqttvrrljcxbroizkymuidvfmhhsjtumksdkcbwwpfqdyvxtrlymofendqvznzlmim\nmimlznzvqdnefomylrtxvydqfpwwbckdskmutjshhmfvdiumykziorbxcjlrrvttqooum", "output": "YES" }, { "input": "vxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaivg\ngviayyikkitmuomcpiakhbxszgbnhvwyzkftwoagzixaearxpjacrnvpvbuzenvovehkmmxvblqyxvctroddksdsgebcmlluqpxv", "output": "YES" }, { "input": "mnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfdc\ncdfmkdgrdptkpewbsqvszipgxvgvuiuzbkkwuowbafkikgvnqdkxnayzdjygvezmtsgywnupocdntipiyiorblqkrzjpzatxahnm", "output": "NO" }, { "input": "dgxmzbqofstzcdgthbaewbwocowvhqpinehpjatnnbrijcolvsatbblsrxabzrpszoiecpwhfjmwuhqrapvtcgvikuxtzbftydkw\nwkdytfbztxukivgctvparqhuwmjfhwpceiozsprzbaxrslbbqasvlocjirbnntajphenipthvwocowbweabhtgdcztsfoqbzmxgd", "output": "NO" }, { "input": "gxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwgeh\nhegwxvocotmzstqfbmpjvijgkcyodlxyjawrpkczpmdspsuhoiruavnnnuwvtwohglkdxjetshkboalvzqbgjgthoteceixioxg", "output": "YES" }, { "input": "sihxuwvmaambplxvjfoskinghzicyfqebjtkysotattkahssumfcgrkheotdxwjckpvapbkaepqrxseyfrwtyaycmrzsrsngkh\nhkgnsrszrmcyaytwrfyesxrqpeakbpavpkcjwxdtoehkrgcfmusshakttatosyktjbeqfycizhgniksofjvxlpbmaamvwuxhis", "output": "YES" }, { "input": "ycnahksbughnonldzrhkysujmylcgcfuludjvjiahtkyzqvkopzqcnwhltbzfugzojqkjjlggmvnultascmygelkiktmfieok\nkoeifmtkiklegkmcsatlunvmggkjjlqjozgufzbtlhwncqzpokvqzykthaijvjdulufcgclymjusyyhrzdlnonhgubskhancy", "output": "NO" }, { "input": "wbqasaehtkfojruzyhrlgwmtyiovmzyfifslvlemhqheyaelzwnthrenjsbmntwaoryzwfbxmscmypvxlfmzpnkkjlvwvmtz\nztmvwvljkknpzmflxvpymcsmxbfwzyroawtnmbsjnerhtnwzleayehqhmelvlsfifyzmvoiytmwglrhyzurjofktheasaqbw", "output": "YES" }, { "input": "imippqurprbhfugngtgifelytadegwrgaefnfhbjjnmzikvjaccotqzemufqieqldgnbmviisgkynzeldlhqxuqphjfmyij\njiymfjhpquxqhldleznykgsiivmbngdlqeiqfumezqtoccajvkizmnjjbhfnfeagrwgedatylefigtgngufhbrpruqppimi", "output": "YES" }, { "input": "bikydffiuisckpvzqlteqfhegsagimodb\nbdomigasgehfqetlqzvpkcsiuiffdykib", "output": "YES" } ]

1,520,501,867

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

9

122

5,632,000

def check(s, t): for i in range(len(s)): if s[i] != t[len(s)-i-1]: return "NO" return "YES" s = list(input().strip()) t = list(input().strip()) print(check(s, t))

Title: Translation Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly. Input Specification: The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols. Output Specification: If the word *t* is a word *s*, written reversely, print YES, otherwise print NO. Demo Input: ['code\nedoc\n', 'abb\naba\n', 'code\ncode\n'] Demo Output: ['YES\n', 'NO\n', 'NO\n'] Note: none

```python def check(s, t): for i in range(len(s)): if s[i] != t[len(s)-i-1]: return "NO" return "YES" s = list(input().strip()) t = list(input().strip()) print(check(s, t)) ```

-1

268

A

Games

PROGRAMMING

800

[ "brute force" ]

null

Manao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different. There are *n* teams taking part in the national championship. The championship consists of *n*·(*n*<=-<=1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number. You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question.

The first line contains an integer *n* (2<=≤<=*n*<=≤<=30). Each of the following *n* lines contains a pair of distinct space-separated integers *h**i*, *a**i* (1<=≤<=*h**i*,<=*a**i*<=≤<=100) — the colors of the *i*-th team's home and guest uniforms, respectively.

In a single line print the number of games where the host team is going to play in the guest uniform.

[ "3\n1 2\n2 4\n3 4\n", "4\n100 42\n42 100\n5 42\n100 5\n", "2\n1 2\n1 2\n" ]

[ "1\n", "5\n", "0\n" ]

In the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2. In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first).

500

[ { "input": "3\n1 2\n2 4\n3 4", "output": "1" }, { "input": "4\n100 42\n42 100\n5 42\n100 5", "output": "5" }, { "input": "2\n1 2\n1 2", "output": "0" }, { "input": "7\n4 7\n52 55\n16 4\n55 4\n20 99\n3 4\n7 52", "output": "6" }, { "input": "10\n68 42\n1 35\n25 70\n59 79\n65 63\n46 6\n28 82\n92 62\n43 96\n37 28", "output": "1" }, { "input": "30\n10 39\n89 1\n78 58\n75 99\n36 13\n77 50\n6 97\n79 28\n27 52\n56 5\n93 96\n40 21\n33 74\n26 37\n53 59\n98 56\n61 65\n42 57\n9 7\n25 63\n74 34\n96 84\n95 47\n12 23\n34 21\n71 6\n27 13\n15 47\n64 14\n12 77", "output": "6" }, { "input": "30\n46 100\n87 53\n34 84\n44 66\n23 20\n50 34\n90 66\n17 39\n13 22\n94 33\n92 46\n63 78\n26 48\n44 61\n3 19\n41 84\n62 31\n65 89\n23 28\n58 57\n19 85\n26 60\n75 66\n69 67\n76 15\n64 15\n36 72\n90 89\n42 69\n45 35", "output": "4" }, { "input": "2\n46 6\n6 46", "output": "2" }, { "input": "29\n8 18\n33 75\n69 22\n97 95\n1 97\n78 10\n88 18\n13 3\n19 64\n98 12\n79 92\n41 72\n69 15\n98 31\n57 74\n15 56\n36 37\n15 66\n63 100\n16 42\n47 56\n6 4\n73 15\n30 24\n27 71\n12 19\n88 69\n85 6\n50 11", "output": "10" }, { "input": "23\n43 78\n31 28\n58 80\n66 63\n20 4\n51 95\n40 20\n50 14\n5 34\n36 39\n77 42\n64 97\n62 89\n16 56\n8 34\n58 16\n37 35\n37 66\n8 54\n50 36\n24 8\n68 48\n85 33", "output": "6" }, { "input": "13\n76 58\n32 85\n99 79\n23 58\n96 59\n72 35\n53 43\n96 55\n41 78\n75 10\n28 11\n72 7\n52 73", "output": "0" }, { "input": "18\n6 90\n70 79\n26 52\n67 81\n29 95\n41 32\n94 88\n18 58\n59 65\n51 56\n64 68\n34 2\n6 98\n95 82\n34 2\n40 98\n83 78\n29 2", "output": "1" }, { "input": "18\n6 90\n100 79\n26 100\n67 100\n29 100\n100 32\n94 88\n18 58\n59 65\n51 56\n64 68\n34 2\n6 98\n95 82\n34 2\n40 98\n83 78\n29 100", "output": "8" }, { "input": "30\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1", "output": "450" }, { "input": "30\n100 99\n58 59\n56 57\n54 55\n52 53\n50 51\n48 49\n46 47\n44 45\n42 43\n40 41\n38 39\n36 37\n34 35\n32 33\n30 31\n28 29\n26 27\n24 25\n22 23\n20 21\n18 19\n16 17\n14 15\n12 13\n10 11\n8 9\n6 7\n4 5\n2 3", "output": "0" }, { "input": "15\n9 3\n2 6\n7 6\n5 10\n9 5\n8 1\n10 5\n2 8\n4 5\n9 8\n5 3\n3 8\n9 8\n4 10\n8 5", "output": "20" }, { "input": "15\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n2 1\n1 2", "output": "108" }, { "input": "25\n2 1\n1 2\n1 2\n1 2\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n1 2\n2 1\n2 1\n2 1\n2 1\n1 2", "output": "312" }, { "input": "25\n91 57\n2 73\n54 57\n2 57\n23 57\n2 6\n57 54\n57 23\n91 54\n91 23\n57 23\n91 57\n54 2\n6 91\n57 54\n2 57\n57 91\n73 91\n57 23\n91 57\n2 73\n91 2\n23 6\n2 73\n23 6", "output": "96" }, { "input": "28\n31 66\n31 91\n91 31\n97 66\n31 66\n31 66\n66 91\n91 31\n97 31\n91 97\n97 31\n66 31\n66 97\n91 31\n31 66\n31 66\n66 31\n31 97\n66 97\n97 31\n31 91\n66 91\n91 66\n31 66\n91 66\n66 31\n66 31\n91 97", "output": "210" }, { "input": "29\n78 27\n50 68\n24 26\n68 43\n38 78\n26 38\n78 28\n28 26\n27 24\n23 38\n24 26\n24 43\n61 50\n38 78\n27 23\n61 26\n27 28\n43 23\n28 78\n43 27\n43 78\n27 61\n28 38\n61 78\n50 26\n43 27\n26 78\n28 50\n43 78", "output": "73" }, { "input": "29\n80 27\n69 80\n27 80\n69 80\n80 27\n80 27\n80 27\n80 69\n27 69\n80 69\n80 27\n27 69\n69 27\n80 69\n27 69\n69 80\n27 69\n80 69\n80 27\n69 27\n27 69\n27 80\n80 27\n69 80\n27 69\n80 69\n69 80\n69 80\n27 80", "output": "277" }, { "input": "30\n19 71\n7 89\n89 71\n21 7\n19 21\n7 89\n19 71\n89 8\n89 21\n19 8\n21 7\n8 89\n19 89\n7 21\n19 8\n19 7\n7 19\n8 21\n71 21\n71 89\n7 19\n7 19\n21 7\n21 19\n21 19\n71 8\n21 8\n71 19\n19 71\n8 21", "output": "154" }, { "input": "30\n44 17\n44 17\n44 17\n17 44\n44 17\n44 17\n17 44\n17 44\n17 44\n44 17\n44 17\n44 17\n44 17\n44 17\n17 44\n17 44\n17 44\n44 17\n44 17\n17 44\n44 17\n44 17\n44 17\n17 44\n17 44\n44 17\n17 44\n44 17\n44 17\n44 17", "output": "418" }, { "input": "22\n78 92\n15 92\n92 78\n78 80\n92 16\n24 80\n92 16\n16 92\n78 16\n24 78\n80 78\n92 80\n16 80\n80 78\n15 78\n92 16\n24 15\n24 80\n80 16\n16 80\n92 80\n24 80", "output": "74" }, { "input": "24\n9 83\n90 31\n83 3\n83 3\n21 31\n83 3\n32 31\n12 21\n31 21\n90 32\n32 21\n12 9\n12 31\n9 83\n83 12\n32 3\n32 83\n90 31\n9 32\n31 21\n83 90\n32 21\n21 3\n32 9", "output": "59" }, { "input": "30\n67 21\n85 39\n85 87\n21 39\n66 85\n10 95\n10 21\n87 85\n82 21\n67 21\n95 10\n21 39\n82 21\n21 66\n66 39\n95 30\n67 85\n66 82\n85 82\n21 66\n10 39\n67 10\n21 85\n10 82\n85 95\n10 85\n21 39\n85 39\n39 10\n95 67", "output": "100" }, { "input": "4\n8 7\n8 7\n7 8\n7 8", "output": "8" }, { "input": "6\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1", "output": "10" }, { "input": "12\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1", "output": "72" }, { "input": "4\n1 2\n1 2\n2 1\n2 1", "output": "8" } ]

1,685,886,387

2,147,483,647

Python 3

OK

TESTS

31

92

0

n = int(input()) l = [] for i in range(n): a,b = map(int,input().split()) l.append([a,b]) i = 0 c = 0 for i in range(len(l)): for j in range(len(l)): if l[i][0] == l[j][1]: c+=1 print(c)

Title: Games Time Limit: None seconds Memory Limit: None megabytes Problem Description: Manao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different. There are *n* teams taking part in the national championship. The championship consists of *n*·(*n*<=-<=1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number. You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question. Input Specification: The first line contains an integer *n* (2<=≤<=*n*<=≤<=30). Each of the following *n* lines contains a pair of distinct space-separated integers *h**i*, *a**i* (1<=≤<=*h**i*,<=*a**i*<=≤<=100) — the colors of the *i*-th team's home and guest uniforms, respectively. Output Specification: In a single line print the number of games where the host team is going to play in the guest uniform. Demo Input: ['3\n1 2\n2 4\n3 4\n', '4\n100 42\n42 100\n5 42\n100 5\n', '2\n1 2\n1 2\n'] Demo Output: ['1\n', '5\n', '0\n'] Note: In the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2. In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first).

```python n = int(input()) l = [] for i in range(n): a,b = map(int,input().split()) l.append([a,b]) i = 0 c = 0 for i in range(len(l)): for j in range(len(l)): if l[i][0] == l[j][1]: c+=1 print(c) ```

3

515

C

Drazil and Factorial

PROGRAMMING

1,400

[ "greedy", "math", "sortings" ]

null

Drazil is playing a math game with Varda. Let's define for positive integer *x* as a product of factorials of its digits. For example, . First, they choose a decimal number *a* consisting of *n* digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number *x* satisfying following two conditions: 1. *x* doesn't contain neither digit 0 nor digit 1. 2. = . Help friends find such number.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=15) — the number of digits in *a*. The second line contains *n* digits of *a*. There is at least one digit in *a* that is larger than 1. Number *a* may possibly contain leading zeroes.

Output a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation.

[ "4\n1234\n", "3\n555\n" ]

[ "33222\n", "555\n" ]

In the first case, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/f5a4207f23215fddce977ab5ea9e9d2e7578fb52.png" style="max-width: 100.0%;max-height: 100.0%;"/>

1,000

[ { "input": "4\n1234", "output": "33222" }, { "input": "3\n555", "output": "555" }, { "input": "15\n012345781234578", "output": "7777553333222222222222" }, { "input": "1\n8", "output": "7222" }, { "input": "10\n1413472614", "output": "75333332222222" }, { "input": "8\n68931246", "output": "77553333332222222" }, { "input": "7\n4424368", "output": "75333332222222222" }, { "input": "6\n576825", "output": "7755532222" }, { "input": "5\n97715", "output": "7775332" }, { "input": "3\n915", "output": "75332" }, { "input": "2\n26", "output": "532" }, { "input": "1\n4", "output": "322" }, { "input": "15\n028745260720699", "output": "7777755533333332222222222" }, { "input": "13\n5761790121605", "output": "7775555333322" }, { "input": "10\n3312667105", "output": "755533332" }, { "input": "1\n7", "output": "7" }, { "input": "15\n989898989898989", "output": "777777777777777333333333333333322222222222222222222222222222" }, { "input": "15\n000000000000007", "output": "7" }, { "input": "15\n999999999999990", "output": "77777777777777333333333333333333333333333322222222222222" }, { "input": "1\n2", "output": "2" }, { "input": "1\n3", "output": "3" }, { "input": "1\n4", "output": "322" }, { "input": "1\n5", "output": "5" }, { "input": "1\n6", "output": "53" }, { "input": "1\n7", "output": "7" }, { "input": "1\n9", "output": "7332" }, { "input": "2\n09", "output": "7332" }, { "input": "13\n1337251172966", "output": "777555333333222" }, { "input": "15\n987654329876543", "output": "777777555533333333332222222222222" }, { "input": "9\n234567899", "output": "777755333333322222222" }, { "input": "2\n99", "output": "77333322" }, { "input": "2\n66", "output": "5533" }, { "input": "3\n999", "output": "777333333222" }, { "input": "5\n99999", "output": "77777333333333322222" }, { "input": "9\n123456789", "output": "77755333332222222" }, { "input": "9\n987654321", "output": "77755333332222222" }, { "input": "3\n666", "output": "555333" }, { "input": "2\n26", "output": "532" }, { "input": "6\n555777", "output": "777555" }, { "input": "10\n1234567899", "output": "777755333333322222222" }, { "input": "4\n6666", "output": "55553333" }, { "input": "4\n9754", "output": "775333222" }, { "input": "2\n95", "output": "75332" }, { "input": "14\n11122233344455", "output": "55333333222222222" }, { "input": "12\n836544897832", "output": "77777553333333222222222222222" } ]

1,691,776,770

2,147,483,647

PyPy 3-64

OK

TESTS

45

62

0

input() print(''.join(sorted(''.join(['' if int(i) < 2 else ['2','3','322','5','53','7','7222','7332'][int(i)-2] for i in input()])))[::-1])

Title: Drazil and Factorial Time Limit: None seconds Memory Limit: None megabytes Problem Description: Drazil is playing a math game with Varda. Let's define for positive integer *x* as a product of factorials of its digits. For example, . First, they choose a decimal number *a* consisting of *n* digits that contains at least one digit larger than 1. This number may possibly start with leading zeroes. Then they should find maximum positive number *x* satisfying following two conditions: 1. *x* doesn't contain neither digit 0 nor digit 1. 2. = . Help friends find such number. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=15) — the number of digits in *a*. The second line contains *n* digits of *a*. There is at least one digit in *a* that is larger than 1. Number *a* may possibly contain leading zeroes. Output Specification: Output a maximum possible integer satisfying the conditions above. There should be no zeroes and ones in this number decimal representation. Demo Input: ['4\n1234\n', '3\n555\n'] Demo Output: ['33222\n', '555\n'] Note: In the first case, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/f5a4207f23215fddce977ab5ea9e9d2e7578fb52.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python input() print(''.join(sorted(''.join(['' if int(i) < 2 else ['2','3','322','5','53','7','7222','7332'][int(i)-2] for i in input()])))[::-1]) ```

3

146

A

Lucky Ticket

PROGRAMMING

800

[ "implementation" ]

null

Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya loves tickets very much. As we know, each ticket has a number that is a positive integer. Its length equals *n* (*n* is always even). Petya calls a ticket lucky if the ticket's number is a lucky number and the sum of digits in the first half (the sum of the first *n*<=/<=2 digits) equals the sum of digits in the second half (the sum of the last *n*<=/<=2 digits). Check if the given ticket is lucky.

The first line contains an even integer *n* (2<=≤<=*n*<=≤<=50) — the length of the ticket number that needs to be checked. The second line contains an integer whose length equals exactly *n* — the ticket number. The number may contain leading zeros.

On the first line print "YES" if the given ticket number is lucky. Otherwise, print "NO" (without the quotes).

[ "2\n47\n", "4\n4738\n", "4\n4774\n" ]

[ "NO\n", "NO\n", "YES\n" ]

In the first sample the sum of digits in the first half does not equal the sum of digits in the second half (4 ≠ 7). In the second sample the ticket number is not the lucky number.

500

[ { "input": "2\n47", "output": "NO" }, { "input": "4\n4738", "output": "NO" }, { "input": "4\n4774", "output": "YES" }, { "input": "4\n4570", "output": "NO" }, { "input": "6\n477477", "output": "YES" }, { "input": "6\n777777", "output": "YES" }, { "input": "20\n44444444444444444444", "output": "YES" }, { "input": "2\n44", "output": "YES" }, { "input": "10\n4745474547", "output": "NO" }, { "input": "14\n77770004444444", "output": "NO" }, { "input": "10\n4747777744", "output": "YES" }, { "input": "10\n1234567890", "output": "NO" }, { "input": "50\n44444444444444444444444444444444444444444444444444", "output": "YES" }, { "input": "50\n44444444444444444444444444444444444444444444444447", "output": "NO" }, { "input": "50\n74444444444444444444444444444444444444444444444444", "output": "NO" }, { "input": "50\n07777777777777777777777777777777777777777777777770", "output": "NO" }, { "input": "50\n77777777777777777777777777777777777777777777777777", "output": "YES" }, { "input": "50\n44747747774474747747747447777447774747447477444474", "output": "YES" }, { "input": "48\n447474444777444474747747744774447444747474774474", "output": "YES" }, { "input": "32\n74474474777444474444747774474774", "output": "YES" }, { "input": "40\n4747777444447747777447447747447474774777", "output": "YES" }, { "input": "10\n4477477444", "output": "YES" }, { "input": "18\n447747474447744747", "output": "YES" }, { "input": "26\n44747744444774744774474447", "output": "YES" }, { "input": "50\n44707747774474747747747447777447774747447477444474", "output": "NO" }, { "input": "40\n4747777444447737777447447747447474774777", "output": "NO" }, { "input": "36\n764477744747444444447747747474744444", "output": "NO" }, { "input": "22\n4477407474777477744447", "output": "NO" }, { "input": "32\n74274474777444474444747774474774", "output": "NO" }, { "input": "16\n4744447974444747", "output": "NO" }, { "input": "2\n11", "output": "NO" }, { "input": "2\n22", "output": "NO" }, { "input": "2\n33", "output": "NO" }, { "input": "2\n74", "output": "NO" }, { "input": "2\n55", "output": "NO" }, { "input": "2\n66", "output": "NO" }, { "input": "2\n77", "output": "YES" }, { "input": "2\n88", "output": "NO" }, { "input": "2\n99", "output": "NO" }, { "input": "4\n4004", "output": "NO" }, { "input": "14\n00077774444444", "output": "NO" }, { "input": "6\n004444", "output": "NO" }, { "input": "4\n0044", "output": "NO" }, { "input": "14\n77771114444444", "output": "NO" }, { "input": "14\n44444447777000", "output": "NO" }, { "input": "6\n004774", "output": "NO" } ]

1,565,116,931

2,147,483,647

Python 3

OK

TESTS

46

248

0

n=int(input()) s=input() if s.count("4")+s.count("7")!=n: print("NO") else: if (sum(int(s[i]) for i in range(0,n//2)))==(sum(int(s[j]) for j in range(n//2,n))): print("YES") else:print("NO")

Title: Lucky Ticket Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya loves tickets very much. As we know, each ticket has a number that is a positive integer. Its length equals *n* (*n* is always even). Petya calls a ticket lucky if the ticket's number is a lucky number and the sum of digits in the first half (the sum of the first *n*<=/<=2 digits) equals the sum of digits in the second half (the sum of the last *n*<=/<=2 digits). Check if the given ticket is lucky. Input Specification: The first line contains an even integer *n* (2<=≤<=*n*<=≤<=50) — the length of the ticket number that needs to be checked. The second line contains an integer whose length equals exactly *n* — the ticket number. The number may contain leading zeros. Output Specification: On the first line print "YES" if the given ticket number is lucky. Otherwise, print "NO" (without the quotes). Demo Input: ['2\n47\n', '4\n4738\n', '4\n4774\n'] Demo Output: ['NO\n', 'NO\n', 'YES\n'] Note: In the first sample the sum of digits in the first half does not equal the sum of digits in the second half (4 ≠ 7). In the second sample the ticket number is not the lucky number.

```python n=int(input()) s=input() if s.count("4")+s.count("7")!=n: print("NO") else: if (sum(int(s[i]) for i in range(0,n//2)))==(sum(int(s[j]) for j in range(n//2,n))): print("YES") else:print("NO") ```

3

71

A

Way Too Long Words

PROGRAMMING

800

[ "strings" ]

A. Way Too Long Words

1

256

Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.

Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.

[ "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n" ]

[ "word\nl10n\ni18n\np43s\n" ]

none

500

[ { "input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis", "output": "word\nl10n\ni18n\np43s" }, { "input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm", "output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m" }, { "input": "3\nnjfngnrurunrgunrunvurn\njfvnjfdnvjdbfvsbdubruvbubvkdb\nksdnvidnviudbvibd", "output": "n20n\nj27b\nk15d" }, { "input": "1\ntcyctkktcctrcyvbyiuhihhhgyvyvyvyvjvytchjckt", "output": "t41t" }, { "input": "24\nyou\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nunofficially\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings", "output": "you\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nu10y\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings" }, { "input": "1\na", "output": "a" }, { "input": "26\na\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz", "output": "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz" }, { "input": "1\nabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij", "output": "a98j" }, { "input": "10\ngyartjdxxlcl\nfzsck\nuidwu\nxbymclornemdmtj\nilppyoapitawgje\ncibzc\ndrgbeu\nhezplmsdekhhbo\nfeuzlrimbqbytdu\nkgdco", "output": "g10l\nfzsck\nuidwu\nx13j\ni13e\ncibzc\ndrgbeu\nh12o\nf13u\nkgdco" }, { "input": "20\nlkpmx\nkovxmxorlgwaomlswjxlpnbvltfv\nhykasjxqyjrmybejnmeumzha\ntuevlumpqbbhbww\nqgqsphvrmupxxc\ntrissbaf\nqfgrlinkzvzqdryckaizutd\nzzqtoaxkvwoscyx\noswytrlnhpjvvnwookx\nlpuzqgec\ngyzqfwxggtvpjhzmzmdw\nrlxjgmvdftvrmvbdwudra\nvsntnjpepnvdaxiporggmglhagv\nxlvcqkqgcrbgtgglj\nlyxwxbiszyhlsrgzeedzprbmcpduvq\nyrmqqvrkqskqukzqrwukpsifgtdc\nxpuohcsjhhuhvr\nvvlfrlxpvqejngwrbfbpmqeirxlw\nsvmasocxdvadmaxtrpakysmeaympy\nyuflqboqfdt", "output": "lkpmx\nk26v\nh22a\nt13w\nq12c\ntrissbaf\nq21d\nz13x\no17x\nlpuzqgec\ng18w\nr19a\nv25v\nx15j\nl28q\ny26c\nx12r\nv26w\ns27y\ny9t" }, { "input": "100\nm\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr", "output": "m\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr" } ]

1,684,761,869

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

1

46

0

def abrivateWords(word): if len(word) <= 10: return word length = len(word)-2 return word[0] + str(length) + word[-1] test = ['word', 'localization', 'internationalization', 'pneumonoultramicroscopicsilicovolcanoconiosis'] for i in test: print(abrivateWords(i))

Title: Way Too Long Words Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters. Output Specification: Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data. Demo Input: ['4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n'] Demo Output: ['word\nl10n\ni18n\np43s\n'] Note: none

```python def abrivateWords(word): if len(word) <= 10: return word length = len(word)-2 return word[0] + str(length) + word[-1] test = ['word', 'localization', 'internationalization', 'pneumonoultramicroscopicsilicovolcanoconiosis'] for i in test: print(abrivateWords(i)) ```

0

242

A

Heads or Tails

PROGRAMMING

1,100

[ "brute force", "implementation" ]

null

Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin *x* times, then Petya tosses a coin *y* times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw. At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least *a* times, and Petya got heads at least *b* times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories.

The single line contains four integers *x*,<=*y*,<=*a*,<=*b* (1<=≤<=*a*<=≤<=*x*<=≤<=100,<=1<=≤<=*b*<=≤<=*y*<=≤<=100). The numbers on the line are separated by a space.

In the first line print integer *n* — the number of possible outcomes of the game. Then on *n* lines print the outcomes. On the *i*-th line print a space-separated pair of integers *c**i*, *d**i* — the number of heads Vasya and Petya got in the *i*-th outcome of the game, correspondingly. Print pairs of integers (*c**i*,<=*d**i*) in the strictly increasing order. Let us remind you that the pair of numbers (*p*1,<=*q*1) is less than the pair of numbers (*p*2,<=*q*2), if *p*1<=<<=*p*2, or *p*1<==<=*p*2 and also *q*1<=<<=*q*2.

[ "3 2 1 1\n", "2 4 2 2\n" ]

[ "3\n2 1\n3 1\n3 2\n", "0\n" ]

none

500

[ { "input": "3 2 1 1", "output": "3\n2 1\n3 1\n3 2" }, { "input": "2 4 2 2", "output": "0" }, { "input": "1 1 1 1", "output": "0" }, { "input": "4 5 2 3", "output": "1\n4 3" }, { "input": "10 6 3 4", "output": "15\n5 4\n6 4\n6 5\n7 4\n7 5\n7 6\n8 4\n8 5\n8 6\n9 4\n9 5\n9 6\n10 4\n10 5\n10 6" }, { "input": "10 10 1 1", "output": "45\n2 1\n3 1\n3 2\n4 1\n4 2\n4 3\n5 1\n5 2\n5 3\n5 4\n6 1\n6 2\n6 3\n6 4\n6 5\n7 1\n7 2\n7 3\n7 4\n7 5\n7 6\n8 1\n8 2\n8 3\n8 4\n8 5\n8 6\n8 7\n9 1\n9 2\n9 3\n9 4\n9 5\n9 6\n9 7\n9 8\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9" }, { "input": "9 7 4 7", "output": "2\n8 7\n9 7" }, { "input": "5 5 3 2", "output": "6\n3 2\n4 2\n4 3\n5 2\n5 3\n5 4" }, { "input": "10 10 1 1", "output": "45\n2 1\n3 1\n3 2\n4 1\n4 2\n4 3\n5 1\n5 2\n5 3\n5 4\n6 1\n6 2\n6 3\n6 4\n6 5\n7 1\n7 2\n7 3\n7 4\n7 5\n7 6\n8 1\n8 2\n8 3\n8 4\n8 5\n8 6\n8 7\n9 1\n9 2\n9 3\n9 4\n9 5\n9 6\n9 7\n9 8\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9" }, { "input": "20 10 1 8", "output": "33\n9 8\n10 8\n10 9\n11 8\n11 9\n11 10\n12 8\n12 9\n12 10\n13 8\n13 9\n13 10\n14 8\n14 9\n14 10\n15 8\n15 9\n15 10\n16 8\n16 9\n16 10\n17 8\n17 9\n17 10\n18 8\n18 9\n18 10\n19 8\n19 9\n19 10\n20 8\n20 9\n20 10" }, { "input": "10 20 4 6", "output": "10\n7 6\n8 6\n8 7\n9 6\n9 7\n9 8\n10 6\n10 7\n10 8\n10 9" }, { "input": "50 50 1 30", "output": "210\n31 30\n32 30\n32 31\n33 30\n33 31\n33 32\n34 30\n34 31\n34 32\n34 33\n35 30\n35 31\n35 32\n35 33\n35 34\n36 30\n36 31\n36 32\n36 33\n36 34\n36 35\n37 30\n37 31\n37 32\n37 33\n37 34\n37 35\n37 36\n38 30\n38 31\n38 32\n38 33\n38 34\n38 35\n38 36\n38 37\n39 30\n39 31\n39 32\n39 33\n39 34\n39 35\n39 36\n39 37\n39 38\n40 30\n40 31\n40 32\n40 33\n40 34\n40 35\n40 36\n40 37\n40 38\n40 39\n41 30\n41 31\n41 32\n41 33\n41 34\n41 35\n41 36\n41 37\n41 38\n41 39\n41 40\n42 30\n42 31\n42 32\n42 33\n42 34\n42 35\n42..." }, { "input": "60 50 30 40", "output": "165\n41 40\n42 40\n42 41\n43 40\n43 41\n43 42\n44 40\n44 41\n44 42\n44 43\n45 40\n45 41\n45 42\n45 43\n45 44\n46 40\n46 41\n46 42\n46 43\n46 44\n46 45\n47 40\n47 41\n47 42\n47 43\n47 44\n47 45\n47 46\n48 40\n48 41\n48 42\n48 43\n48 44\n48 45\n48 46\n48 47\n49 40\n49 41\n49 42\n49 43\n49 44\n49 45\n49 46\n49 47\n49 48\n50 40\n50 41\n50 42\n50 43\n50 44\n50 45\n50 46\n50 47\n50 48\n50 49\n51 40\n51 41\n51 42\n51 43\n51 44\n51 45\n51 46\n51 47\n51 48\n51 49\n51 50\n52 40\n52 41\n52 42\n52 43\n52 44\n52 45\n52..." }, { "input": "100 100 1 1", "output": "4950\n2 1\n3 1\n3 2\n4 1\n4 2\n4 3\n5 1\n5 2\n5 3\n5 4\n6 1\n6 2\n6 3\n6 4\n6 5\n7 1\n7 2\n7 3\n7 4\n7 5\n7 6\n8 1\n8 2\n8 3\n8 4\n8 5\n8 6\n8 7\n9 1\n9 2\n9 3\n9 4\n9 5\n9 6\n9 7\n9 8\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9\n11 1\n11 2\n11 3\n11 4\n11 5\n11 6\n11 7\n11 8\n11 9\n11 10\n12 1\n12 2\n12 3\n12 4\n12 5\n12 6\n12 7\n12 8\n12 9\n12 10\n12 11\n13 1\n13 2\n13 3\n13 4\n13 5\n13 6\n13 7\n13 8\n13 9\n13 10\n13 11\n13 12\n14 1\n14 2\n14 3\n14 4\n14 5\n14 6\n14 7\n14 8\n14 9\n14 10\n14 11\n..." }, { "input": "100 99 10 13", "output": "3828\n14 13\n15 13\n15 14\n16 13\n16 14\n16 15\n17 13\n17 14\n17 15\n17 16\n18 13\n18 14\n18 15\n18 16\n18 17\n19 13\n19 14\n19 15\n19 16\n19 17\n19 18\n20 13\n20 14\n20 15\n20 16\n20 17\n20 18\n20 19\n21 13\n21 14\n21 15\n21 16\n21 17\n21 18\n21 19\n21 20\n22 13\n22 14\n22 15\n22 16\n22 17\n22 18\n22 19\n22 20\n22 21\n23 13\n23 14\n23 15\n23 16\n23 17\n23 18\n23 19\n23 20\n23 21\n23 22\n24 13\n24 14\n24 15\n24 16\n24 17\n24 18\n24 19\n24 20\n24 21\n24 22\n24 23\n25 13\n25 14\n25 15\n25 16\n25 17\n25 18\n2..." }, { "input": "99 100 20 7", "output": "4200\n20 7\n20 8\n20 9\n20 10\n20 11\n20 12\n20 13\n20 14\n20 15\n20 16\n20 17\n20 18\n20 19\n21 7\n21 8\n21 9\n21 10\n21 11\n21 12\n21 13\n21 14\n21 15\n21 16\n21 17\n21 18\n21 19\n21 20\n22 7\n22 8\n22 9\n22 10\n22 11\n22 12\n22 13\n22 14\n22 15\n22 16\n22 17\n22 18\n22 19\n22 20\n22 21\n23 7\n23 8\n23 9\n23 10\n23 11\n23 12\n23 13\n23 14\n23 15\n23 16\n23 17\n23 18\n23 19\n23 20\n23 21\n23 22\n24 7\n24 8\n24 9\n24 10\n24 11\n24 12\n24 13\n24 14\n24 15\n24 16\n24 17\n24 18\n24 19\n24 20\n24 21\n24 22\n24..." }, { "input": "100 90 100 83", "output": "8\n100 83\n100 84\n100 85\n100 86\n100 87\n100 88\n100 89\n100 90" }, { "input": "80 100 1 50", "output": "465\n51 50\n52 50\n52 51\n53 50\n53 51\n53 52\n54 50\n54 51\n54 52\n54 53\n55 50\n55 51\n55 52\n55 53\n55 54\n56 50\n56 51\n56 52\n56 53\n56 54\n56 55\n57 50\n57 51\n57 52\n57 53\n57 54\n57 55\n57 56\n58 50\n58 51\n58 52\n58 53\n58 54\n58 55\n58 56\n58 57\n59 50\n59 51\n59 52\n59 53\n59 54\n59 55\n59 56\n59 57\n59 58\n60 50\n60 51\n60 52\n60 53\n60 54\n60 55\n60 56\n60 57\n60 58\n60 59\n61 50\n61 51\n61 52\n61 53\n61 54\n61 55\n61 56\n61 57\n61 58\n61 59\n61 60\n62 50\n62 51\n62 52\n62 53\n62 54\n62 55\n62..." }, { "input": "100 39 70 5", "output": "1085\n70 5\n70 6\n70 7\n70 8\n70 9\n70 10\n70 11\n70 12\n70 13\n70 14\n70 15\n70 16\n70 17\n70 18\n70 19\n70 20\n70 21\n70 22\n70 23\n70 24\n70 25\n70 26\n70 27\n70 28\n70 29\n70 30\n70 31\n70 32\n70 33\n70 34\n70 35\n70 36\n70 37\n70 38\n70 39\n71 5\n71 6\n71 7\n71 8\n71 9\n71 10\n71 11\n71 12\n71 13\n71 14\n71 15\n71 16\n71 17\n71 18\n71 19\n71 20\n71 21\n71 22\n71 23\n71 24\n71 25\n71 26\n71 27\n71 28\n71 29\n71 30\n71 31\n71 32\n71 33\n71 34\n71 35\n71 36\n71 37\n71 38\n71 39\n72 5\n72 6\n72 7\n72 8\n7..." }, { "input": "70 80 30 80", "output": "0" }, { "input": "100 100 1 1", "output": "4950\n2 1\n3 1\n3 2\n4 1\n4 2\n4 3\n5 1\n5 2\n5 3\n5 4\n6 1\n6 2\n6 3\n6 4\n6 5\n7 1\n7 2\n7 3\n7 4\n7 5\n7 6\n8 1\n8 2\n8 3\n8 4\n8 5\n8 6\n8 7\n9 1\n9 2\n9 3\n9 4\n9 5\n9 6\n9 7\n9 8\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9\n11 1\n11 2\n11 3\n11 4\n11 5\n11 6\n11 7\n11 8\n11 9\n11 10\n12 1\n12 2\n12 3\n12 4\n12 5\n12 6\n12 7\n12 8\n12 9\n12 10\n12 11\n13 1\n13 2\n13 3\n13 4\n13 5\n13 6\n13 7\n13 8\n13 9\n13 10\n13 11\n13 12\n14 1\n14 2\n14 3\n14 4\n14 5\n14 6\n14 7\n14 8\n14 9\n14 10\n14 11\n..." }, { "input": "100 100 100 5", "output": "95\n100 5\n100 6\n100 7\n100 8\n100 9\n100 10\n100 11\n100 12\n100 13\n100 14\n100 15\n100 16\n100 17\n100 18\n100 19\n100 20\n100 21\n100 22\n100 23\n100 24\n100 25\n100 26\n100 27\n100 28\n100 29\n100 30\n100 31\n100 32\n100 33\n100 34\n100 35\n100 36\n100 37\n100 38\n100 39\n100 40\n100 41\n100 42\n100 43\n100 44\n100 45\n100 46\n100 47\n100 48\n100 49\n100 50\n100 51\n100 52\n100 53\n100 54\n100 55\n100 56\n100 57\n100 58\n100 59\n100 60\n100 61\n100 62\n100 63\n100 64\n100 65\n100 66\n100 67\n100 68\n..." }, { "input": "99 99 1 1", "output": "4851\n2 1\n3 1\n3 2\n4 1\n4 2\n4 3\n5 1\n5 2\n5 3\n5 4\n6 1\n6 2\n6 3\n6 4\n6 5\n7 1\n7 2\n7 3\n7 4\n7 5\n7 6\n8 1\n8 2\n8 3\n8 4\n8 5\n8 6\n8 7\n9 1\n9 2\n9 3\n9 4\n9 5\n9 6\n9 7\n9 8\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9\n11 1\n11 2\n11 3\n11 4\n11 5\n11 6\n11 7\n11 8\n11 9\n11 10\n12 1\n12 2\n12 3\n12 4\n12 5\n12 6\n12 7\n12 8\n12 9\n12 10\n12 11\n13 1\n13 2\n13 3\n13 4\n13 5\n13 6\n13 7\n13 8\n13 9\n13 10\n13 11\n13 12\n14 1\n14 2\n14 3\n14 4\n14 5\n14 6\n14 7\n14 8\n14 9\n14 10\n14 11\n..." } ]

1,652,437,835

2,147,483,647

Python 3

OK

TESTS

23

122

0

x,y,a,b=map(int,input().split()) d=list() for i in range(a,x+1): for j in range(b,y+1): if j<i: d.append((i,j)) print(len(d)) for el in d: print(*el)

Title: Heads or Tails Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya and Vasya are tossing a coin. Their friend Valera is appointed as a judge. The game is very simple. First Vasya tosses a coin *x* times, then Petya tosses a coin *y* times. If the tossing player gets head, he scores one point. If he gets tail, nobody gets any points. The winner is the player with most points by the end of the game. If boys have the same number of points, the game finishes with a draw. At some point, Valera lost his count, and so he can not say exactly what the score is at the end of the game. But there are things he remembers for sure. He remembers that the entire game Vasya got heads at least *a* times, and Petya got heads at least *b* times. Moreover, he knows that the winner of the game was Vasya. Valera wants to use this information to know every possible outcome of the game, which do not contradict his memories. Input Specification: The single line contains four integers *x*,<=*y*,<=*a*,<=*b* (1<=≤<=*a*<=≤<=*x*<=≤<=100,<=1<=≤<=*b*<=≤<=*y*<=≤<=100). The numbers on the line are separated by a space. Output Specification: In the first line print integer *n* — the number of possible outcomes of the game. Then on *n* lines print the outcomes. On the *i*-th line print a space-separated pair of integers *c**i*, *d**i* — the number of heads Vasya and Petya got in the *i*-th outcome of the game, correspondingly. Print pairs of integers (*c**i*,<=*d**i*) in the strictly increasing order. Let us remind you that the pair of numbers (*p*1,<=*q*1) is less than the pair of numbers (*p*2,<=*q*2), if *p*1<=<<=*p*2, or *p*1<==<=*p*2 and also *q*1<=<<=*q*2. Demo Input: ['3 2 1 1\n', '2 4 2 2\n'] Demo Output: ['3\n2 1\n3 1\n3 2\n', '0\n'] Note: none

```python x,y,a,b=map(int,input().split()) d=list() for i in range(a,x+1): for j in range(b,y+1): if j<i: d.append((i,j)) print(len(d)) for el in d: print(*el) ```

3

851

B

Arpa and an exam about geometry

PROGRAMMING

1,400

[ "geometry", "math" ]

null

Arpa is taking a geometry exam. Here is the last problem of the exam. You are given three points *a*,<=*b*,<=*c*. Find a point and an angle such that if we rotate the page around the point by the angle, the new position of *a* is the same as the old position of *b*, and the new position of *b* is the same as the old position of *c*. Arpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not.

The only line contains six integers *a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*c**x*,<=*c**y* (|*a**x*|,<=|*a**y*|,<=|*b**x*|,<=|*b**y*|,<=|*c**x*|,<=|*c**y*|<=≤<=109). It's guaranteed that the points are distinct.

Print "Yes" if the problem has a solution, "No" otherwise. You can print each letter in any case (upper or lower).

[ "0 1 1 1 1 0\n", "1 1 0 0 1000 1000\n" ]

[ "Yes\n", "No\n" ]

In the first sample test, rotate the page around (0.5, 0.5) by <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9d845923f4d356a48d8ede337db0303821311f0c.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second sample test, you can't find any solution.

1,000

[ { "input": "0 1 1 1 1 0", "output": "Yes" }, { "input": "1 1 0 0 1000 1000", "output": "No" }, { "input": "1 0 2 0 3 0", "output": "No" }, { "input": "3 4 0 0 4 3", "output": "Yes" }, { "input": "-1000000000 1 0 0 1000000000 1", "output": "Yes" }, { "input": "49152 0 0 0 0 81920", "output": "No" }, { "input": "1 -1 4 4 2 -3", "output": "No" }, { "input": "-2 -2 1 4 -2 0", "output": "No" }, { "input": "5 0 4 -2 0 1", "output": "No" }, { "input": "-4 -3 2 -1 -3 4", "output": "No" }, { "input": "-3 -3 5 2 3 -1", "output": "No" }, { "input": "-1000000000 -1000000000 0 0 1000000000 999999999", "output": "No" }, { "input": "-1000000000 -1000000000 0 0 1000000000 1000000000", "output": "No" }, { "input": "-357531221 381512519 -761132895 -224448284 328888775 -237692564", "output": "No" }, { "input": "264193194 -448876521 736684426 -633906160 -328597212 -47935734", "output": "No" }, { "input": "419578772 -125025887 169314071 89851312 961404059 21419450", "output": "No" }, { "input": "-607353321 -620687860 248029390 477864359 728255275 -264646027", "output": "No" }, { "input": "299948862 -648908808 338174789 841279400 -850322448 350263551", "output": "No" }, { "input": "48517753 416240699 7672672 272460100 -917845051 199790781", "output": "No" }, { "input": "-947393823 -495674431 211535284 -877153626 -522763219 -778236665", "output": "No" }, { "input": "-685673792 -488079395 909733355 385950193 -705890324 256550506", "output": "No" }, { "input": "-326038504 547872194 49630307 713863100 303770000 -556852524", "output": "No" }, { "input": "-706921242 -758563024 -588592101 -443440080 858751713 238854303", "output": "No" }, { "input": "-1000000000 -1000000000 0 1000000000 1000000000 -1000000000", "output": "Yes" }, { "input": "1000000000 1000000000 0 -1000000000 -1000000000 1000000000", "output": "Yes" }, { "input": "-999999999 -1000000000 0 0 1000000000 999999999", "output": "Yes" }, { "input": "-1000000000 -999999999 0 0 1000000000 999999999", "output": "No" }, { "input": "-1 -1000000000 0 1000000000 1 -1000000000", "output": "Yes" }, { "input": "0 1000000000 1 0 0 -1000000000", "output": "Yes" }, { "input": "0 1000000000 0 0 0 -1000000000", "output": "No" }, { "input": "0 1 1 2 2 3", "output": "No" }, { "input": "999999999 1000000000 0 0 -1000000000 -999999999", "output": "Yes" }, { "input": "0 0 1 1 2 0", "output": "Yes" }, { "input": "0 0 1 1 2 2", "output": "No" }, { "input": "1 1 2 2 3 3", "output": "No" }, { "input": "0 2 0 3 0 4", "output": "No" }, { "input": "1 1 1 2 1 3", "output": "No" }, { "input": "0 0 3 4 3 9", "output": "Yes" }, { "input": "589824 196608 262144 196608 0 0", "output": "Yes" }, { "input": "0 0 1000000000 1 1000000000 -999999999", "output": "No" }, { "input": "0 0 2 45 0 90", "output": "Yes" }, { "input": "0 0 0 2 0 1", "output": "No" }, { "input": "0 2 4 5 4 0", "output": "Yes" }, { "input": "0 0 2 0 4 0", "output": "No" }, { "input": "1 1 3 3 5 5", "output": "No" }, { "input": "1 1 2 2 3 1", "output": "Yes" } ]

1,504,555,741

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

26

62

0

ax,ay,bx,by,cx,cy=map(int,input().split()) ab=((ax-bx)**2+(ay-by)**2)**0.5 bc=((bx-cx)**2+(by-cy)**2)**0.5 ca=((cx-ax)**2+(cy-ay)**2)**0.5 if ab==bc: if ab+bc>ca: print("Yes") elif ab+bc==ca and ab**2<(ax-bx)**2+(ay-by)**2 or bc**2<(bx-cx)**2+(by-cy)**2: print("Yes") else: print("No") else: print("No")

Title: Arpa and an exam about geometry Time Limit: None seconds Memory Limit: None megabytes Problem Description: Arpa is taking a geometry exam. Here is the last problem of the exam. You are given three points *a*,<=*b*,<=*c*. Find a point and an angle such that if we rotate the page around the point by the angle, the new position of *a* is the same as the old position of *b*, and the new position of *b* is the same as the old position of *c*. Arpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not. Input Specification: The only line contains six integers *a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*c**x*,<=*c**y* (|*a**x*|,<=|*a**y*|,<=|*b**x*|,<=|*b**y*|,<=|*c**x*|,<=|*c**y*|<=≤<=109). It's guaranteed that the points are distinct. Output Specification: Print "Yes" if the problem has a solution, "No" otherwise. You can print each letter in any case (upper or lower). Demo Input: ['0 1 1 1 1 0\n', '1 1 0 0 1000 1000\n'] Demo Output: ['Yes\n', 'No\n'] Note: In the first sample test, rotate the page around (0.5, 0.5) by <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9d845923f4d356a48d8ede337db0303821311f0c.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second sample test, you can't find any solution.

```python ax,ay,bx,by,cx,cy=map(int,input().split()) ab=((ax-bx)**2+(ay-by)**2)**0.5 bc=((bx-cx)**2+(by-cy)**2)**0.5 ca=((cx-ax)**2+(cy-ay)**2)**0.5 if ab==bc: if ab+bc>ca: print("Yes") elif ab+bc==ca and ab**2<(ax-bx)**2+(ay-by)**2 or bc**2<(bx-cx)**2+(by-cy)**2: print("Yes") else: print("No") else: print("No") ```

0

none

0

[ "none" ]

null

The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness". The test consists of *n* questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question *n*. Question *i* contains *a**i* answer variants, exactly one of them is correct. A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the *n* questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves. Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100). It is the number of questions in the test. The second line contains space-separated *n* positive integers *a**i* (1<=≤<=*a**i*<=≤<=109), the number of answer variants to question *i*.

Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario. Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.

[ "2\n1 1\n", "2\n2 2\n", "1\n10\n" ]

[ "2", "5", "10" ]

Note to the second sample. In the worst-case scenario you will need five clicks: - the first click selects the first variant to the first question, this answer turns out to be wrong. - the second click selects the second variant to the first question, it proves correct and we move on to the second question; - the third click selects the first variant to the second question, it is wrong and we go back to question 1; - the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question; - the fifth click selects the second variant to the second question, it proves correct, the test is finished.

0

[ { "input": "2\n1 1", "output": "2" }, { "input": "2\n2 2", "output": "5" }, { "input": "1\n10", "output": "10" }, { "input": "3\n2 4 1", "output": "10" }, { "input": "4\n5 5 3 1", "output": "22" }, { "input": "2\n1000000000 1000000000", "output": "2999999999" }, { "input": "10\n5 7 8 1 10 3 6 4 10 6", "output": "294" }, { "input": "100\n5 7 5 3 5 4 6 5 3 6 4 6 6 2 1 9 6 5 3 8 4 10 1 9 1 3 7 6 5 5 8 8 7 7 8 9 2 10 3 5 4 2 6 10 2 6 9 6 1 9 3 7 7 8 3 9 9 5 10 10 3 10 7 8 3 9 8 3 2 4 10 2 1 1 7 3 9 10 4 6 9 8 2 1 4 10 1 10 6 8 7 5 3 3 6 2 7 10 3 8", "output": "24212" }, { "input": "100\n96 23 25 62 34 30 85 15 26 61 59 87 34 99 60 41 52 73 63 84 50 89 42 29 87 99 19 94 84 43 82 90 41 100 60 61 99 49 26 3 97 5 24 34 51 59 69 61 11 41 72 60 33 36 18 29 82 53 18 80 52 98 38 32 56 95 55 79 32 80 37 64 45 13 62 80 70 29 1 58 88 24 79 68 41 80 12 72 52 39 64 19 54 56 70 58 19 3 83 62", "output": "261115" }, { "input": "100\n883 82 79 535 478 824 700 593 262 385 403 183 176 386 126 648 710 516 922 97 800 728 372 9 954 911 975 526 476 3 74 459 471 174 295 831 698 21 927 698 580 856 712 430 5 473 592 40 301 230 763 266 38 213 393 70 333 779 811 249 130 456 763 657 578 699 939 660 898 918 438 855 892 85 35 232 54 593 849 777 917 979 796 322 473 887 284 105 522 415 86 480 80 592 516 227 680 574 488 644", "output": "2519223" }, { "input": "100\n6659 5574 5804 7566 7431 1431 3871 6703 200 300 3523 3580 8500 2312 4812 3149 3324 5846 8965 5758 5831 1341 7733 4477 355 3024 2941 9938 1494 16 1038 8262 9938 9230 5192 8113 7575 7696 5566 2884 8659 1951 1253 6480 3877 3707 5482 3825 5359 44 3219 3258 1785 5478 4525 5950 2417 1991 8885 4264 8769 2961 7107 8904 5097 2319 5713 8811 9723 8677 2153 3237 7174 9528 9260 7390 3050 6823 6239 5222 4602 933 7823 4198 8304 244 5845 3189 4490 3216 7877 6323 1938 4597 880 1206 1691 1405 4122 5950", "output": "24496504" }, { "input": "50\n515844718 503470143 928669067 209884122 322869098 241621928 844696197 105586164 552680307 968792756 135928721 842094825 298782438 829020472 791637138 285482545 811025527 428952878 887796419 11883658 546401594 6272027 100292274 308219869 372132044 955814846 644008184 521195760 919389466 215065725 687764134 655750167 181397022 404292682 643251185 776299412 741398345 865144798 369796727 673902099 124966684 35796775 794385099 594562033 550366869 868093561 695094388 580789105 755076935 198783899", "output": "685659563557" }, { "input": "10\n12528238 329065023 620046219 303914458 356423530 751571368 72944261 883971060 123105651 868129460", "output": "27409624352" }, { "input": "1\n84355694", "output": "84355694" }, { "input": "2\n885992042 510468669", "output": "1906929379" }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "100" }, { "input": "100\n2 1 2 2 2 2 1 2 2 1 2 2 2 1 2 1 2 2 1 2 2 2 2 2 2 1 2 1 1 2 1 1 2 1 2 1 1 1 2 2 2 2 2 1 2 2 2 2 1 1 1 1 1 2 2 1 1 1 2 2 1 1 2 1 1 2 2 2 2 1 2 2 2 1 2 1 2 2 1 2 1 1 1 2 2 1 2 1 2 1 1 1 2 1 2 2 2 1 1 1", "output": "2686" }, { "input": "100\n1 3 2 1 1 2 1 3 2 2 3 1 1 1 2 2 1 3 3 1 1 2 2 3 2 1 3 1 3 2 1 1 3 3 2 1 2 2 2 3 2 2 3 2 2 3 2 1 3 1 1 2 1 3 2 2 1 1 1 1 1 1 3 1 2 3 1 1 1 1 1 2 3 3 1 1 1 1 2 3 3 1 3 2 2 3 2 1 3 2 2 3 1 1 3 2 3 2 3 1", "output": "4667" } ]

1,617,728,912

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

4

124

204,800

#Author : Zahin uddin #Github : https://github.com/Zahin52 from sys import * #import math #import queue input=stdin.readline listInput=lambda:list(map(int,input().strip().split())) lineInput= lambda:map(int,input().strip().split()) sJoin=lambda a,sep : f'{sep}'.join(a) arrJoin=lambda a,sep : f'{sep}'.join(map(str,a)) #print=stdout.write def isPrime(n): if(n <= 1): return False if(n <= 3): return True if(n % 2 == 0 or n % 3 == 0): return False for i in range(5,int(math.sqrt(n) + 1), 6): if(n % i == 0 or n % (i + 2) == 0): return False return True def main(): n=int(input()) arr=listInput() c=arr[0] for i in range(1,n): c+=arr[i]+(arr[i]-1) print(c) if __name__ == "__main__": main()

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness". The test consists of *n* questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question *n*. Question *i* contains *a**i* answer variants, exactly one of them is correct. A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the *n* questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves. Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case? Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100). It is the number of questions in the test. The second line contains space-separated *n* positive integers *a**i* (1<=≤<=*a**i*<=≤<=109), the number of answer variants to question *i*. Output Specification: Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario. Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. Demo Input: ['2\n1 1\n', '2\n2 2\n', '1\n10\n'] Demo Output: ['2', '5', '10'] Note: Note to the second sample. In the worst-case scenario you will need five clicks: - the first click selects the first variant to the first question, this answer turns out to be wrong. - the second click selects the second variant to the first question, it proves correct and we move on to the second question; - the third click selects the first variant to the second question, it is wrong and we go back to question 1; - the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question; - the fifth click selects the second variant to the second question, it proves correct, the test is finished.

```python #Author : Zahin uddin #Github : https://github.com/Zahin52 from sys import * #import math #import queue input=stdin.readline listInput=lambda:list(map(int,input().strip().split())) lineInput= lambda:map(int,input().strip().split()) sJoin=lambda a,sep : f'{sep}'.join(a) arrJoin=lambda a,sep : f'{sep}'.join(map(str,a)) #print=stdout.write def isPrime(n): if(n <= 1): return False if(n <= 3): return True if(n % 2 == 0 or n % 3 == 0): return False for i in range(5,int(math.sqrt(n) + 1), 6): if(n % i == 0 or n % (i + 2) == 0): return False return True def main(): n=int(input()) arr=listInput() c=arr[0] for i in range(1,n): c+=arr[i]+(arr[i]-1) print(c) if __name__ == "__main__": main() ```

0

527

A

Playing with Paper

PROGRAMMING

1,100

[ "implementation", "math" ]

null

One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a square piece of paper from the rectangular sheet by folding the sheet along the bisector of the right angle, and cutting the excess part. After making a paper ship from the square piece, Vasya looked on the remaining (*a*<=-<=*b*) mm <=×<= *b* mm strip of paper. He got the idea to use this strip of paper in the same way to make an origami, and then use the remainder (if it exists) and so on. At the moment when he is left with a square piece of paper, he will make the last ship from it and stop. Can you determine how many ships Vasya will make during the lesson?

The first line of the input contains two integers *a*, *b* (1<=≤<=*b*<=<<=*a*<=≤<=1012) — the sizes of the original sheet of paper.

Print a single integer — the number of ships that Vasya will make.

[ "2 1\n", "10 7\n", "1000000000000 1\n" ]

[ "2\n", "6\n", "1000000000000\n" ]

Pictures to the first and second sample test.

500

[ { "input": "2 1", "output": "2" }, { "input": "10 7", "output": "6" }, { "input": "1000000000000 1", "output": "1000000000000" }, { "input": "3 1", "output": "3" }, { "input": "4 1", "output": "4" }, { "input": "3 2", "output": "3" }, { "input": "4 2", "output": "2" }, { "input": "1000 700", "output": "6" }, { "input": "959986566087 524054155168", "output": "90" }, { "input": "4 3", "output": "4" }, { "input": "7 6", "output": "7" }, { "input": "1000 999", "output": "1000" }, { "input": "1000 998", "output": "500" }, { "input": "1000 997", "output": "336" }, { "input": "42 1", "output": "42" }, { "input": "1000 1", "output": "1000" }, { "input": "8 5", "output": "5" }, { "input": "13 8", "output": "6" }, { "input": "987 610", "output": "15" }, { "input": "442 42", "output": "22" }, { "input": "754 466", "output": "13" }, { "input": "1000000000000 999999999999", "output": "1000000000000" }, { "input": "1000000000000 999999999998", "output": "500000000000" }, { "input": "941 14", "output": "74" }, { "input": "998 2", "output": "499" }, { "input": "1000 42", "output": "32" }, { "input": "1000 17", "output": "66" }, { "input": "5 1", "output": "5" }, { "input": "5 2", "output": "4" }, { "input": "5 3", "output": "4" }, { "input": "5 4", "output": "5" }, { "input": "293 210", "output": "17" }, { "input": "787878787878 424242424242", "output": "8" }, { "input": "956722026041 591286729879", "output": "58" }, { "input": "956722026041 365435296162", "output": "58" }, { "input": "628625247282 464807889701", "output": "102" }, { "input": "695928431619 424778620208", "output": "167" }, { "input": "1000000000000 42", "output": "23809523821" }, { "input": "987654345678 23", "output": "42941493300" }, { "input": "10000000001 2", "output": "5000000002" }, { "input": "1000000000000 2", "output": "500000000000" }, { "input": "1000000000000 3", "output": "333333333336" }, { "input": "100000000000 3", "output": "33333333336" }, { "input": "100000000000 23", "output": "4347826109" }, { "input": "999999999997 7", "output": "142857142861" }, { "input": "8589934592 4294967296", "output": "2" } ]

1,595,973,472

2,147,483,647

PyPy 3

OK

TESTS

46

140

20,172,800

a , b = map(int , input().split()) ans = 0 while b>0: n = a//b temp = b b = a-(n*b) a = temp ans += n print(ans)

Title: Playing with Paper Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a square piece of paper from the rectangular sheet by folding the sheet along the bisector of the right angle, and cutting the excess part. After making a paper ship from the square piece, Vasya looked on the remaining (*a*<=-<=*b*) mm <=×<= *b* mm strip of paper. He got the idea to use this strip of paper in the same way to make an origami, and then use the remainder (if it exists) and so on. At the moment when he is left with a square piece of paper, he will make the last ship from it and stop. Can you determine how many ships Vasya will make during the lesson? Input Specification: The first line of the input contains two integers *a*, *b* (1<=≤<=*b*<=<<=*a*<=≤<=1012) — the sizes of the original sheet of paper. Output Specification: Print a single integer — the number of ships that Vasya will make. Demo Input: ['2 1\n', '10 7\n', '1000000000000 1\n'] Demo Output: ['2\n', '6\n', '1000000000000\n'] Note: Pictures to the first and second sample test.

```python a , b = map(int , input().split()) ans = 0 while b>0: n = a//b temp = b b = a-(n*b) a = temp ans += n print(ans) ```

3

486

A

Calculating Function

PROGRAMMING

800

[ "implementation", "math" ]

null

For a positive integer *n* let's define a function *f*: *f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n* Your task is to calculate *f*(*n*) for a given integer *n*.

The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015).

Print *f*(*n*) in a single line.

[ "4\n", "5\n" ]

[ "2\n", "-3\n" ]

*f*(4) = - 1 + 2 - 3 + 4 = 2 *f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3

500

[ { "input": "4", "output": "2" }, { "input": "5", "output": "-3" }, { "input": "1000000000", "output": "500000000" }, { "input": "1000000001", "output": "-500000001" }, { "input": "1000000000000000", "output": "500000000000000" }, { "input": "100", "output": "50" }, { "input": "101", "output": "-51" }, { "input": "102", "output": "51" }, { "input": "103", "output": "-52" }, { "input": "104", "output": "52" }, { "input": "105", "output": "-53" }, { "input": "106", "output": "53" }, { "input": "107", "output": "-54" }, { "input": "108", "output": "54" }, { "input": "109", "output": "-55" }, { "input": "208170109961052", "output": "104085054980526" }, { "input": "46017661651072", "output": "23008830825536" }, { "input": "4018154546667", "output": "-2009077273334" }, { "input": "288565475053", "output": "-144282737527" }, { "input": "3052460231", "output": "-1526230116" }, { "input": "29906716", "output": "14953358" }, { "input": "87897701693326", "output": "43948850846663" }, { "input": "8240", "output": "4120" }, { "input": "577935", "output": "-288968" }, { "input": "62", "output": "31" }, { "input": "1", "output": "-1" }, { "input": "2", "output": "1" }, { "input": "9999999999999", "output": "-5000000000000" }, { "input": "1000000000000", "output": "500000000000" }, { "input": "99999999999999", "output": "-50000000000000" }, { "input": "999999999999999", "output": "-500000000000000" }, { "input": "42191359342", "output": "21095679671" }, { "input": "100000000000000", "output": "50000000000000" }, { "input": "145645214654154", "output": "72822607327077" }, { "input": "4294967296", "output": "2147483648" }, { "input": "3037000499", "output": "-1518500250" }, { "input": "10000000000001", "output": "-5000000000001" }, { "input": "100000017040846", "output": "50000008520423" }, { "input": "98979894985999", "output": "-49489947493000" } ]

1,696,435,934

2,147,483,647

PyPy 3

TIME_LIMIT_EXCEEDED

TESTS

2

1,000

1,228,800

a=int(input()) count=0 for i in range(1,a+1): if i%2==1: count+=-i else: count+=i print(count)

Title: Calculating Function Time Limit: None seconds Memory Limit: None megabytes Problem Description: For a positive integer *n* let's define a function *f*: *f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n* Your task is to calculate *f*(*n*) for a given integer *n*. Input Specification: The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015). Output Specification: Print *f*(*n*) in a single line. Demo Input: ['4\n', '5\n'] Demo Output: ['2\n', '-3\n'] Note: *f*(4) = - 1 + 2 - 3 + 4 = 2 *f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3

```python a=int(input()) count=0 for i in range(1,a+1): if i%2==1: count+=-i else: count+=i print(count) ```

0

47

B

Coins

PROGRAMMING

1,200

[ "implementation" ]

B. Coins

2

256

One day Vasya came across three Berland coins. They didn't have any numbers that's why Vasya didn't understand how their denominations differ. He supposed that if one coin is heavier than the other one, then it should be worth more. Vasya weighed all the three pairs of coins on pan balance scales and told you the results. Find out how the deminations of the coins differ or if Vasya has a mistake in the weighting results. No two coins are equal.

The input data contains the results of all the weighting, one result on each line. It is guaranteed that every coin pair was weighted exactly once. Vasya labelled the coins with letters «A», «B» and «C». Each result is a line that appears as (letter)(> or < sign)(letter). For example, if coin "A" proved lighter than coin "B", the result of the weighting is A<B.

It the results are contradictory, print Impossible. Otherwise, print without spaces the rearrangement of letters «A», «B» and «C» which represent the coins in the increasing order of their weights.

[ "A>B\nC<B\nA>C\n", "A<B\nB>C\nC>A\n" ]

[ "CBA", "ACB" ]

none

1,000

[ { "input": "A>B\nC<B\nA>C", "output": "CBA" }, { "input": "A<B\nB>C\nC>A", "output": "ACB" }, { "input": "A<C\nB<A\nB>C", "output": "Impossible" }, { "input": "A<B\nA<C\nB>C", "output": "ACB" }, { "input": "B>A\nC<B\nC>A", "output": "ACB" }, { "input": "A>B\nB>C\nC<A", "output": "CBA" }, { "input": "A>C\nA>B\nB<C", "output": "BCA" }, { "input": "C<B\nB>A\nA<C", "output": "ACB" }, { "input": "C<B\nA>B\nC<A", "output": "CBA" }, { "input": "C>B\nB>A\nA<C", "output": "ABC" }, { "input": "C<B\nB<A\nC>A", "output": "Impossible" }, { "input": "B<C\nC<A\nA>B", "output": "BCA" }, { "input": "A>B\nC<B\nC<A", "output": "CBA" }, { "input": "B>A\nC>B\nA>C", "output": "Impossible" }, { "input": "B<A\nC>B\nC>A", "output": "BAC" }, { "input": "A<B\nC>B\nA<C", "output": "ABC" }, { "input": "A<B\nC<A\nB<C", "output": "Impossible" }, { "input": "A>C\nC<B\nB>A", "output": "CAB" }, { "input": "C>A\nA<B\nB>C", "output": "ACB" }, { "input": "C>A\nC<B\nB>A", "output": "ACB" }, { "input": "B>C\nB>A\nA<C", "output": "ACB" }, { "input": "C<B\nC<A\nB<A", "output": "CBA" }, { "input": "A<C\nA<B\nB>C", "output": "ACB" }, { "input": "B>A\nA>C\nB>C", "output": "CAB" }, { "input": "B<A\nA<C\nC<B", "output": "Impossible" }, { "input": "A<C\nB>C\nA>B", "output": "Impossible" }, { "input": "B>A\nC<A\nC>B", "output": "Impossible" }, { "input": "A>C\nC>B\nB<A", "output": "BCA" }, { "input": "B<C\nB<A\nA>C", "output": "BCA" }, { "input": "A>B\nC>B\nA<C", "output": "BAC" }, { "input": "C<B\nC<A\nB<A", "output": "CBA" }, { "input": "A<C\nA>B\nB>C", "output": "Impossible" }, { "input": "B>A\nB>C\nA<C", "output": "ACB" }, { "input": "B>C\nC<A\nB<A", "output": "CBA" }, { "input": "C>A\nB>A\nB>C", "output": "ACB" }, { "input": "B<A\nB>C\nA<C", "output": "Impossible" }, { "input": "B<C\nA<B\nC>A", "output": "ABC" }, { "input": "C<B\nB>A\nA>C", "output": "CAB" }, { "input": "A>B\nC>A\nB<C", "output": "BAC" }, { "input": "A>B\nB>C\nC<A", "output": "CBA" }, { "input": "B>C\nC>A\nA>B", "output": "Impossible" }, { "input": "B<A\nB>C\nC<A", "output": "CBA" }, { "input": "C>B\nB>A\nC>A", "output": "ABC" }, { "input": "A>C\nA>B\nB>C", "output": "CBA" }, { "input": "B<C\nA>B\nA<C", "output": "BAC" }, { "input": "C>A\nC<B\nB>A", "output": "ACB" }, { "input": "C>B\nA<B\nC<A", "output": "Impossible" }, { "input": "A<C\nC<B\nA>B", "output": "Impossible" }, { "input": "B>C\nA<B\nA<C", "output": "ACB" }, { "input": "C>A\nA<B\nC>B", "output": "ABC" } ]

1,669,913,486

2,147,483,647

Python 3

OK

TESTS

50

92

102,400

from collections import defaultdict, Counter import itertools as it import random as rand s1 = input() s2 = input() s3 = input() w = defaultdict(int) def relax(s1, w): if s1[1] == '>': w[s1[0]]+=1 else: w[s1[2]]+=1 relax(s1, w) relax(s2, w) relax(s3, w) ss = sorted(w.values()) if ss == [1, 2]: res = [0,1,2] seen = set() for k,v in w.items(): if v == 2: res[2]=k else: res[1]=k seen.add(k) for c in "ABC": if c not in seen: res[0]=c print(''.join(res)) else: print("Impossible")

Title: Coins Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: One day Vasya came across three Berland coins. They didn't have any numbers that's why Vasya didn't understand how their denominations differ. He supposed that if one coin is heavier than the other one, then it should be worth more. Vasya weighed all the three pairs of coins on pan balance scales and told you the results. Find out how the deminations of the coins differ or if Vasya has a mistake in the weighting results. No two coins are equal. Input Specification: The input data contains the results of all the weighting, one result on each line. It is guaranteed that every coin pair was weighted exactly once. Vasya labelled the coins with letters «A», «B» and «C». Each result is a line that appears as (letter)(> or < sign)(letter). For example, if coin "A" proved lighter than coin "B", the result of the weighting is A<B. Output Specification: It the results are contradictory, print Impossible. Otherwise, print without spaces the rearrangement of letters «A», «B» and «C» which represent the coins in the increasing order of their weights. Demo Input: ['A>B\nC<B\nA>C\n', 'A<B\nB>C\nC>A\n'] Demo Output: ['CBA', 'ACB'] Note: none

```python from collections import defaultdict, Counter import itertools as it import random as rand s1 = input() s2 = input() s3 = input() w = defaultdict(int) def relax(s1, w): if s1[1] == '>': w[s1[0]]+=1 else: w[s1[2]]+=1 relax(s1, w) relax(s2, w) relax(s3, w) ss = sorted(w.values()) if ss == [1, 2]: res = [0,1,2] seen = set() for k,v in w.items(): if v == 2: res[2]=k else: res[1]=k seen.add(k) for c in "ABC": if c not in seen: res[0]=c print(''.join(res)) else: print("Impossible") ```

3.976809

346

A

Alice and Bob

PROGRAMMING

1,600

[ "games", "math", "number theory" ]

null

It is so boring in the summer holiday, isn't it? So Alice and Bob have invented a new game to play. The rules are as follows. First, they get a set of *n* distinct integers. And then they take turns to make the following moves. During each move, either Alice or Bob (the player whose turn is the current) can choose two distinct integers *x* and *y* from the set, such that the set doesn't contain their absolute difference |*x*<=-<=*y*|. Then this player adds integer |*x*<=-<=*y*| to the set (so, the size of the set increases by one). If the current player has no valid move, he (or she) loses the game. The question is who will finally win the game if both players play optimally. Remember that Alice always moves first.

The first line contains an integer *n* (2<=≤<=*n*<=≤<=100) — the initial number of elements in the set. The second line contains *n* distinct space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the elements of the set.

Print a single line with the winner's name. If Alice wins print "Alice", otherwise print "Bob" (without quotes).

[ "2\n2 3\n", "2\n5 3\n", "3\n5 6 7\n" ]

[ "Alice\n", "Alice\n", "Bob\n" ]

Consider the first test sample. Alice moves first, and the only move she can do is to choose 2 and 3, then to add 1 to the set. Next Bob moves, there is no valid move anymore, so the winner is Alice.

500

[ { "input": "2\n2 3", "output": "Alice" }, { "input": "2\n5 3", "output": "Alice" }, { "input": "3\n5 6 7", "output": "Bob" }, { "input": "10\n72 96 24 66 6 18 12 30 60 48", "output": "Bob" }, { "input": "10\n78 66 6 60 18 84 36 96 72 48", "output": "Bob" }, { "input": "10\n98 63 42 56 14 77 70 35 84 21", "output": "Bob" }, { "input": "2\n1 1000000000", "output": "Bob" }, { "input": "2\n1000000000 999999999", "output": "Bob" }, { "input": "3\n2 4 6", "output": "Bob" }, { "input": "2\n4 6", "output": "Alice" }, { "input": "2\n2 6", "output": "Alice" }, { "input": "2\n6 2", "output": "Alice" }, { "input": "10\n100000000 200000000 300000000 400000000 500000000 600000000 700000000 800000000 900000000 1000000000", "output": "Bob" }, { "input": "2\n1 2", "output": "Bob" }, { "input": "10\n1 999999999 999999998 999999997 999999996 999999995 999999994 999999993 999999992 999999991", "output": "Alice" }, { "input": "3\n6 14 21", "output": "Bob" }, { "input": "3\n4 12 18", "output": "Bob" }, { "input": "4\n2 3 15 30", "output": "Bob" }, { "input": "2\n10 4", "output": "Alice" } ]

1,696,756,054

2,147,483,647

PyPy 3-64

COMPILATION_ERROR

TESTS

0

for T in range(int(input()): n=int(input()) a=[int(i) for i in input().split()] b=max(a) if (b-n)%2==0:print("Bob") else : print("Alice")

Title: Alice and Bob Time Limit: None seconds Memory Limit: None megabytes Problem Description: It is so boring in the summer holiday, isn't it? So Alice and Bob have invented a new game to play. The rules are as follows. First, they get a set of *n* distinct integers. And then they take turns to make the following moves. During each move, either Alice or Bob (the player whose turn is the current) can choose two distinct integers *x* and *y* from the set, such that the set doesn't contain their absolute difference |*x*<=-<=*y*|. Then this player adds integer |*x*<=-<=*y*| to the set (so, the size of the set increases by one). If the current player has no valid move, he (or she) loses the game. The question is who will finally win the game if both players play optimally. Remember that Alice always moves first. Input Specification: The first line contains an integer *n* (2<=≤<=*n*<=≤<=100) — the initial number of elements in the set. The second line contains *n* distinct space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the elements of the set. Output Specification: Print a single line with the winner's name. If Alice wins print "Alice", otherwise print "Bob" (without quotes). Demo Input: ['2\n2 3\n', '2\n5 3\n', '3\n5 6 7\n'] Demo Output: ['Alice\n', 'Alice\n', 'Bob\n'] Note: Consider the first test sample. Alice moves first, and the only move she can do is to choose 2 and 3, then to add 1 to the set. Next Bob moves, there is no valid move anymore, so the winner is Alice.

```python for T in range(int(input()): n=int(input()) a=[int(i) for i in input().split()] b=max(a) if (b-n)%2==0:print("Bob") else : print("Alice") ```

-1

50

A

Domino piling

PROGRAMMING

800

[ "greedy", "math" ]

A. Domino piling

2

256

You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions: 1. Each domino completely covers two squares. 2. No two dominoes overlap. 3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board. Find the maximum number of dominoes, which can be placed under these restrictions.

In a single line you are given two integers *M* and *N* — board sizes in squares (1<=≤<=*M*<=≤<=*N*<=≤<=16).

Output one number — the maximal number of dominoes, which can be placed.

[ "2 4\n", "3 3\n" ]

[ "4\n", "4\n" ]

none

500

[ { "input": "2 4", "output": "4" }, { "input": "3 3", "output": "4" }, { "input": "1 5", "output": "2" }, { "input": "1 6", "output": "3" }, { "input": "1 15", "output": "7" }, { "input": "1 16", "output": "8" }, { "input": "2 5", "output": "5" }, { "input": "2 6", "output": "6" }, { "input": "2 7", "output": "7" }, { "input": "2 14", "output": "14" }, { "input": "2 15", "output": "15" }, { "input": "1 4", "output": "2" }, { "input": "2 16", "output": "16" }, { "input": "3 5", "output": "7" }, { "input": "3 6", "output": "9" }, { "input": "3 10", "output": "15" }, { "input": "3 14", "output": "21" }, { "input": "3 15", "output": "22" }, { "input": "3 16", "output": "24" }, { "input": "5 7", "output": "17" }, { "input": "16 16", "output": "128" }, { "input": "15 16", "output": "120" }, { "input": "2 3", "output": "3" }, { "input": "15 15", "output": "112" }, { "input": "14 16", "output": "112" }, { "input": "11 13", "output": "71" }, { "input": "5 16", "output": "40" }, { "input": "8 15", "output": "60" }, { "input": "2 2", "output": "2" }, { "input": "3 4", "output": "6" }, { "input": "4 4", "output": "8" }, { "input": "1 1", "output": "0" }, { "input": "1 2", "output": "1" }, { "input": "1 3", "output": "1" }, { "input": "14 15", "output": "105" } ]

1,632,112,662

2,147,483,647

Python 3

OK

TESTS

35

154

6,758,400

q = input() sList = q.split() product = int(sList[0])*int(sList[1]) print(product//2)

Title: Domino piling Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions: 1. Each domino completely covers two squares. 2. No two dominoes overlap. 3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board. Find the maximum number of dominoes, which can be placed under these restrictions. Input Specification: In a single line you are given two integers *M* and *N* — board sizes in squares (1<=≤<=*M*<=≤<=*N*<=≤<=16). Output Specification: Output one number — the maximal number of dominoes, which can be placed. Demo Input: ['2 4\n', '3 3\n'] Demo Output: ['4\n', '4\n'] Note: none

```python q = input() sList = q.split() product = int(sList[0])*int(sList[1]) print(product//2) ```

3.948911

476

A

Dreamoon and Stairs

PROGRAMMING

1,000

[ "implementation", "math" ]

null

Dreamoon wants to climb up a stair of *n* steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer *m*. What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition?

The single line contains two space separated integers *n*, *m* (0<=<<=*n*<=≤<=10000,<=1<=<<=*m*<=≤<=10).

Print a single integer — the minimal number of moves being a multiple of *m*. If there is no way he can climb satisfying condition print <=-<=1 instead.

[ "10 2\n", "3 5\n" ]

[ "6\n", "-1\n" ]

For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}. For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.

500

[ { "input": "10 2", "output": "6" }, { "input": "3 5", "output": "-1" }, { "input": "29 7", "output": "21" }, { "input": "2 2", "output": "2" }, { "input": "1 2", "output": "-1" }, { "input": "10000 2", "output": "5000" }, { "input": "10000 3", "output": "5001" }, { "input": "10000 10", "output": "5000" }, { "input": "9999 3", "output": "5001" }, { "input": "9999 2", "output": "5000" }, { "input": "9999 10", "output": "5000" }, { "input": "9999 9", "output": "5004" }, { "input": "18 10", "output": "10" }, { "input": "19 10", "output": "10" }, { "input": "20 10", "output": "10" }, { "input": "21 10", "output": "20" }, { "input": "7688 5", "output": "3845" }, { "input": "4608 5", "output": "2305" }, { "input": "3979 2", "output": "1990" }, { "input": "9985 6", "output": "4998" }, { "input": "3230 8", "output": "1616" }, { "input": "24 9", "output": "18" }, { "input": "3275 8", "output": "1640" }, { "input": "6240 7", "output": "3122" }, { "input": "5227 4", "output": "2616" }, { "input": "3832 6", "output": "1920" }, { "input": "4 2", "output": "2" }, { "input": "6 3", "output": "3" }, { "input": "10 5", "output": "5" }, { "input": "3 2", "output": "2" }, { "input": "6 4", "output": "4" }, { "input": "5 2", "output": "4" }, { "input": "8 2", "output": "4" }, { "input": "9 9", "output": "9" }, { "input": "4 5", "output": "-1" } ]

1,682,229,618

2,147,483,647

PyPy 3-64

RUNTIME_ERROR

TESTS

0

77

2,969,600

l = n // 2 ans = -1 flag = 0 for i in range(l,n + 1): if flag == 1: break for j in range(i,2*i + 1): if j == n and i % m == 0: ans = i flag = 1 break print(ans)

Title: Dreamoon and Stairs Time Limit: None seconds Memory Limit: None megabytes Problem Description: Dreamoon wants to climb up a stair of *n* steps. He can climb 1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer *m*. What is the minimal number of moves making him climb to the top of the stairs that satisfies his condition? Input Specification: The single line contains two space separated integers *n*, *m* (0<=<<=*n*<=≤<=10000,<=1<=<<=*m*<=≤<=10). Output Specification: Print a single integer — the minimal number of moves being a multiple of *m*. If there is no way he can climb satisfying condition print <=-<=1 instead. Demo Input: ['10 2\n', '3 5\n'] Demo Output: ['6\n', '-1\n'] Note: For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}. For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.

```python l = n // 2 ans = -1 flag = 0 for i in range(l,n + 1): if flag == 1: break for j in range(i,2*i + 1): if j == n and i % m == 0: ans = i flag = 1 break print(ans) ```

-1

1

A

Theatre Square

PROGRAMMING

1,000

[ "math" ]

A. Theatre Square

1

256

Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size *a*<=×<=*a*. What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.

The input contains three positive integer numbers in the first line: *n*,<=<=*m* and *a* (1<=≤<=<=*n*,<=*m*,<=*a*<=≤<=109).

Write the needed number of flagstones.

[ "6 6 4\n" ]

[ "4\n" ]

none

0

[ { "input": "6 6 4", "output": "4" }, { "input": "1 1 1", "output": "1" }, { "input": "2 1 1", "output": "2" }, { "input": "1 2 1", "output": "2" }, { "input": "2 2 1", "output": "4" }, { "input": "2 1 2", "output": "1" }, { "input": "1 1 3", "output": "1" }, { "input": "2 3 4", "output": "1" }, { "input": "1000000000 1000000000 1", "output": "1000000000000000000" }, { "input": "12 13 4", "output": "12" }, { "input": "222 332 5", "output": "3015" }, { "input": "1000 1000 10", "output": "10000" }, { "input": "1001 1000 10", "output": "10100" }, { "input": "100 10001 1000000000", "output": "1" }, { "input": "1000000000 1000000000 1000000000", "output": "1" }, { "input": "1000000000 1000000000 999999999", "output": "4" }, { "input": "1000000000 1000000000 192", "output": "27126743055556" }, { "input": "1000000000 987654321 1", "output": "987654321000000000" }, { "input": "456784567 1000000000 51", "output": "175618850864484" }, { "input": "39916800 134217728 40320", "output": "3295710" } ]

1,691,824,888

2,147,483,647

Python 3

OK

TESTS

20

31

0

n, m, a = map(int, input().split()) side1 = n % a side2 = m % a if side1 != 0: val1 = n // a + 1 else: val1 = n // a if side2 != 0: val2 = m // a + 1 else: val2 = m // a print(val1 * val2)

Title: Theatre Square Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Theatre Square in the capital city of Berland has a rectangular shape with the size *n*<=×<=*m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size *a*<=×<=*a*. What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square. Input Specification: The input contains three positive integer numbers in the first line: *n*,<=<=*m* and *a* (1<=≤<=<=*n*,<=*m*,<=*a*<=≤<=109). Output Specification: Write the needed number of flagstones. Demo Input: ['6 6 4\n'] Demo Output: ['4\n'] Note: none

```python n, m, a = map(int, input().split()) side1 = n % a side2 = m % a if side1 != 0: val1 = n // a + 1 else: val1 = n // a if side2 != 0: val2 = m // a + 1 else: val2 = m // a print(val1 * val2) ```

3.9845

764

B

Timofey and cubes

PROGRAMMING

900

[ "constructive algorithms", "implementation" ]

null

Young Timofey has a birthday today! He got kit of *n* cubes as a birthday present from his parents. Every cube has a number *a**i*, which is written on it. Timofey put all the cubes in a row and went to unpack other presents. In this time, Timofey's elder brother, Dima reordered the cubes using the following rule. Suppose the cubes are numbered from 1 to *n* in their order. Dima performs several steps, on step *i* he reverses the segment of cubes from *i*-th to (*n*<=-<=*i*<=+<=1)-th. He does this while *i*<=≤<=*n*<=-<=*i*<=+<=1. After performing the operations Dima went away, being very proud of himself. When Timofey returned to his cubes, he understood that their order was changed. Help Timofey as fast as you can and save the holiday — restore the initial order of the cubes using information of their current location.

The first line contains single integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of cubes. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109), where *a**i* is the number written on the *i*-th cube after Dima has changed their order.

Print *n* integers, separated by spaces — the numbers written on the cubes in their initial order. It can be shown that the answer is unique.

[ "7\n4 3 7 6 9 1 2\n", "8\n6 1 4 2 5 6 9 2\n" ]

[ "2 3 9 6 7 1 4", "2 1 6 2 5 4 9 6" ]

Consider the first sample. 1. At the begining row was [2, 3, 9, 6, 7, 1, 4]. 1. After first operation row was [4, 1, 7, 6, 9, 3, 2]. 1. After second operation row was [4, 3, 9, 6, 7, 1, 2]. 1. After third operation row was [4, 3, 7, 6, 9, 1, 2]. 1. At fourth operation we reverse just middle element, so nothing has changed. The final row is [4, 3, 7, 6, 9, 1, 2]. So the answer for this case is row [2, 3, 9, 6, 7, 1, 4].

1,000

[ { "input": "7\n4 3 7 6 9 1 2", "output": "2 3 9 6 7 1 4" }, { "input": "8\n6 1 4 2 5 6 9 2", "output": "2 1 6 2 5 4 9 6" }, { "input": "1\n1424", "output": "1424" }, { "input": "9\n-7 9 -4 9 -6 11 15 2 -10", "output": "-10 9 15 9 -6 11 -4 2 -7" }, { "input": "2\n21968 5686", "output": "5686 21968" }, { "input": "5\n241218936 -825949895 -84926813 491336344 -872198236", "output": "-872198236 -825949895 -84926813 491336344 241218936" }, { "input": "42\n-557774624 828320986 -345782722 -62979938 -681259411 -945983652 -139095040 832293378 -82572118 432027535 88438103 568183540 961782904 73543295 615958219 -5050584 322982437 -146046730 759453379 129267920 -819827396 -348156048 805080102 390723009 -771277251 -79011872 -592313207 528489973 656201270 -127795621 17284747 145139617 -565641608 83452176 -223074608 545811186 -657981923 -204657836 154779765 -476867246 180386291 202782486", "output": "202782486 828320986 -476867246 -62979938 -204657836 -945983652 545811186 832293378 83452176 432027535 145139617 568183540 -127795621 73543295 528489973 -5050584 -79011872 -146046730 390723009 129267920 -348156048 -819827396 805080102 759453379 -771277251 322982437 -592313207 615958219 656201270 961782904 17284747 88438103 -565641608 -82572118 -223074608 -139095040 -657981923 -681259411 154779765 -345782722 180386291 -557774624" }, { "input": "2\n1 2", "output": "2 1" }, { "input": "6\n1 2 3 4 5 6", "output": "6 2 4 3 5 1" }, { "input": "4\n0 1 2 3", "output": "3 1 2 0" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "10 2 8 4 6 5 7 3 9 1" }, { "input": "2\n4 5", "output": "5 4" }, { "input": "2\n1 5", "output": "5 1" }, { "input": "2\n2 5", "output": "5 2" }, { "input": "2\n3 4", "output": "4 3" }, { "input": "2\n10 0", "output": "0 10" }, { "input": "66\n8229 5299 5562 1259 2258 1126 5026 8796 3497 7111 6680 1180 1426 4821 3322 3502 400 2951 4187 417 5234 1266 7525 7648 417 9297 174 670 1790 4121 9737 938 4616 3402 2009 2461 474 3728 327 3353 9773 6818 8781 874 2209 1260 1647 6126 9287 9638 5049 1256 4459 863 1835 4822 6809 348 5053 7784 6927 2140 9173 7817 5095 4184", "output": "4184 5299 7817 1259 2140 1126 7784 8796 348 7111 4822 1180 863 4821 1256 3502 9638 2951 6126 417 1260 1266 874 7648 6818 9297 3353 670 3728 4121 2461 938 3402 4616 2009 9737 474 1790 327 174 9773 417 8781 7525 2209 5234 1647 4187 9287 400 5049 3322 4459 1426 1835 6680 6809 3497 5053 5026 6927 2258 9173 5562 5095 8229" } ]

1,643,106,451

2,147,483,647

PyPy 3

OK

TESTS

34

436

22,835,200

n=int(input()) A=list(map(int,input().split())) for i in range(0,n//2,2): A[i],A[n-i-1]=A[n-i-1],A[i] print(*A)

Title: Timofey and cubes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Young Timofey has a birthday today! He got kit of *n* cubes as a birthday present from his parents. Every cube has a number *a**i*, which is written on it. Timofey put all the cubes in a row and went to unpack other presents. In this time, Timofey's elder brother, Dima reordered the cubes using the following rule. Suppose the cubes are numbered from 1 to *n* in their order. Dima performs several steps, on step *i* he reverses the segment of cubes from *i*-th to (*n*<=-<=*i*<=+<=1)-th. He does this while *i*<=≤<=*n*<=-<=*i*<=+<=1. After performing the operations Dima went away, being very proud of himself. When Timofey returned to his cubes, he understood that their order was changed. Help Timofey as fast as you can and save the holiday — restore the initial order of the cubes using information of their current location. Input Specification: The first line contains single integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of cubes. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109), where *a**i* is the number written on the *i*-th cube after Dima has changed their order. Output Specification: Print *n* integers, separated by spaces — the numbers written on the cubes in their initial order. It can be shown that the answer is unique. Demo Input: ['7\n4 3 7 6 9 1 2\n', '8\n6 1 4 2 5 6 9 2\n'] Demo Output: ['2 3 9 6 7 1 4', '2 1 6 2 5 4 9 6'] Note: Consider the first sample. 1. At the begining row was [2, 3, 9, 6, 7, 1, 4]. 1. After first operation row was [4, 1, 7, 6, 9, 3, 2]. 1. After second operation row was [4, 3, 9, 6, 7, 1, 2]. 1. After third operation row was [4, 3, 7, 6, 9, 1, 2]. 1. At fourth operation we reverse just middle element, so nothing has changed. The final row is [4, 3, 7, 6, 9, 1, 2]. So the answer for this case is row [2, 3, 9, 6, 7, 1, 4].

```python n=int(input()) A=list(map(int,input().split())) for i in range(0,n//2,2): A[i],A[n-i-1]=A[n-i-1],A[i] print(*A) ```

3

349

B

Color the Fence

PROGRAMMING

1,700

[ "data structures", "dp", "greedy", "implementation" ]

null

Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has. Unfortunately, Igor could only get *v* liters of paint. He did the math and concluded that digit *d* requires *a**d* liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number. Help Igor find the maximum number he can write on the fence.

The first line contains a positive integer *v* (0<=≤<=*v*<=≤<=106). The second line contains nine positive integers *a*1,<=*a*2,<=...,<=*a*9 (1<=≤<=*a**i*<=≤<=105).

Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.

[ "5\n5 4 3 2 1 2 3 4 5\n", "2\n9 11 1 12 5 8 9 10 6\n", "0\n1 1 1 1 1 1 1 1 1\n" ]

[ "55555\n", "33\n", "-1\n" ]

none

1,000

[ { "input": "5\n5 4 3 2 1 2 3 4 5", "output": "55555" }, { "input": "2\n9 11 1 12 5 8 9 10 6", "output": "33" }, { "input": "0\n1 1 1 1 1 1 1 1 1", "output": "-1" }, { "input": "50\n5 3 10 2 2 4 3 6 5", "output": "5555555555555555555555555" }, { "input": "22\n405 343 489 474 385 23 100 94 276", "output": "-1" }, { "input": "62800\n867 936 2 888 474 530 287 822 220", "output": "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333..." }, { "input": "27\n836 637 966 929 82 678 213 465 688", "output": "-1" }, { "input": "1000000\n100000 100000 100000 100000 100000 100000 100000 100000 100000", "output": "9999999999" }, { "input": "898207\n99745 99746 99748 99752 99760 99776 99808 99872 100000", "output": "987654321" }, { "input": "80910\n64537 83748 97081 82722 12334 3056 9491 59130 28478", "output": "66666666666666666666666666" }, { "input": "120081\n11268 36403 73200 12674 83919 74218 74172 91581 68432", "output": "4444411111" }, { "input": "839851\n29926 55862 57907 51153 56350 86145 1909 22622 89861", "output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777" }, { "input": "751233\n69761 51826 91095 73642 98995 93262 377 38818 97480", "output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..." }, { "input": "306978\n95955 99204 81786 41258 96065 46946 64532 36297 70808", "output": "88888888" }, { "input": "366313\n18486 12701 92334 95391 61480 14118 20465 69784 13592", "output": "9999999999922222222222222222" }, { "input": "320671\n95788 46450 97582 95928 47742 15508 10466 10301 38822", "output": "8888888888888888888888888888888" }, { "input": "913928\n80373 47589 53204 68236 44060 97485 82241 44149 59825", "output": "99888888888888855555" }, { "input": "630384\n19652 11530 20316 3161 87360 64207 74067 77894 81452", "output": "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444" }, { "input": "95\n22076 12056 63350 12443 43123 585 52908 18372 96799", "output": "-1" }, { "input": "271380\n19135 80309 23783 48534 98990 37278 85258 67602 40288", "output": "11111111111111" }, { "input": "80085\n56973 29725 30219 17439 53162 6051 41388 35555 39392", "output": "6666666666666" }, { "input": "201332\n20008 22829 30296 1967 32154 67760 11437 90972 79865", "output": "444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444" }, { "input": "3402\n64151 98148 81468 82342 48823 93464 5989 58868 77138", "output": "-1" }, { "input": "432544\n95724 98294 23292 24174 57778 95072 81898 50019 86824", "output": "444444444444444333" }, { "input": "1000000\n1 1 1 1 1 1 1 1 1", "output": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999..." }, { "input": "1000000\n2 2 2 2 2 2 2 2 2", "output": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999..." }, { "input": "1000000\n2 3 2 2 3 2 2 3 2", "output": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999..." }, { "input": "999999\n2 3 2 2 3 2 2 3 3", "output": "9777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777..." }, { "input": "153\n85 91 28 53 29 30 92 36 89", "output": "86653" }, { "input": "26531\n64 93 48 49 86 57 93 60 96", "output": "8864433333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333..." }, { "input": "17186\n50 90 76 51 91 54 71 90 73", "output": "9666411111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" }, { "input": "11213\n51 82 49 50 99 52 69 96 85", "output": "964433333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333" }, { "input": "20075\n57 42 99 45 56 80 76 71 63", "output": "954422222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222" }, { "input": "21069\n31 19 49 30 28 43 21 25 28", "output": "9872222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222..." }, { "input": "4822\n35 36 21 13 34 36 14 16 20", "output": "9877444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444" } ]

1,610,910,094

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

124

0

def solve(): v = int(input()) a = list(map(int, input().split())) minA = min(a) if v == 0 or minA > v: return -1 f = v // minA number = a.index(minA) ans = str(number + 1) return ans * f def main(): print(solve()) if __name__ == "__main__": main()

Title: Color the Fence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has. Unfortunately, Igor could only get *v* liters of paint. He did the math and concluded that digit *d* requires *a**d* liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number. Help Igor find the maximum number he can write on the fence. Input Specification: The first line contains a positive integer *v* (0<=≤<=*v*<=≤<=106). The second line contains nine positive integers *a*1,<=*a*2,<=...,<=*a*9 (1<=≤<=*a**i*<=≤<=105). Output Specification: Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1. Demo Input: ['5\n5 4 3 2 1 2 3 4 5\n', '2\n9 11 1 12 5 8 9 10 6\n', '0\n1 1 1 1 1 1 1 1 1\n'] Demo Output: ['55555\n', '33\n', '-1\n'] Note: none

```python def solve(): v = int(input()) a = list(map(int, input().split())) minA = min(a) if v == 0 or minA > v: return -1 f = v // minA number = a.index(minA) ans = str(number + 1) return ans * f def main(): print(solve()) if __name__ == "__main__": main() ```

0

451

A

Game With Sticks

PROGRAMMING

900

[ "implementation" ]

null

After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of *n* horizontal and *m* vertical sticks. An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick. In the grid shown below, *n*<==<=3 and *m*<==<=3. There are *n*<=+<=*m*<==<=6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are *n*·*m*<==<=9 intersection points, numbered from 1 to 9. The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move). Assume that both players play optimally. Who will win the game?

The first line of input contains two space-separated integers, *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100).

Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.

[ "2 2\n", "2 3\n", "3 3\n" ]

[ "Malvika\n", "Malvika\n", "Akshat\n" ]

Explanation of the first sample: The grid has four intersection points, numbered from 1 to 4. If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this. Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty. In the empty grid, Akshat cannot make any move, hence he will lose. Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.

500

[ { "input": "2 2", "output": "Malvika" }, { "input": "2 3", "output": "Malvika" }, { "input": "3 3", "output": "Akshat" }, { "input": "20 68", "output": "Malvika" }, { "input": "1 1", "output": "Akshat" }, { "input": "1 2", "output": "Akshat" }, { "input": "1 3", "output": "Akshat" }, { "input": "2 1", "output": "Akshat" }, { "input": "2 2", "output": "Malvika" }, { "input": "3 1", "output": "Akshat" }, { "input": "3 2", "output": "Malvika" }, { "input": "68 42", "output": "Malvika" }, { "input": "1 35", "output": "Akshat" }, { "input": "25 70", "output": "Akshat" }, { "input": "59 79", "output": "Akshat" }, { "input": "65 63", "output": "Akshat" }, { "input": "46 6", "output": "Malvika" }, { "input": "28 82", "output": "Malvika" }, { "input": "98 98", "output": "Malvika" }, { "input": "98 99", "output": "Malvika" }, { "input": "98 100", "output": "Malvika" }, { "input": "99 98", "output": "Malvika" }, { "input": "99 99", "output": "Akshat" }, { "input": "99 100", "output": "Akshat" }, { "input": "100 98", "output": "Malvika" }, { "input": "100 99", "output": "Akshat" }, { "input": "100 100", "output": "Malvika" }, { "input": "3 4", "output": "Akshat" } ]

1,687,253,539

2,147,483,647

Python 3

OK

TESTS

28

46

0

a = input().split(" ") if min(int(a[0]), int(a[1])) % 2 == 0: print("Malvika") else: print("Akshat")

Title: Game With Sticks Time Limit: None seconds Memory Limit: None megabytes Problem Description: After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of *n* horizontal and *m* vertical sticks. An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick. In the grid shown below, *n*<==<=3 and *m*<==<=3. There are *n*<=+<=*m*<==<=6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are *n*·*m*<==<=9 intersection points, numbered from 1 to 9. The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move). Assume that both players play optimally. Who will win the game? Input Specification: The first line of input contains two space-separated integers, *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100). Output Specification: Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game. Demo Input: ['2 2\n', '2 3\n', '3 3\n'] Demo Output: ['Malvika\n', 'Malvika\n', 'Akshat\n'] Note: Explanation of the first sample: The grid has four intersection points, numbered from 1 to 4. If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this. Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty. In the empty grid, Akshat cannot make any move, hence he will lose. Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.

```python a = input().split(" ") if min(int(a[0]), int(a[1])) % 2 == 0: print("Malvika") else: print("Akshat") ```

3

474

A

Keyboard

PROGRAMMING

900

[ "implementation" ]

null

Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way: Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately. He accidentally moved both his hands with one position to the left or to the right. That means that now he presses not a button he wants, but one neighboring button (left or right, as specified in input). We have a sequence of characters he has typed and we want to find the original message.

First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right). Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain spaces as there is no space on Mole's keyboard. It is guaranteed that even though Mole hands are moved, he is still pressing buttons on keyboard and not hitting outside it.

Print a line that contains the original message.

[ "R\ns;;upimrrfod;pbr\n" ]

[ "allyouneedislove\n" ]

none

500

[ { "input": "R\ns;;upimrrfod;pbr", "output": "allyouneedislove" }, { "input": "R\nwertyuiop;lkjhgfdsxcvbnm,.", "output": "qwertyuiolkjhgfdsazxcvbnm," }, { "input": "L\nzxcvbnm,kjhgfdsaqwertyuio", "output": "xcvbnm,.lkjhgfdswertyuiop" }, { "input": "R\nbubbuduppudup", "output": "vyvvysyooysyo" }, { "input": "L\ngggggggggggggggggggggggggggggggggggggggggg", "output": "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh" }, { "input": "R\ngggggggggggggggggggggggggggggggggggggggggg", "output": "ffffffffffffffffffffffffffffffffffffffffff" }, { "input": "L\nggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg", "output": "hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh" }, { "input": "R\nggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg", "output": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" }, { "input": "L\nxgwurenkxkiau,c,vonei.zltazmnkhqtwuogkgvgckvja,z.rhanuy.ybebmzcfwozkwvuuiolaqlgvvvewnbuinrncgjwjdsfw", "output": "cheitrmlclosi.v.bpmro/x;ysx,mljwyeiphlhbhvlbks.x/tjsmiu/unrn,xvgepxlebiiop;sw;hbbbremniomtmvhkekfdge" }, { "input": "L\nuoz.vmks,wxrb,nwcvdzh.m,hwsios.lvu,ktes,,ythddhm.sh,d,c,cfj.wqam,bowofbyx,jathqayhreqvixvbmgdokofmym", "output": "ipx/b,ld.ectn.mevbfxj/,.jedopd/;bi.lyrd..uyjffj,/dj.f.v.vgk/ews,.npepgnuc.ksyjwsujtrwbocbn,hfplpg,u," }, { "input": "R\noedjyrvuw/rn.v.hdwndbiposiewgsn.pnyf;/tsdohp,hrtd/mx,;coj./billd..mwbneohcikrdes/ucjr,wspthleyp,..f,", "output": "iwshtecyq.eb,c,gsqbsvuoiauwqfab,obtdl.rasigomgers.nzmlxih,.vukks,,nqvbwigxujeswa.yxhemqaorgkwtom,,dm" }, { "input": "R\nvgj;o;ijrtfyck,dthccioltcx,crub;oceooognsuvfx/kgo.fbsudv,yod.erdrxhbeiyltxhnrobbb;ydrgroefcr/f;uvdjd", "output": "cfhliluherdtxjmsrgxxuikrxzmxeyvlixwiiifbaycdz.jfi,dvayscmtis,wesezgvwutkrzgbeivvvltsefeiwdxe.dlycshs" }, { "input": "L\nqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq", "output": "wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww" }, { "input": "L\noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo", "output": "pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp" }, { "input": "L\n,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", "output": "...................................................................................................." }, { "input": "L\nzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" }, { "input": "R\noooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo", "output": "iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii" }, { "input": "R\nwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww", "output": "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq" }, { "input": "R\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "output": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" }, { "input": "L\nq", "output": "w" }, { "input": "L\no", "output": "p" }, { "input": "L\n,", "output": "." }, { "input": "L\nz", "output": "x" }, { "input": "R\n.", "output": "," }, { "input": "R\no", "output": "i" }, { "input": "R\nw", "output": "q" }, { "input": "R\nx", "output": "z" }, { "input": "R\n,./", "output": "m,." }, { "input": "R\nwertuk;;/", "output": "qweryjll." }, { "input": "L\n..", "output": "//" } ]

1,674,927,204

2,147,483,647

Python 3

OK

TESTS

31

46

0

k = [[col for col in row] for row in "qwertyuiop#asdfghjkl;#zxcvbnm,./".split("#")] def main(): s = input() t = input() res = "" for i in range(len(t)): # Iterate over the keyboard for row in range(len(k)): for col in range(len(k[row])): if k[row][col] == t[i]: res += k[row][col-1] if s == "R" else k[row][col+1] print(res) if __name__ == "__main__": main()

Title: Keyboard Time Limit: None seconds Memory Limit: None megabytes Problem Description: Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way: Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately. He accidentally moved both his hands with one position to the left or to the right. That means that now he presses not a button he wants, but one neighboring button (left or right, as specified in input). We have a sequence of characters he has typed and we want to find the original message. Input Specification: First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right). Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain spaces as there is no space on Mole's keyboard. It is guaranteed that even though Mole hands are moved, he is still pressing buttons on keyboard and not hitting outside it. Output Specification: Print a line that contains the original message. Demo Input: ['R\ns;;upimrrfod;pbr\n'] Demo Output: ['allyouneedislove\n'] Note: none

```python k = [[col for col in row] for row in "qwertyuiop#asdfghjkl;#zxcvbnm,./".split("#")] def main(): s = input() t = input() res = "" for i in range(len(t)): # Iterate over the keyboard for row in range(len(k)): for col in range(len(k[row])): if k[row][col] == t[i]: res += k[row][col-1] if s == "R" else k[row][col+1] print(res) if __name__ == "__main__": main() ```

3

112

A

Petya and Strings

PROGRAMMING

800

[ "implementation", "strings" ]

A. Petya and Strings

2

256

Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. The letters' case does not matter, that is an uppercase letter is considered equivalent to the corresponding lowercase letter. Help Petya perform the comparison.

Each of the first two lines contains a bought string. The strings' lengths range from 1 to 100 inclusive. It is guaranteed that the strings are of the same length and also consist of uppercase and lowercase Latin letters.

If the first string is less than the second one, print "-1". If the second string is less than the first one, print "1". If the strings are equal, print "0". Note that the letters' case is not taken into consideration when the strings are compared.

[ "aaaa\naaaA\n", "abs\nAbz\n", "abcdefg\nAbCdEfF\n" ]

[ "0\n", "-1\n", "1\n" ]

If you want more formal information about the lexicographical order (also known as the "dictionary order" or "alphabetical order"), you can visit the following site: - http://en.wikipedia.org/wiki/Lexicographical_order

500

[ { "input": "aaaa\naaaA", "output": "0" }, { "input": "abs\nAbz", "output": "-1" }, { "input": "abcdefg\nAbCdEfF", "output": "1" }, { "input": "asadasdasd\nasdwasdawd", "output": "-1" }, { "input": "aslkjlkasdd\nasdlkjdajwi", "output": "1" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "0" }, { "input": "aAaaaAAaAaaAzZsssSsdDfeEaeqZlpP\nAaaaAaaAaaAaZzSSSSsDdFeeAeQZLpp", "output": "0" }, { "input": "bwuEhEveouaTECagLZiqmUdxEmhRSOzMauJRWLQMppZOumxhAmwuGeDIkvkBLvMXwUoFmpAfDprBcFtEwOULcZWRQhcTbTbX\nHhoDWbcxwiMnCNexOsKsujLiSGcLllXOkRSbnOzThAjnnliLYFFmsYkOfpTxRNEfBsoUHfoLTiqAINRPxWRqrTJhgfkKcDOH", "output": "-1" }, { "input": "kGWUuguKzcvxqKTNpxeDWXpXkrXDvGMFGoXKDfPBZvWSDUyIYBynbKOUonHvmZaKeirUhfmVRKtGhAdBfKMWXDUoqvbfpfHYcg\ncvOULleuIIiYVVxcLZmHVpNGXuEpzcWZZWyMOwIwbpkKPwCfkVbKkUuosvxYCKjqfVmHfJKbdrsAcatPYgrCABaFcoBuOmMfFt", "output": "1" }, { "input": "nCeNVIzHqPceNhjHeHvJvgBsNFiXBATRrjSTXJzhLMDMxiJztphxBRlDlqwDFImWeEPkggZCXSRwelOdpNrYnTepiOqpvkr\nHJbjJFtlvNxIbkKlxQUwmZHJFVNMwPAPDRslIoXISBYHHfymyIaQHLgECPxAmqnOCizwXnIUBRmpYUBVPenoUKhCobKdOjL", "output": "1" }, { "input": "ttXjenUAlfixytHEOrPkgXmkKTSGYuyVXGIHYmWWYGlBYpHkujueqBSgjLguSgiMGJWATIGEUjjAjKXdMiVbHozZUmqQtFrT\nJziDBFBDmDJCcGqFsQwDFBYdOidLxxhBCtScznnDgnsiStlWFnEXQrJxqTXKPxZyIGfLIToETKWZBPUIBmLeImrlSBWCkTNo", "output": "1" }, { "input": "AjQhPqSVhwQQjcgCycjKorWBgFCRuQBwgdVuAPSMJAvTyxGVuFHjfJzkKfsmfhFbKqFrFIohSZBbpjgEHebezmVlGLTPSCTMf\nXhxWuSnMmKFrCUOwkTUmvKAfbTbHWzzOTzxJatLLCdlGnHVaBUnxDlsqpvjLHMThOPAFBggVKDyKBrZAmjnjrhHlrnSkyzBja", "output": "-1" }, { "input": "HCIgYtnqcMyjVngziNflxKHtdTmcRJhzMAjFAsNdWXFJYEhiTzsQUtFNkAbdrFBRmvLirkuirqTDvIpEfyiIqkrwsjvpPWTEdI\nErqiiWKsmIjyZuzgTlTqxYZwlrpvRyaVhRTOYUqtPMVGGtWOkDCOOQRKrkkRzPftyQCkYkzKkzTPqqXmeZhvvEEiEhkdOmoMvy", "output": "1" }, { "input": "mtBeJYILXcECGyEVSyzLFdQJbiVnnfkbsYYsdUJSIRmyzLfTTtFwIBmRLVnwcewIqcuydkcLpflHAFyDaToLiFMgeHvQorTVbI\nClLvyejznjbRfCDcrCzkLvqQaGzTjwmWONBdCctJAPJBcQrcYvHaSLQgPIJbmkFBhFzuQLBiRzAdNHulCjIAkBvZxxlkdzUWLR", "output": "1" }, { "input": "tjucSbGESVmVridTBjTmpVBCwwdWKBPeBvmgdxgIVLwQxveETnSdxkTVJpXoperWSgdpPMKNmwDiGeHfxnuqaDissgXPlMuNZIr\nHfjOOJhomqNIKHvqSgfySjlsWJQBuWYwhLQhlZYlpZwboMpoLoluGsBmhhlYgeIouwdkPfiaAIrkYRlxtiFazOPOllPsNZHcIZd", "output": "1" }, { "input": "AanbDfbZNlUodtBQlvPMyomStKNhgvSGhSbTdabxGFGGXCdpsJDimsAykKjfBDPMulkhBMsqLmVKLDoesHZsRAEEdEzqigueXInY\ncwfyjoppiJNrjrOLNZkqcGimrpTsiyFBVgMWEPXsMrxLJDDbtYzerXiFGuLBcQYitLdqhGHBpdjRnkUegmnwhGHAKXGyFtscWDSI", "output": "-1" }, { "input": "HRfxniwuJCaHOcaOVgjOGHXKrwxrDQxJpppeGDXnTAowyKbCsCQPbchCKeTWOcKbySSYnoaTJDnmRcyGPbfXJyZoPcARHBu\nxkLXvwkvGIWSQaFTznLOctUXNuzzBBOlqvzmVfTSejekTAlwidRrsxkbZTsGGeEWxCXHzqWVuLGoCyrGjKkQoHqduXwYQKC", "output": "-1" }, { "input": "OjYwwNuPESIazoyLFREpObIaMKhCaKAMWMfRGgucEuyNYRantwdwQkmflzfqbcFRaXBnZoIUGsFqXZHGKwlaBUXABBcQEWWPvkjW\nRxLqGcTTpBwHrHltCOllnTpRKLDofBUqqHxnOtVWPgvGaeHIevgUSOeeDOJubfqonFpVNGVbHFcAhjnyFvrrqnRgKhkYqQZmRfUl", "output": "-1" }, { "input": "tatuhQPIzjptlzzJpCAPXSRTKZRlwgfoCIsFjJquRoIDyZZYRSPdFUTjjUPhLBBfeEIfLQpygKXRcyQFiQsEtRtLnZErBqW\ntkHUjllbafLUWhVCnvblKjgYIEoHhsjVmrDBmAWbvtkHxDbRFvsXAjHIrujaDbYwOZmacknhZPeCcorbRgHjjgAgoJdjvLo", "output": "-1" }, { "input": "cymCPGqdXKUdADEWDdUaLEEMHiXHsdAZuDnJDMUvxvrLRBrPSDpXPAgMRoGplLtniFRTomDTAHXWAdgUveTxaqKVSvnOyhOwiRN\nuhmyEWzapiRNPFDisvHTbenXMfeZaHqOFlKjrfQjUBwdFktNpeiRoDWuBftZLcCZZAVfioOihZVNqiNCNDIsUdIhvbcaxpTRWoV", "output": "-1" }, { "input": "sSvpcITJAwghVfJaLKBmyjOkhltTGjYJVLWCYMFUomiJaKQYhXTajvZVHIMHbyckYROGQZzjWyWCcnmDmrkvTKfHSSzCIhsXgEZa\nvhCXkCwAmErGVBPBAnkSYEYvseFKbWSktoqaHYXUmYkHfOkRwuEyBRoGoBrOXBKVxXycjZGStuvDarnXMbZLWrbjrisDoJBdSvWJ", "output": "-1" }, { "input": "hJDANKUNBisOOINDsTixJmYgHNogtpwswwcvVMptfGwIjvqgwTYFcqTdyAqaqlnhOCMtsnWXQqtjFwQlEcBtMFAtSqnqthVb\nrNquIcjNWESjpPVWmzUJFrelpUZeGDmSvCurCqVmKHKVAAPkaHksniOlzjiKYIJtvbuQWZRufMebpTFPqyxIWWjfPaWYiNlK", "output": "-1" }, { "input": "ycLoapxsfsDTHMSfAAPIUpiEhQKUIXUcXEiopMBuuZLHtfPpLmCHwNMNQUwsEXxCEmKHTBSnKhtQhGWUvppUFZUgSpbeChX\ndCZhgVXofkGousCzObxZSJwXcHIaqUDSCPKzXntcVmPxtNcXmVcjsetZYxedmgQzXTZHMvzjoaXCMKsncGciSDqQWIIRlys", "output": "1" }, { "input": "nvUbnrywIePXcoukIhwTfUVcHUEgXcsMyNQhmMlTltZiCooyZiIKRIGVHMCnTKgzXXIuvoNDEZswKoACOBGSyVNqTNQqMhAG\nplxuGSsyyJjdvpddrSebOARSAYcZKEaKjqbCwvjhNykuaECoQVHTVFMKXwvrQXRaqXsHsBaGVhCxGRxNyGUbMlxOarMZNXxy", "output": "-1" }, { "input": "EncmXtAblQzcVRzMQqdDqXfAhXbtJKQwZVWyHoWUckohnZqfoCmNJDzexFgFJYrwNHGgzCJTzQQFnxGlhmvQTpicTkEeVICKac\nNIUNZoMLFMyAjVgQLITELJSodIXcGSDWfhFypRoGYuogJpnqGTotWxVqpvBHjFOWcDRDtARsaHarHaOkeNWEHGTaGOFCOFEwvK", "output": "-1" }, { "input": "UG\nak", "output": "1" }, { "input": "JZR\nVae", "output": "-1" }, { "input": "a\nZ", "output": "-1" }, { "input": "rk\nkv", "output": "1" }, { "input": "RvuT\nbJzE", "output": "1" }, { "input": "PPS\nydq", "output": "-1" }, { "input": "q\nq", "output": "0" }, { "input": "peOw\nIgSJ", "output": "1" }, { "input": "PyK\noKN", "output": "1" }, { "input": "O\ni", "output": "1" }, { "input": "NmGY\npDlP", "output": "-1" }, { "input": "nG\nZf", "output": "-1" }, { "input": "m\na", "output": "1" }, { "input": "MWyB\nWZEV", "output": "-1" }, { "input": "Gre\nfxc", "output": "1" }, { "input": "Ooq\nwap", "output": "-1" }, { "input": "XId\nlbB", "output": "1" }, { "input": "lfFpECEqUMEOJhipvkZjDPcpDNJedOVXiSMgBvBZbtfzIKekcvpWPCazKAhJyHircRtgcBIJwwstpHaLAgxFOngAWUZRgCef\nLfFPEcequmeojHIpVkzjDPcpdNJEDOVXiSmGBVBZBtfZikEKcvPwpCAzKAHJyHIrCRTgCbIJWwSTphALagXfOnGAwUzRGcEF", "output": "0" }, { "input": "DQBdtSEDtFGiNRUeJNbOIfDZnsryUlzJHGTXGFXnwsVyxNtLgmklmFvRCzYETBVdmkpJJIvIOkMDgCFHZOTODiYrkwXd\nDQbDtsEdTFginRUEJNBOIfdZnsryulZJHGtxGFxnwSvYxnTLgmKlmFVRCzyEtBVdmKpJjiVioKMDgCFhzoTODiYrKwXD", "output": "0" }, { "input": "tYWRijFQSzHBpCjUzqBtNvBKyzZRnIdWEuyqnORBQTLyOQglIGfYJIRjuxnbLvkqZakNqPiGDvgpWYkfxYNXsdoKXZtRkSasfa\nTYwRiJfqsZHBPcJuZQBTnVbkyZZRnidwEuYQnorbQTLYOqGligFyjirJUxnblVKqZaknQpigDVGPwyKfxyNXSDoKxztRKSaSFA", "output": "0" }, { "input": "KhScXYiErQIUtmVhNTCXSLAviefIeHIIdiGhsYnPkSBaDTvMkyanfMLBOvDWgRybLtDqvXVdVjccNunDyijhhZEAKBrdz\nkHsCXyiErqIuTMVHNTCxSLaViEFIEhIIDiGHsYNpKsBAdTvMKyANFMLBovdwGRYbLtdQVxvDVJCcNUndYiJHhzeakBrdZ", "output": "0" }, { "input": "cpPQMpjRQJKQVXjWDYECXbagSmNcVfOuBWNZxihdERraVuiOpSVDCPgTGuSQALNoVjySceHcKXwOEpSzXrEqWwwrYeppNiWhDVg\nCPPqmPjRqJkQvxJwdyECXBAGsMNcVfOuBWNzxIhderRavUiOpSvDCpGTgusqAlNovjyScEhCKXwoePSZxrEQwWwryEPPniWHDvG", "output": "0" }, { "input": "SajcCGMepaLjZIWLRBGFcrZRCRvvoCsIyKsQerbrwsIamxxpRmQSZSalasJLVFbCHCuXJlubciQAvLxXYBazLsMKLHLdDQ\nsaJcCgmEpaLJziWlrBgFcRzrCrVVOcSIykSQerBrwSIamxxPrMqSzSalASjLVFbChCUxjLUbCIQAVlxxybAZLsmkLhLDdQ", "output": "0" }, { "input": "kigPrWNTOUNDBskAfefjhHYZNYdnfZWuXWzHiBxFQryBbAkPtenFwWvCSTYGpzOntUNzNUhxRWjKmicTwLwJAnbAxj\nkigpRWntOUNdBsKaFEFjhhYZnYDNfzWuXwZhibxFQRybbakPteNfwwvcStyGPzoNTunznuHXrWjKMIctWLWJANBAxJ", "output": "0" }, { "input": "nTomZZuTTRTAAPoUsySVFGElrpQRNLjqvFmcYytiheQnjUhPLnqNBiYtQkljbcvmjuNAVKbvQOWpqqFlQhAhULIhquoCnjUI\nntOmzZuttrtAAPOUSySVFgeLRPQrNLjQvfmCyYTiHEQnjuHPlNQNbIYtqKLJBCVmjunavkbvQOWPQQFlqHaHULIHQuOcnJUi", "output": "0" }, { "input": "abac\nadaa", "output": "-1" }, { "input": "Bbc\nabc", "output": "1" }, { "input": "aaaba\naaaab", "output": "1" } ]

1,695,826,084

2,147,483,647

Python 3

OK

TESTS

53

92

0

# Input string1 = input().lower() # Convert the first string to lowercase string2 = input().lower() # Convert the second string to lowercase # Compare the strings if string1 < string2: print("-1") elif string1 > string2: print("1") else: print("0")

Title: Petya and Strings Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Little Petya loves presents. His mum bought him two strings of the same size for his birthday. The strings consist of uppercase and lowercase Latin letters. Now Petya wants to compare those two strings lexicographically. The letters' case does not matter, that is an uppercase letter is considered equivalent to the corresponding lowercase letter. Help Petya perform the comparison. Input Specification: Each of the first two lines contains a bought string. The strings' lengths range from 1 to 100 inclusive. It is guaranteed that the strings are of the same length and also consist of uppercase and lowercase Latin letters. Output Specification: If the first string is less than the second one, print "-1". If the second string is less than the first one, print "1". If the strings are equal, print "0". Note that the letters' case is not taken into consideration when the strings are compared. Demo Input: ['aaaa\naaaA\n', 'abs\nAbz\n', 'abcdefg\nAbCdEfF\n'] Demo Output: ['0\n', '-1\n', '1\n'] Note: If you want more formal information about the lexicographical order (also known as the "dictionary order" or "alphabetical order"), you can visit the following site: - http://en.wikipedia.org/wiki/Lexicographical_order

```python # Input string1 = input().lower() # Convert the first string to lowercase string2 = input().lower() # Convert the second string to lowercase # Compare the strings if string1 < string2: print("-1") elif string1 > string2: print("1") else: print("0") ```

3.977

845

B

Luba And The Ticket

PROGRAMMING

1,600

[ "brute force", "greedy", "implementation" ]

null

Luba has a ticket consisting of 6 digits. In one move she can choose digit in any position and replace it with arbitrary digit. She wants to know the minimum number of digits she needs to replace in order to make the ticket lucky. The ticket is considered lucky if the sum of first three digits equals to the sum of last three digits.

You are given a string consisting of 6 characters (all characters are digits from 0 to 9) — this string denotes Luba's ticket. The ticket can start with the digit 0.

Print one number — the minimum possible number of digits Luba needs to replace to make the ticket lucky.

[ "000000\n", "123456\n", "111000\n" ]

[ "0\n", "2\n", "1\n" ]

In the first example the ticket is already lucky, so the answer is 0. In the second example Luba can replace 4 and 5 with zeroes, and the ticket will become lucky. It's easy to see that at least two replacements are required. In the third example Luba can replace any zero with 3. It's easy to see that at least one replacement is required.

0

[ { "input": "000000", "output": "0" }, { "input": "123456", "output": "2" }, { "input": "111000", "output": "1" }, { "input": "120111", "output": "0" }, { "input": "999999", "output": "0" }, { "input": "199880", "output": "1" }, { "input": "899889", "output": "1" }, { "input": "899888", "output": "1" }, { "input": "505777", "output": "2" }, { "input": "999000", "output": "3" }, { "input": "989010", "output": "3" }, { "input": "651894", "output": "1" }, { "input": "858022", "output": "2" }, { "input": "103452", "output": "1" }, { "input": "999801", "output": "2" }, { "input": "999990", "output": "1" }, { "input": "697742", "output": "1" }, { "input": "242367", "output": "2" }, { "input": "099999", "output": "1" }, { "input": "198999", "output": "1" }, { "input": "023680", "output": "1" }, { "input": "999911", "output": "2" }, { "input": "000990", "output": "2" }, { "input": "117099", "output": "1" }, { "input": "990999", "output": "1" }, { "input": "000111", "output": "1" }, { "input": "000444", "output": "2" }, { "input": "202597", "output": "2" }, { "input": "000333", "output": "1" }, { "input": "030039", "output": "1" }, { "input": "000009", "output": "1" }, { "input": "006456", "output": "1" }, { "input": "022995", "output": "3" }, { "input": "999198", "output": "1" }, { "input": "223456", "output": "2" }, { "input": "333665", "output": "2" }, { "input": "123986", "output": "2" }, { "input": "599257", "output": "1" }, { "input": "101488", "output": "3" }, { "input": "111399", "output": "2" }, { "input": "369009", "output": "1" }, { "input": "024887", "output": "2" }, { "input": "314347", "output": "1" }, { "input": "145892", "output": "1" }, { "input": "321933", "output": "1" }, { "input": "100172", "output": "1" }, { "input": "222455", "output": "2" }, { "input": "317596", "output": "1" }, { "input": "979245", "output": "2" }, { "input": "000018", "output": "1" }, { "input": "101389", "output": "2" }, { "input": "123985", "output": "2" }, { "input": "900000", "output": "1" }, { "input": "132069", "output": "1" }, { "input": "949256", "output": "1" }, { "input": "123996", "output": "2" }, { "input": "034988", "output": "2" }, { "input": "320869", "output": "2" }, { "input": "089753", "output": "1" }, { "input": "335667", "output": "2" }, { "input": "868580", "output": "1" }, { "input": "958031", "output": "2" }, { "input": "117999", "output": "2" }, { "input": "000001", "output": "1" }, { "input": "213986", "output": "2" }, { "input": "123987", "output": "3" }, { "input": "111993", "output": "2" }, { "input": "642479", "output": "1" }, { "input": "033788", "output": "2" }, { "input": "766100", "output": "2" }, { "input": "012561", "output": "1" }, { "input": "111695", "output": "2" }, { "input": "123689", "output": "2" }, { "input": "944234", "output": "1" }, { "input": "154999", "output": "2" }, { "input": "333945", "output": "1" }, { "input": "371130", "output": "1" }, { "input": "977330", "output": "2" }, { "input": "777544", "output": "2" }, { "input": "111965", "output": "2" }, { "input": "988430", "output": "2" }, { "input": "123789", "output": "3" }, { "input": "111956", "output": "2" }, { "input": "444776", "output": "2" }, { "input": "001019", "output": "1" }, { "input": "011299", "output": "2" }, { "input": "011389", "output": "2" }, { "input": "999333", "output": "2" }, { "input": "126999", "output": "2" }, { "input": "744438", "output": "0" }, { "input": "588121", "output": "3" }, { "input": "698213", "output": "2" }, { "input": "652858", "output": "1" }, { "input": "989304", "output": "3" }, { "input": "888213", "output": "3" }, { "input": "969503", "output": "2" }, { "input": "988034", "output": "2" }, { "input": "889444", "output": "2" }, { "input": "990900", "output": "1" }, { "input": "301679", "output": "2" }, { "input": "434946", "output": "1" }, { "input": "191578", "output": "2" }, { "input": "118000", "output": "2" }, { "input": "636915", "output": "0" }, { "input": "811010", "output": "1" }, { "input": "822569", "output": "1" }, { "input": "122669", "output": "2" }, { "input": "010339", "output": "2" }, { "input": "213698", "output": "2" }, { "input": "895130", "output": "2" }, { "input": "000900", "output": "1" }, { "input": "191000", "output": "2" }, { "input": "001000", "output": "1" }, { "input": "080189", "output": "2" }, { "input": "990000", "output": "2" }, { "input": "201984", "output": "2" }, { "input": "002667", "output": "2" }, { "input": "877542", "output": "2" }, { "input": "301697", "output": "2" }, { "input": "211597", "output": "2" }, { "input": "420337", "output": "1" }, { "input": "024768", "output": "2" }, { "input": "878033", "output": "2" }, { "input": "788024", "output": "2" }, { "input": "023869", "output": "2" }, { "input": "466341", "output": "1" }, { "input": "696327", "output": "1" }, { "input": "779114", "output": "2" }, { "input": "858643", "output": "1" }, { "input": "011488", "output": "3" }, { "input": "003669", "output": "2" }, { "input": "202877", "output": "3" }, { "input": "738000", "output": "2" }, { "input": "567235", "output": "2" }, { "input": "887321", "output": "3" }, { "input": "401779", "output": "2" }, { "input": "989473", "output": "2" }, { "input": "004977", "output": "3" }, { "input": "023778", "output": "2" }, { "input": "809116", "output": "1" }, { "input": "042762", "output": "1" }, { "input": "777445", "output": "2" }, { "input": "769302", "output": "2" }, { "input": "023977", "output": "2" }, { "input": "990131", "output": "2" } ]

1,698,843,866

2,147,483,647

PyPy 3

RUNTIME_ERROR

TESTS

0

93

2,150,400

n,k=map(int,input().split()) print(1-(k==0 or k==n),min(n-k,k+(k>0)))

Title: Luba And The Ticket Time Limit: None seconds Memory Limit: None megabytes Problem Description: Luba has a ticket consisting of 6 digits. In one move she can choose digit in any position and replace it with arbitrary digit. She wants to know the minimum number of digits she needs to replace in order to make the ticket lucky. The ticket is considered lucky if the sum of first three digits equals to the sum of last three digits. Input Specification: You are given a string consisting of 6 characters (all characters are digits from 0 to 9) — this string denotes Luba's ticket. The ticket can start with the digit 0. Output Specification: Print one number — the minimum possible number of digits Luba needs to replace to make the ticket lucky. Demo Input: ['000000\n', '123456\n', '111000\n'] Demo Output: ['0\n', '2\n', '1\n'] Note: In the first example the ticket is already lucky, so the answer is 0. In the second example Luba can replace 4 and 5 with zeroes, and the ticket will become lucky. It's easy to see that at least two replacements are required. In the third example Luba can replace any zero with 3. It's easy to see that at least one replacement is required.

```python n,k=map(int,input().split()) print(1-(k==0 or k==n),min(n-k,k+(k>0))) ```

-1

682

A

Alyona and Numbers

PROGRAMMING

1,100

[ "constructive algorithms", "math", "number theory" ]

null

After finishing eating her bun, Alyona came up with two integers *n* and *m*. She decided to write down two columns of integers — the first column containing integers from 1 to *n* and the second containing integers from 1 to *m*. Now the girl wants to count how many pairs of integers she can choose, one from the first column and the other from the second column, such that their sum is divisible by 5. Formally, Alyona wants to count the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and equals 0. As usual, Alyona has some troubles and asks you to help.

The only line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1<=000<=000).

Print the only integer — the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and (*x*<=+<=*y*) is divisible by 5.

[ "6 12\n", "11 14\n", "1 5\n", "3 8\n", "5 7\n", "21 21\n" ]

[ "14\n", "31\n", "1\n", "5\n", "7\n", "88\n" ]

Following pairs are suitable in the first sample case: - for *x* = 1 fits *y* equal to 4 or 9; - for *x* = 2 fits *y* equal to 3 or 8; - for *x* = 3 fits *y* equal to 2, 7 or 12; - for *x* = 4 fits *y* equal to 1, 6 or 11; - for *x* = 5 fits *y* equal to 5 or 10; - for *x* = 6 fits *y* equal to 4 or 9. Only the pair (1, 4) is suitable in the third sample case.

500

[ { "input": "6 12", "output": "14" }, { "input": "11 14", "output": "31" }, { "input": "1 5", "output": "1" }, { "input": "3 8", "output": "5" }, { "input": "5 7", "output": "7" }, { "input": "21 21", "output": "88" }, { "input": "10 15", "output": "30" }, { "input": "1 1", "output": "0" }, { "input": "1 1000000", "output": "200000" }, { "input": "1000000 1", "output": "200000" }, { "input": "1000000 1000000", "output": "200000000000" }, { "input": "944 844", "output": "159348" }, { "input": "368 984", "output": "72423" }, { "input": "792 828", "output": "131155" }, { "input": "920 969", "output": "178296" }, { "input": "640 325", "output": "41600" }, { "input": "768 170", "output": "26112" }, { "input": "896 310", "output": "55552" }, { "input": "320 154", "output": "9856" }, { "input": "744 999", "output": "148652" }, { "input": "630 843", "output": "106218" }, { "input": "54 688", "output": "7431" }, { "input": "478 828", "output": "79157" }, { "input": "902 184", "output": "33194" }, { "input": "31 29", "output": "180" }, { "input": "751 169", "output": "25384" }, { "input": "879 14", "output": "2462" }, { "input": "7 858", "output": "1201" }, { "input": "431 702", "output": "60512" }, { "input": "855 355", "output": "60705" }, { "input": "553 29", "output": "3208" }, { "input": "721767 525996", "output": "75929310986" }, { "input": "805191 74841", "output": "12052259926" }, { "input": "888615 590981", "output": "105030916263" }, { "input": "4743 139826", "output": "132638943" }, { "input": "88167 721374", "output": "12720276292" }, { "input": "171591 13322", "output": "457187060" }, { "input": "287719 562167", "output": "32349225415" }, { "input": "371143 78307", "output": "5812618980" }, { "input": "487271 627151", "output": "61118498984" }, { "input": "261436 930642", "output": "48660664382" }, { "input": "377564 446782", "output": "33737759810" }, { "input": "460988 28330", "output": "2611958008" }, { "input": "544412 352983", "output": "38433636199" }, { "input": "660540 869123", "output": "114818101284" }, { "input": "743964 417967", "output": "62190480238" }, { "input": "827388 966812", "output": "159985729411" }, { "input": "910812 515656", "output": "93933134534" }, { "input": "26940 64501", "output": "347531388" }, { "input": "110364 356449", "output": "7867827488" }, { "input": "636358 355531", "output": "45248999219" }, { "input": "752486 871672", "output": "131184195318" }, { "input": "803206 420516", "output": "67552194859" }, { "input": "919334 969361", "output": "178233305115" }, { "input": "35462 261309", "output": "1853307952" }, { "input": "118887 842857", "output": "20040948031" }, { "input": "202311 358998", "output": "14525848875" }, { "input": "285735 907842", "output": "51880446774" }, { "input": "401863 456686", "output": "36705041203" }, { "input": "452583 972827", "output": "88056992428" }, { "input": "235473 715013", "output": "33673251230" }, { "input": "318897 263858", "output": "16828704925" }, { "input": "402321 812702", "output": "65393416268" }, { "input": "518449 361546", "output": "37488632431" }, { "input": "634577 910391", "output": "115542637921" }, { "input": "685297 235043", "output": "32214852554" }, { "input": "801425 751183", "output": "120403367155" }, { "input": "884849 300028", "output": "53095895155" }, { "input": "977 848872", "output": "165869588" }, { "input": "51697 397716", "output": "4112144810" }, { "input": "834588 107199", "output": "17893399803" }, { "input": "918012 688747", "output": "126455602192" }, { "input": "1436 237592", "output": "68236422" }, { "input": "117564 753732", "output": "17722349770" }, { "input": "200988 302576", "output": "12162829017" }, { "input": "284412 818717", "output": "46570587880" }, { "input": "400540 176073", "output": "14104855884" }, { "input": "483964 724917", "output": "70166746198" }, { "input": "567388 241058", "output": "27354683301" }, { "input": "650812 789902", "output": "102815540084" }, { "input": "400999 756281", "output": "60653584944" }, { "input": "100 101", "output": "2020" }, { "input": "100 102", "output": "2040" }, { "input": "103 100", "output": "2060" }, { "input": "100 104", "output": "2080" }, { "input": "3 4", "output": "3" }, { "input": "11 23", "output": "50" }, { "input": "8 14", "output": "23" }, { "input": "23423 34234", "output": "160372597" }, { "input": "1 4", "output": "1" }, { "input": "999999 999999", "output": "199999600001" }, { "input": "82 99", "output": "1624" }, { "input": "21 18", "output": "75" }, { "input": "234 234", "output": "10952" }, { "input": "4 4", "output": "4" }, { "input": "6 13", "output": "15" }, { "input": "3 9", "output": "6" }, { "input": "99999 99999", "output": "1999960001" }, { "input": "34 33", "output": "225" }, { "input": "2 2", "output": "0" }, { "input": "333 1", "output": "66" }, { "input": "3 3", "output": "2" }, { "input": "8 2", "output": "3" }, { "input": "2179 2218", "output": "966605" }, { "input": "1000000 999999", "output": "199999800000" }, { "input": "873828 774207", "output": "135304750879" }, { "input": "13 19", "output": "50" }, { "input": "1648 576469", "output": "190004183" }, { "input": "11 13", "output": "28" }, { "input": "5 8", "output": "8" }, { "input": "650074 943659", "output": "122689636154" }, { "input": "1 3", "output": "0" }, { "input": "54 43", "output": "465" }, { "input": "14 9", "output": "26" }, { "input": "2 3", "output": "1" }, { "input": "543 534", "output": "57993" }, { "input": "321 123", "output": "7896" }, { "input": "21 3", "output": "12" }, { "input": "2 1", "output": "0" }, { "input": "4 3", "output": "3" }, { "input": "47474 74747", "output": "709707816" }, { "input": "4 9", "output": "8" }, { "input": "7 4", "output": "6" }, { "input": "9 4", "output": "8" }, { "input": "12414 4214", "output": "10462520" }, { "input": "2 9", "output": "4" }, { "input": "253 821", "output": "41542" }, { "input": "2 4", "output": "2" } ]

1,573,488,821

2,147,483,647

PyPy 3

OK

TESTS

128

140

0

n,m=map(int,input().split()) ans=5*(n//5)*(m//5) p=n%5 q=m%5 tmp=0 for i in range(1,p+1): for j in range(1,q+1): if (i+j)%5==0: tmp+=1 res1,res2=0,0 for i in range(1,p+1): for j in range(1,6): if (i+j)%5==0: res1+=1 for i in range(1,q+1): for j in range(1,6): if(i+j)%5==0: res2+=1 ans=ans+res1*(m//5)+res2*(n//5)+tmp print(ans)

Title: Alyona and Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: After finishing eating her bun, Alyona came up with two integers *n* and *m*. She decided to write down two columns of integers — the first column containing integers from 1 to *n* and the second containing integers from 1 to *m*. Now the girl wants to count how many pairs of integers she can choose, one from the first column and the other from the second column, such that their sum is divisible by 5. Formally, Alyona wants to count the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and equals 0. As usual, Alyona has some troubles and asks you to help. Input Specification: The only line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=1<=000<=000). Output Specification: Print the only integer — the number of pairs of integers (*x*,<=*y*) such that 1<=≤<=*x*<=≤<=*n*, 1<=≤<=*y*<=≤<=*m* and (*x*<=+<=*y*) is divisible by 5. Demo Input: ['6 12\n', '11 14\n', '1 5\n', '3 8\n', '5 7\n', '21 21\n'] Demo Output: ['14\n', '31\n', '1\n', '5\n', '7\n', '88\n'] Note: Following pairs are suitable in the first sample case: - for *x* = 1 fits *y* equal to 4 or 9; - for *x* = 2 fits *y* equal to 3 or 8; - for *x* = 3 fits *y* equal to 2, 7 or 12; - for *x* = 4 fits *y* equal to 1, 6 or 11; - for *x* = 5 fits *y* equal to 5 or 10; - for *x* = 6 fits *y* equal to 4 or 9. Only the pair (1, 4) is suitable in the third sample case.

```python n,m=map(int,input().split()) ans=5*(n//5)*(m//5) p=n%5 q=m%5 tmp=0 for i in range(1,p+1): for j in range(1,q+1): if (i+j)%5==0: tmp+=1 res1,res2=0,0 for i in range(1,p+1): for j in range(1,6): if (i+j)%5==0: res1+=1 for i in range(1,q+1): for j in range(1,6): if(i+j)%5==0: res2+=1 ans=ans+res1*(m//5)+res2*(n//5)+tmp print(ans) ```

3

722

C

Destroying Array

PROGRAMMING

1,600

[ "data structures", "dsu" ]

null

You are given an array consisting of *n* non-negative integers *a*1,<=*a*2,<=...,<=*a**n*. You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to *n* defining the order elements of the array are destroyed. After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the length of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=109). The third line contains a permutation of integers from 1 to *n* — the order used to destroy elements.

Print *n* lines. The *i*-th line should contain a single integer — the maximum possible sum of elements on the segment containing no destroyed elements, after first *i* operations are performed.

[ "4\n1 3 2 5\n3 4 1 2\n", "5\n1 2 3 4 5\n4 2 3 5 1\n", "8\n5 5 4 4 6 6 5 5\n5 2 8 7 1 3 4 6\n" ]

[ "5\n4\n3\n0\n", "6\n5\n5\n1\n0\n", "18\n16\n11\n8\n8\n6\n6\n0\n" ]

Consider the first sample: 1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5. 1. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3. 1. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3. 1. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0.

1,000

[ { "input": "4\n1 3 2 5\n3 4 1 2", "output": "5\n4\n3\n0" }, { "input": "5\n1 2 3 4 5\n4 2 3 5 1", "output": "6\n5\n5\n1\n0" }, { "input": "8\n5 5 4 4 6 6 5 5\n5 2 8 7 1 3 4 6", "output": "18\n16\n11\n8\n8\n6\n6\n0" }, { "input": "10\n3 3 3 5 6 9 3 1 7 3\n3 4 6 7 5 1 10 9 2 8", "output": "34\n29\n14\n11\n11\n11\n8\n3\n1\n0" }, { "input": "17\n12 9 17 5 0 6 5 1 3 1 17 17 2 14 5 1 17\n3 7 5 8 12 9 15 13 11 14 6 16 17 1 10 2 4", "output": "94\n78\n78\n77\n39\n39\n21\n21\n21\n21\n21\n21\n21\n9\n9\n5\n0" }, { "input": "17\n1 6 9 2 10 5 15 16 17 14 17 3 9 8 12 0 2\n9 13 15 14 16 17 11 10 12 4 6 5 7 8 2 3 1", "output": "65\n64\n64\n64\n64\n64\n64\n64\n64\n46\n31\n31\n16\n16\n9\n1\n0" }, { "input": "17\n10 10 3 9 8 0 10 13 11 8 11 1 6 9 2 10 5\n9 4 13 2 6 15 11 5 16 10 7 3 14 1 12 8 17", "output": "63\n52\n31\n31\n26\n23\n23\n23\n23\n23\n13\n13\n13\n13\n13\n5\n0" }, { "input": "10\n10 4 9 0 7 5 10 3 10 9\n5 2 8 1 3 9 6 10 4 7", "output": "37\n37\n19\n19\n19\n15\n10\n10\n10\n0" }, { "input": "10\n3 10 9 2 6 8 4 4 1 9\n5 8 6 7 9 10 2 1 3 4", "output": "26\n24\n24\n24\n24\n24\n11\n11\n2\n0" }, { "input": "1\n1\n1", "output": "0" }, { "input": "7\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000\n1 2 3 4 5 6 7", "output": "6000000000\n5000000000\n4000000000\n3000000000\n2000000000\n1000000000\n0" } ]

1,657,694,007

2,907

PyPy 3-64

OK

TESTS

49

436

27,340,800

import sys input = lambda :sys.stdin.readline()[:-1] ni = lambda :int(input()) na = lambda :list(map(int,input().split())) yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES") no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO") ####################################################################### from collections import defaultdict class UnionFind(): def __init__(self, n): self.n = n self.parents = [-1] * n self.a = [0]*n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.a[x] += self.a[y] self.a[y] = 0 self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): group_members = defaultdict(list) for member in range(self.n): group_members[self.find(member)].append(member) return group_members def __str__(self): return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items()) n = ni() a = na() p = [i-1 for i in na()] ans = [0] b = [0]*n uf = UnionFind(n) for i in range(n-1,-1,-1): z = ans[-1] x = p[i] uf.a[x] = a[x] if x and b[x-1]: uf.union(x, x-1) if x < n-1 and b[x+1]: uf.union(x,x+1) z = max(z,uf.a[uf.find(x)]) b[x] = 1 ans.append(z) print(*ans[::-1][1:],sep="\n")

Title: Destroying Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given an array consisting of *n* non-negative integers *a*1,<=*a*2,<=...,<=*a**n*. You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to *n* defining the order elements of the array are destroyed. After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0. Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the length of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=109). The third line contains a permutation of integers from 1 to *n* — the order used to destroy elements. Output Specification: Print *n* lines. The *i*-th line should contain a single integer — the maximum possible sum of elements on the segment containing no destroyed elements, after first *i* operations are performed. Demo Input: ['4\n1 3 2 5\n3 4 1 2\n', '5\n1 2 3 4 5\n4 2 3 5 1\n', '8\n5 5 4 4 6 6 5 5\n5 2 8 7 1 3 4 6\n'] Demo Output: ['5\n4\n3\n0\n', '6\n5\n5\n1\n0\n', '18\n16\n11\n8\n8\n6\n6\n0\n'] Note: Consider the first sample: 1. Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5. 1. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3. 1. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3. 1. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0.

```python import sys input = lambda :sys.stdin.readline()[:-1] ni = lambda :int(input()) na = lambda :list(map(int,input().split())) yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES") no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO") ####################################################################### from collections import defaultdict class UnionFind(): def __init__(self, n): self.n = n self.parents = [-1] * n self.a = [0]*n def find(self, x): if self.parents[x] < 0: return x else: self.parents[x] = self.find(self.parents[x]) return self.parents[x] def union(self, x, y): x = self.find(x) y = self.find(y) if x == y: return if self.parents[x] > self.parents[y]: x, y = y, x self.a[x] += self.a[y] self.a[y] = 0 self.parents[x] += self.parents[y] self.parents[y] = x def size(self, x): return -self.parents[self.find(x)] def same(self, x, y): return self.find(x) == self.find(y) def members(self, x): root = self.find(x) return [i for i in range(self.n) if self.find(i) == root] def roots(self): return [i for i, x in enumerate(self.parents) if x < 0] def group_count(self): return len(self.roots()) def all_group_members(self): group_members = defaultdict(list) for member in range(self.n): group_members[self.find(member)].append(member) return group_members def __str__(self): return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items()) n = ni() a = na() p = [i-1 for i in na()] ans = [0] b = [0]*n uf = UnionFind(n) for i in range(n-1,-1,-1): z = ans[-1] x = p[i] uf.a[x] = a[x] if x and b[x-1]: uf.union(x, x-1) if x < n-1 and b[x+1]: uf.union(x,x+1) z = max(z,uf.a[uf.find(x)]) b[x] = 1 ans.append(z) print(*ans[::-1][1:],sep="\n") ```

3

0

none

0

[ "none" ]

null

Everyone knows what the Fibonacci sequence is. This sequence can be defined by the recurrence relation: We'll define a new number sequence *A**i*(*k*) by the formula: In this problem, your task is to calculate the following sum: *A*1(*k*)<=+<=*A*2(*k*)<=+<=...<=+<=*A**n*(*k*). The answer can be very large, so print it modulo 1000000007 (109<=+<=7).

The first line contains two space-separated integers *n*, *k* (1<=≤<=*n*<=≤<=1017; 1<=≤<=*k*<=≤<=40).

Print a single integer — the sum of the first *n* elements of the sequence *A**i*(*k*) modulo 1000000007 (109<=+<=7).

[ "1 1\n", "4 1\n", "5 2\n", "7 4\n" ]

[ "1\n", "34\n", "316\n", "73825\n" ]

none

0

[]

1,689,177,651

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

46

0

print("_RANDOM_GUESS_1689177651.528398")# 1689177651.528425

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Everyone knows what the Fibonacci sequence is. This sequence can be defined by the recurrence relation: We'll define a new number sequence *A**i*(*k*) by the formula: In this problem, your task is to calculate the following sum: *A*1(*k*)<=+<=*A*2(*k*)<=+<=...<=+<=*A**n*(*k*). The answer can be very large, so print it modulo 1000000007 (109<=+<=7). Input Specification: The first line contains two space-separated integers *n*, *k* (1<=≤<=*n*<=≤<=1017; 1<=≤<=*k*<=≤<=40). Output Specification: Print a single integer — the sum of the first *n* elements of the sequence *A**i*(*k*) modulo 1000000007 (109<=+<=7). Demo Input: ['1 1\n', '4 1\n', '5 2\n', '7 4\n'] Demo Output: ['1\n', '34\n', '316\n', '73825\n'] Note: none

```python print("_RANDOM_GUESS_1689177651.528398")# 1689177651.528425 ```

0

637

B

Chat Order

PROGRAMMING

1,200

[ "*special", "binary search", "constructive algorithms", "data structures", "sortings" ]

null

Polycarp is a big lover of killing time in social networks. A page with a chatlist in his favourite network is made so that when a message is sent to some friend, his friend's chat rises to the very top of the page. The relative order of the other chats doesn't change. If there was no chat with this friend before, then a new chat is simply inserted to the top of the list. Assuming that the chat list is initially empty, given the sequence of Polycaprus' messages make a list of chats after all of his messages are processed. Assume that no friend wrote any message to Polycarpus.

The first line contains integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of Polycarpus' messages. Next *n* lines enlist the message recipients in the order in which the messages were sent. The name of each participant is a non-empty sequence of lowercase English letters of length at most 10.

Print all the recipients to who Polycarp talked to in the order of chats with them, from top to bottom.

[ "4\nalex\nivan\nroman\nivan\n", "8\nalina\nmaria\nekaterina\ndarya\ndarya\nekaterina\nmaria\nalina\n" ]

[ "ivan\nroman\nalex\n", "alina\nmaria\nekaterina\ndarya\n" ]

In the first test case Polycarpus first writes to friend by name "alex", and the list looks as follows: 1. alex Then Polycarpus writes to friend by name "ivan" and the list looks as follows: 1. ivan 1. alex Polycarpus writes the third message to friend by name "roman" and the list looks as follows: 1. roman 1. ivan 1. alex Polycarpus writes the fourth message to friend by name "ivan", to who he has already sent a message, so the list of chats changes as follows: 1. ivan 1. roman 1. alex

1,000

[ { "input": "4\nalex\nivan\nroman\nivan", "output": "ivan\nroman\nalex" }, { "input": "8\nalina\nmaria\nekaterina\ndarya\ndarya\nekaterina\nmaria\nalina", "output": "alina\nmaria\nekaterina\ndarya" }, { "input": "1\nwdi", "output": "wdi" }, { "input": "2\nypg\nypg", "output": "ypg" }, { "input": "3\nexhll\nexhll\narruapexj", "output": "arruapexj\nexhll" }, { "input": "3\nfv\nle\nle", "output": "le\nfv" }, { "input": "8\nm\nm\nm\nm\nm\nm\nm\nm", "output": "m" }, { "input": "10\nr\nr\ni\nw\nk\nr\nb\nu\nu\nr", "output": "r\nu\nb\nk\nw\ni" }, { "input": "7\ne\nfau\ncmk\nnzs\nby\nwx\ntjmok", "output": "tjmok\nwx\nby\nnzs\ncmk\nfau\ne" }, { "input": "6\nklrj\nwe\nklrj\nwe\nwe\nwe", "output": "we\nklrj" }, { "input": "8\nzncybqmh\naeebef\nzncybqmh\nn\naeebef\nzncybqmh\nzncybqmh\nzncybqmh", "output": "zncybqmh\naeebef\nn" }, { "input": "30\nkqqcbs\nvap\nkymomn\nj\nkqqcbs\nfuzlzoum\nkymomn\ndbh\nfuzlzoum\nkymomn\nvap\nvlgzs\ndbh\nvlgzs\nbvy\ndbh\nkymomn\nkymomn\neoqql\nkymomn\nkymomn\nkqqcbs\nvlgzs\nkqqcbs\nkqqcbs\nfuzlzoum\nvlgzs\nrylgdoo\nvlgzs\nrylgdoo", "output": "rylgdoo\nvlgzs\nfuzlzoum\nkqqcbs\nkymomn\neoqql\ndbh\nbvy\nvap\nj" }, { "input": "40\nji\nv\nv\nns\nji\nn\nji\nv\nfvy\nvje\nns\nvje\nv\nhas\nv\nusm\nhas\nfvy\nvje\nkdb\nn\nv\nji\nji\nn\nhas\nv\nji\nkdb\nr\nvje\nns\nv\nusm\nn\nvje\nhas\nns\nhas\nn", "output": "n\nhas\nns\nvje\nusm\nv\nr\nkdb\nji\nfvy" }, { "input": "50\njcg\nvle\njopb\nepdb\nnkef\nfv\nxj\nufe\nfuy\noqta\ngbc\nyuz\nec\nyji\nkuux\ncwm\ntq\nnno\nhp\nzry\nxxpp\ntjvo\ngyz\nkwo\nvwqz\nyaqc\njnj\nwoav\nqcv\ndcu\ngc\nhovn\nop\nevy\ndc\ntrpu\nyb\nuzfa\npca\noq\nnhxy\nsiqu\nde\nhphy\nc\nwovu\nf\nbvv\ndsik\nlwyg", "output": "lwyg\ndsik\nbvv\nf\nwovu\nc\nhphy\nde\nsiqu\nnhxy\noq\npca\nuzfa\nyb\ntrpu\ndc\nevy\nop\nhovn\ngc\ndcu\nqcv\nwoav\njnj\nyaqc\nvwqz\nkwo\ngyz\ntjvo\nxxpp\nzry\nhp\nnno\ntq\ncwm\nkuux\nyji\nec\nyuz\ngbc\noqta\nfuy\nufe\nxj\nfv\nnkef\nepdb\njopb\nvle\njcg" }, { "input": "100\nvhh\nvhh\nvhh\nfa\nfa\nvhh\nvhh\nvhh\nfa\nfa\nfa\nvhh\nfa\nvhh\nvhh\nvhh\nfa\nvhh\nvhh\nfa\nfa\nfa\nfa\nfa\nfa\nvhh\nfa\nfa\nvhh\nvhh\nvhh\nfa\nfa\nfa\nvhh\nfa\nvhh\nfa\nvhh\nvhh\nfa\nvhh\nfa\nvhh\nvhh\nvhh\nfa\nvhh\nfa\nfa\nvhh\nfa\nvhh\nvhh\nvhh\nvhh\nfa\nvhh\nvhh\nvhh\nvhh\nfa\nvhh\nvhh\nvhh\nvhh\nvhh\nfa\nvhh\nvhh\nfa\nfa\nfa\nvhh\nfa\nfa\nvhh\nfa\nvhh\nfa\nfa\nfa\nfa\nfa\nfa\nvhh\nvhh\nfa\nvhh\nfa\nfa\nvhh\nfa\nfa\nvhh\nfa\nvhh\nvhh\nfa\nvhh", "output": "vhh\nfa" }, { "input": "2\naa\nbb", "output": "bb\naa" }, { "input": "2\naa\na", "output": "a\naa" }, { "input": "3\naa\naa\naa", "output": "aa" }, { "input": "5\naa\na\naa\na\naa", "output": "aa\na" }, { "input": "7\naaaa\naaaa\naaa\na\naa\naaaaaaa\naaa", "output": "aaa\naaaaaaa\naa\na\naaaa" }, { "input": "5\na\naa\naaa\naaaa\na", "output": "a\naaaa\naaa\naa" }, { "input": "12\naaaaa\naaaaaa\naaaa\naaaaaa\naa\naaaa\naaaa\naaaaaa\na\naaa\naaaaaaaa\naa", "output": "aa\naaaaaaaa\naaa\na\naaaaaa\naaaa\naaaaa" }, { "input": "3\na\naa\naaa", "output": "aaa\naa\na" }, { "input": "9\nzzz\nzzzzz\nzzz\nzzzz\nzz\nzzzz\nzzzzz\nzzzz\nzzzzzzz", "output": "zzzzzzz\nzzzz\nzzzzz\nzz\nzzz" } ]

1,692,060,273

2,147,483,647

PyPy 3-64

OK

TESTS

95

1,263

47,206,400

n = int(input()) lista = [""] * n conjunto = set() for i in range(n): entrada = input() lista[i] = entrada result = {} for i in range(len(lista)): result[lista.pop()] = 0 for chave in result: print(chave)

Title: Chat Order Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarp is a big lover of killing time in social networks. A page with a chatlist in his favourite network is made so that when a message is sent to some friend, his friend's chat rises to the very top of the page. The relative order of the other chats doesn't change. If there was no chat with this friend before, then a new chat is simply inserted to the top of the list. Assuming that the chat list is initially empty, given the sequence of Polycaprus' messages make a list of chats after all of his messages are processed. Assume that no friend wrote any message to Polycarpus. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of Polycarpus' messages. Next *n* lines enlist the message recipients in the order in which the messages were sent. The name of each participant is a non-empty sequence of lowercase English letters of length at most 10. Output Specification: Print all the recipients to who Polycarp talked to in the order of chats with them, from top to bottom. Demo Input: ['4\nalex\nivan\nroman\nivan\n', '8\nalina\nmaria\nekaterina\ndarya\ndarya\nekaterina\nmaria\nalina\n'] Demo Output: ['ivan\nroman\nalex\n', 'alina\nmaria\nekaterina\ndarya\n'] Note: In the first test case Polycarpus first writes to friend by name "alex", and the list looks as follows: 1. alex Then Polycarpus writes to friend by name "ivan" and the list looks as follows: 1. ivan 1. alex Polycarpus writes the third message to friend by name "roman" and the list looks as follows: 1. roman 1. ivan 1. alex Polycarpus writes the fourth message to friend by name "ivan", to who he has already sent a message, so the list of chats changes as follows: 1. ivan 1. roman 1. alex

```python n = int(input()) lista = [""] * n conjunto = set() for i in range(n): entrada = input() lista[i] = entrada result = {} for i in range(len(lista)): result[lista.pop()] = 0 for chave in result: print(chave) ```

3

479

B

Towers

PROGRAMMING

1,400

[ "brute force", "constructive algorithms", "greedy", "implementation", "sortings" ]

null

As you know, all the kids in Berland love playing with cubes. Little Petya has *n* towers consisting of cubes of the same size. Tower with number *i* consists of *a**i* cubes stacked one on top of the other. Petya defines the instability of a set of towers as a value equal to the difference between the heights of the highest and the lowest of the towers. For example, if Petya built five cube towers with heights (8, 3, 2, 6, 3), the instability of this set is equal to 6 (the highest tower has height 8, the lowest one has height 2). The boy wants the instability of his set of towers to be as low as possible. All he can do is to perform the following operation several times: take the top cube from some tower and put it on top of some other tower of his set. Please note that Petya would never put the cube on the same tower from which it was removed because he thinks it's a waste of time. Before going to school, the boy will have time to perform no more than *k* such operations. Petya does not want to be late for class, so you have to help him accomplish this task.

The first line contains two space-separated positive integers *n* and *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=1000) — the number of towers in the given set and the maximum number of operations Petya can perform. The second line contains *n* space-separated positive integers *a**i* (1<=≤<=*a**i*<=≤<=104) — the towers' initial heights.

In the first line print two space-separated non-negative integers *s* and *m* (*m*<=≤<=*k*). The first number is the value of the minimum possible instability that can be obtained after performing at most *k* operations, the second number is the number of operations needed for that. In the next *m* lines print the description of each operation as two positive integers *i* and *j*, each of them lies within limits from 1 to *n*. They represent that Petya took the top cube from the *i*-th tower and put in on the *j*-th one (*i*<=≠<=*j*). Note that in the process of performing operations the heights of some towers can become equal to zero. If there are multiple correct sequences at which the minimum possible instability is achieved, you are allowed to print any of them.

[ "3 2\n5 8 5\n", "3 4\n2 2 4\n", "5 3\n8 3 2 6 3\n" ]

[ "0 2\n2 1\n2 3\n", "1 1\n3 2\n", "3 3\n1 3\n1 2\n1 3\n" ]

In the first sample you need to move the cubes two times, from the second tower to the third one and from the second one to the first one. Then the heights of the towers are all the same and equal to 6.

1,000

[ { "input": "3 2\n5 8 5", "output": "0 2\n2 1\n2 3" }, { "input": "3 4\n2 2 4", "output": "1 4\n3 1\n1 2\n2 1\n1 2" }, { "input": "5 3\n8 3 2 6 3", "output": "3 3\n1 3\n1 2\n1 3" }, { "input": "4 6\n1 10 8 2", "output": "2 6\n2 1\n2 1\n2 4\n3 1\n2 4\n3 1" }, { "input": "5 3\n2 2 2 2 2", "output": "0 0" }, { "input": "95 720\n9119 7480 7245 2431 7986 4088 3498 7724 9291 3853 9733 4018 1109 6476 6915 6456 8956 2877 8090 7557 1886 5944 9952 6275 2877 6488 2688 319 4635 8618 2724 7047 3261 8750 971 9114 6552 7749 4356 6059 1495 5713 2625 7230 7330 3879 8965 7337 5975 3263 646 9124 692 610 2091 2681 5354 1323 1933 4356 3164 8150 2234 4627 5773 1092 445 598 4949 8916 1335 1135 9004 395 665 9859 7949 4813 7543 6023 836 2465 4598 4516 5072 608 733 9299 5073 5333 7847 7921 3482 5422 8527", "output": "8993 720\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 28\n23 2..." }, { "input": "1 1\n1", "output": "0 0" }, { "input": "1 1\n10000", "output": "0 0" }, { "input": "1 1\n1238", "output": "0 0" }, { "input": "1 998\n13", "output": "0 0" }, { "input": "1 1000\n2153", "output": "0 0" }, { "input": "2 1\n13 13", "output": "0 0" }, { "input": "2 2\n27 29", "output": "0 1\n2 1" }, { "input": "2 1\n27 29", "output": "0 1\n2 1" }, { "input": "2 1\n37 41", "output": "2 1\n2 1" }, { "input": "2 2\n37 41", "output": "0 2\n2 1\n2 1" }, { "input": "5 1000\n10000 10000 10000 10000 10000", "output": "0 0" }, { "input": "6 1000\n1 2 3 4 5 6", "output": "1 1000\n6 1\n5 1\n6 2\n4 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2..." }, { "input": "5 17\n10000 1 10000 1 10000", "output": "9986 17\n1 2\n3 4\n5 2\n1 4\n3 2\n5 4\n1 2\n3 4\n5 2\n1 4\n3 2\n5 4\n1 2\n3 4\n5 2\n1 4\n3 2" }, { "input": "9 325\n100 200 300 200 100 200 300 200 100", "output": "1 325\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n7 9\n3 1\n7 5\n3 9\n7 1\n3 5\n..." }, { "input": "8 4\n9 8 7 5 6 8 10 12", "output": "2 4\n8 4\n8 4\n7 5\n8 3" }, { "input": "7 23\n1 1 1 1 1 1 1", "output": "0 0" }, { "input": "11 20\n10 12 14 7 9 11 13 15 5 7 88", "output": "57 20\n11 9\n11 9\n11 4\n11 9\n11 10\n11 4\n11 9\n11 10\n11 4\n11 5\n11 9\n11 10\n11 1\n11 4\n11 5\n11 9\n11 10\n11 1\n11 4\n11 5" }, { "input": "12 159\n987 654 321 123 456 789 963 852 147 741 852 963", "output": "704 159\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9\n1 4\n7 9\n12 4\n1 9\n7 4\n12 9..." }, { "input": "8 1000\n1 9999 1 9999 1 9999 1 9999", "output": "9498 1000\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n2 1\n4 3\n6 5\n8 7\n..." }, { "input": "10 14\n18 26 19 37 37 37 12 2 11 39", "output": "21 14\n10 8\n10 8\n4 8\n5 8\n6 8\n10 8\n4 8\n5 8\n6 8\n10 8\n4 9\n5 7\n6 8\n10 9" }, { "input": "7 859\n12 10 11 12 10 15 18", "output": "1 859\n7 2\n7 5\n7 2\n6 3\n7 5\n6 1\n7 2\n1 3\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n..." }, { "input": "8 789\n80 88 86 88 89 80 85 86", "output": "1 789\n5 1\n2 6\n4 1\n5 6\n2 1\n4 6\n5 1\n2 6\n3 1\n4 6\n5 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n..." }, { "input": "7 987\n670 658 658 658 679 690 684", "output": "0 40\n6 2\n6 3\n6 4\n6 2\n6 3\n6 4\n6 2\n7 3\n6 4\n7 2\n6 3\n7 4\n6 2\n7 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 2\n5 3\n6 4\n7 1\n5 2\n6 3\n7 4" }, { "input": "7 750\n96 101 102 103 104 105 103", "output": "0 7\n6 1\n5 1\n6 1\n4 1\n5 1\n6 1\n7 2" }, { "input": "5 1000\n300 300 2 3 5", "output": "0 356\n1 3\n2 3\n1 4\n2 3\n1 4\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n2 3\n1 4\n2 5\n1 3\n2 4\n1 5\n..." }, { "input": "55 534\n3524 154 2688 7004 4266 6818 7391 423 7879 8045 1874 5427 6158 2003 7257 9003 8493 5829 316 9797 6297 8719 5457 7939 5156 5078 1300 2974 3417 9610 494 5979 4779 6098 5504 4344 9563 5540 2247 4508 545 4620 1191 4460 704 6225 2066 82 756 9589 1136 294 468 2003 8982", "output": "9162 534\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 48\n20 4..." }, { "input": "71 596\n8473 9181 6643 3064 9601 3196 3989 2178 115 4941 3471 3587 264 7530 1790 1006 4382 270 8350 6230 8004 951 5153 5411 1083 7861 7752 1981 4358 2761 7719 2207 3194 6694 9093 3221 9870 1171 4329 5662 5947 3527 302 4394 7325 8571 2063 4316 8240 3755 7979 4712 244 7045 8033 2246 6921 279 7189 9501 7075 6228 2137 3880 3510 5280 8692 6724 7386 4223 1854", "output": "9114 596\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 9\n37 ..." }, { "input": "83 307\n2877 1856 4790 3989 2777 3222 7883 1230 8702 1293 9261 8644 9505 7248 2131 3553 3919 3222 2737 2663 8222 9535 658 7075 3361 99 6364 989 6243 2808 9137 1139 8360 4042 6330 5346 177 3155 8571 9919 4454 5138 3060 5272 4891 1861 9356 3413 2477 81 4277 74 9076 8438 7085 676 5073 5501 5560 9977 9502 2091 9929 6411 754 5006 5719 8435 4348 4444 1034 5047 1509 6488 2205 8998 8417 287 522 9192 4140 3700 1092", "output": "9656 307\n60 52\n60 52\n60 52\n60 52\n60 52\n60 52\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 50\n60 52\n60 26\n60 50\n60 52\n60 26\n60 50\n60 52\n63 26\n60 50\n63 52\n60 26\n63 50\n60 52\n63 26\n60 50\n63 52\n60 26\n63 50\n60 52\n63 26\n60 50\n63 52\n60 26\n63 50\n60 52\n63 26\n40 50\n60 52\n63 26\n40 5..." }, { "input": "99 313\n4178 5075 2937 8561 5408 9600 1777 3929 938 8188 8698 997 3611 2775 5720 5556 9808 7663 771 7608 2633 8118 2514 1444 5640 2882 5520 7292 5024 9607 9610 7367 2582 4639 7215 4224 6836 7298 654 1072 3504 4045 1626 2501 1513 4207 9353 7646 7258 2759 1120 300 8852 9287 9784 9107 9032 6531 9740 6806 4634 658 6232 9485 703 1627 6939 146 9823 7369 6565 5679 6851 5816 3753 5377 7175 1077 8588 4616 8889 1184 1363 2996 2823 4397 2729 6297 1205 1966 5030 4811 2580 2426 8136 6066 8139 2073 45", "output": "9459 313\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n69 99\n17 99\n55 99\n69 99\n17 99\n55 99\n69 99\n17 99\n55 99\n69 9..." }, { "input": "100 742\n4447 7727 1809 6921 15 6873 3861 1648 4239 4725 3590 1680 8691 8691 6084 3747 9116 8916 9092 8292 4031 7149 6668 4222 1828 9699 5971 6464 5268 2621 2181 6171 9418 9429 3677 3266 1155 9382 1513 2792 8333 4670 8682 7925 1003 4717 5600 4273 6718 5444 2769 8199 8109 1927 4530 9283 9182 1115 4636 6404 5162 5416 3592 9178 3244 4567 2595 3864 7970 8180 7114 6498 3434 3676 4798 4000 2342 5696 5489 3129 1320 8400 9511 6616 2374 2897 2870 1994 3446 7191 5141 1294 3362 1899 6592 147 4485 5477 4098 5580", "output": "8888 742\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 5\n26 ..." }, { "input": "100 805\n1556 4594 5764 9334 9542 6899 459 699 6475 8916 9379 9841 6988 4217 6425 7239 8653 3357 9830 4725 8442 9381 2172 8590 7755 1937 4584 5471 9857 2668 9951 5103 3640 25 8210 6335 5109 7717 6300 1241 9544 6282 1440 7859 4920 711 5597 8506 1499 1770 1771 8425 589 9128 3582 7713 437 6337 3007 4720 293 3983 7192 8060 4681 4837 9622 5575 4932 8401 6294 4426 4584 5708 3642 6731 1100 9590 3555 4905 5125 76 1270 2012 5088 4180 56 2088 2243 909 1669 3352 5905 6690 850 9124 2100 581 544 6797", "output": "9356 805\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 34\n31 87\n31 3..." }, { "input": "100 811\n6505 7269 262 3906 5822 7469 4353 6102 4519 5812 8816 4898 2038 9744 3662 5594 4542 6309 7864 6965 2852 7965 7677 254 6930 4720 1036 4478 4446 5819 1368 1331 1511 7373 1799 1564 5416 9701 7838 8202 4946 5189 6 2929 5190 353 8698 7604 8984 8640 8614 3787 2525 4169 2633 6144 8589 4263 9891 1549 5425 5654 3495 1135 8277 8755 842 1478 407 3486 5473 866 5733 4091 1543 3111 4051 380 3108 3033 9874 4856 5734 5248 5641 4519 4139 4885 1040 979 1301 2307 2640 9321 9300 4454 8227 8789 3343 8958", "output": "9188 811\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 43\n81 43\n59 4..." }, { "input": "100 521\n910 6295 5705 5775 5349 3847 4599 5153 3107 5812 4605 3058 7631 5270 356 1789 4079 750 91 6102 3071 196 9533 7726 9208 3310 9648 9293 3228 6811 2786 3912 7221 1073 6332 442 4235 3844 9920 9356 3997 4096 2765 2862 2756 2699 8695 1837 7413 2262 4913 8205 2301 2859 5332 7278 2548 9485 8263 6217 7853 7868 1287 18 5522 8480 7869 3189 7369 3707 1005 4602 1075 3418 3091 5842 9161 1170 1173 6297 4623 9636 6005 3348 8355 5803 1326 4034 9837 1594 3636 7069 9374 464 3558 6136 2194 3893 9245 8015", "output": "9355 521\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 64\n39 6..." }, { "input": "100 527\n9506 8970 9660 4539 4333 3873 8492 4204 5343 9060 394 8115 5385 4989 4889 144 6320 4246 4477 2535 7482 8780 7742 9390 5135 8253 5156 5596 4169 9962 9068 140 1444 1669 9921 8375 4542 3123 515 7805 6695 5707 5523 92 5186 8693 5988 935 4898 4940 1755 9376 2077 7900 4384 5709 3804 515 2442 3046 6632 6435 4886 2548 5470 8750 6385 7604 7035 6633 7480 8338 8577 7609 5183 8574 7920 7768 6534 4425 5725 7120 7765 6584 1069 6142 8513 2640 9578 5312 2324 5480 3405 9447 2008 7817 5617 4805 2044 2880", "output": "9377 527\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n30 44\n35 44\n30 44\n35 44\n30 44\n35 44\n30 44\n35 32\n30 44\n35 32\n30 44\n35 32\n30 44\n35 32\n30 44\n35 16\n30 32\n35 44\n30 16\n35 32\n30 44\n35 16\n30 32\n35 44\n30 16\n35 32\n30 44\n35 16\n30 32\n35 44\n30 1..." }, { "input": "100 324\n372 362 365 379 370 377 371 377 367 366 363 378 365 368 378 359 369 380 377 374 363 366 372 365 365 378 371 363 369 367 361 366 375 366 380 379 367 374 366 365 373 372 363 378 365 377 379 377 362 380 366 376 380 378 361 362 367 359 366 359 370 361 361 374 377 368 366 359 365 359 380 360 375 375 367 372 372 375 377 377 363 367 379 380 373 364 374 377 360 380 380 379 365 374 375 368 376 365 369 360", "output": "1 324\n18 16\n35 58\n50 60\n53 68\n71 70\n84 16\n90 58\n91 60\n4 68\n18 70\n35 72\n36 89\n47 100\n50 16\n53 31\n71 55\n83 58\n84 60\n90 62\n91 63\n92 68\n4 70\n12 72\n15 89\n18 100\n26 2\n35 16\n36 31\n44 49\n47 55\n50 56\n53 58\n54 60\n71 62\n83 63\n84 68\n90 70\n91 72\n92 89\n4 100\n6 2\n8 11\n12 16\n15 21\n18 28\n19 31\n26 43\n35 49\n36 55\n44 56\n46 58\n47 60\n48 62\n50 63\n53 68\n54 70\n65 72\n71 81\n79 89\n80 100\n83 2\n84 11\n88 16\n90 21\n91 28\n92 31\n4 43\n6 49\n8 55\n12 56\n15 58\n18 60\n19 62\n..." }, { "input": "64 35\n369 370 362 370 380 377 379 360 369 380 366 369 360 379 359 374 360 373 370 375 363 367 380 361 364 367 369 370 368 370 375 362 359 364 367 371 362 377 372 367 377 373 375 364 359 359 370 368 377 372 374 378 376 365 368 370 369 373 370 365 365 372 365 367", "output": "12 35\n5 15\n10 33\n23 45\n5 46\n7 8\n10 13\n14 15\n23 17\n5 33\n7 45\n10 46\n14 8\n23 13\n52 15\n5 17\n6 24\n7 33\n10 45\n14 46\n23 3\n38 8\n41 13\n49 15\n52 17\n5 24\n6 32\n7 33\n10 37\n14 45\n23 46\n38 3\n41 8\n49 13\n52 15\n53 17" }, { "input": "76 41\n359 359 366 370 376 375 368 361 369 373 367 363 364 377 363 378 373 371 370 370 360 367 369 359 365 373 379 379 375 361 372 377 369 368 373 362 375 379 365 378 370 370 377 364 373 379 365 362 360 366 375 364 372 376 375 379 362 377 369 370 359 379 365 359 372 376 373 371 364 361 377 366 373 380 378 369", "output": "13 41\n74 1\n27 2\n28 24\n38 61\n46 64\n56 1\n62 2\n74 21\n16 24\n27 49\n28 61\n38 64\n40 1\n46 2\n56 8\n62 21\n74 24\n75 30\n14 49\n16 61\n27 64\n28 70\n32 1\n38 2\n40 8\n43 21\n46 24\n56 30\n58 36\n62 48\n71 49\n74 57\n75 61\n5 64\n14 70\n16 1\n27 2\n28 8\n32 12\n38 15\n40 21" }, { "input": "92 751\n380 368 363 379 359 379 380 368 379 365 370 376 359 366 378 371 362 374 370 376 375 367 379 367 363 360 373 362 360 360 370 375 376 362 370 378 368 364 367 371 374 371 372 368 380 377 364 375 377 362 362 366 366 365 363 365 364 374 377 376 372 366 360 366 380 370 362 368 369 376 371 376 364 371 360 375 360 373 359 367 370 365 374 374 379 379 359 371 367 377 359 360", "output": "1 751\n1 5\n7 13\n45 79\n65 87\n1 91\n4 5\n6 13\n7 26\n9 29\n23 30\n45 63\n65 75\n85 77\n86 79\n1 87\n4 91\n6 92\n7 5\n9 13\n15 26\n23 29\n36 30\n45 63\n65 75\n85 77\n86 79\n1 87\n4 91\n6 92\n7 5\n9 13\n15 17\n23 26\n36 28\n45 29\n46 30\n49 34\n59 50\n65 51\n85 63\n86 67\n90 75\n1 77\n4 79\n6 87\n7 91\n9 92\n12 3\n15 5\n20 13\n23 17\n33 25\n36 26\n45 28\n46 29\n49 30\n59 34\n60 50\n65 51\n70 55\n72 63\n85 67\n86 75\n90 77\n1 79\n4 87\n6 91\n7 92\n9 3\n12 5\n15 13\n20 17\n21 25\n23 26\n32 28\n33 29\n36 30\n..." }, { "input": "4 917\n371 379 368 369", "output": "1 917\n2 3\n2 3\n2 4\n2 3\n2 4\n2 1\n2 3\n1 4\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n..." }, { "input": "40 543\n817 818 818 817 817 818 818 818 818 817 818 818 818 818 818 818 818 818 817 818 817 817 818 817 818 817 818 817 818 818 817 818 818 818 817 818 818 818 818 818", "output": "1 543\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n..." }, { "input": "56 253\n818 817 817 818 817 818 817 817 818 818 817 817 818 817 817 817 817 817 818 817 818 818 818 817 817 818 818 818 817 817 818 817 817 818 818 817 818 818 817 817 817 817 818 817 818 818 818 817 817 818 817 817 818 818 818 817", "output": "1 253\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n..." }, { "input": "16 611\n817 817 818 818 818 818 817 817 818 818 818 817 817 817 818 818", "output": "1 611\n3 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n2 1\n..." }, { "input": "87 161\n1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024 1024", "output": "0 0" }, { "input": "100 1000\n18 12 14 17 19 20 18 16 15 12 10 20 20 19 18 12 13 14 19 11 17 10 18 13 11 11 14 15 13 20 16 13 17 12 12 19 18 15 16 11 12 13 15 20 12 16 20 10 13 20 13 15 13 20 17 16 19 20 19 11 20 19 12 15 12 20 16 10 19 19 11 19 13 11 18 12 19 10 14 15 13 19 20 20 11 10 11 19 19 12 20 20 10 13 10 18 16 15 20 16", "output": "1 1000\n6 11\n12 22\n13 48\n30 68\n44 78\n47 86\n50 93\n54 95\n58 11\n61 20\n66 22\n83 25\n84 26\n91 40\n92 48\n99 60\n5 68\n6 71\n12 74\n13 78\n14 85\n19 86\n30 87\n36 93\n44 95\n47 2\n50 10\n54 11\n57 16\n58 20\n59 22\n61 25\n62 26\n66 34\n69 35\n70 40\n72 41\n77 45\n82 48\n83 60\n84 63\n88 65\n89 68\n91 71\n92 74\n99 76\n1 78\n5 85\n6 86\n7 87\n12 90\n13 93\n14 95\n15 2\n19 10\n23 11\n30 16\n36 17\n37 20\n44 22\n47 24\n50 25\n54 26\n57 29\n58 32\n59 34\n61 35\n62 40\n66 41\n69 42\n70 45\n72 48\n75 49\n7..." }, { "input": "100 1000\n22 12 16 15 19 16 15 21 13 20 12 16 14 13 21 14 16 12 12 12 18 16 19 18 15 14 21 11 12 22 20 12 20 22 13 22 11 19 11 17 21 16 13 13 22 13 14 21 13 21 21 20 19 17 13 18 15 14 15 13 13 16 16 22 17 11 17 22 22 22 19 19 21 16 19 11 12 12 13 18 13 18 22 21 11 18 19 19 18 14 21 20 16 20 13 17 12 15 19 17", "output": "1 1000\n1 28\n30 37\n34 39\n36 66\n45 76\n64 85\n68 2\n69 11\n70 18\n83 19\n1 20\n8 28\n15 29\n27 32\n30 37\n34 39\n36 66\n41 76\n45 77\n48 78\n50 85\n51 97\n64 2\n68 9\n69 11\n70 14\n73 18\n83 19\n84 20\n91 28\n1 29\n8 32\n10 35\n15 37\n27 39\n30 43\n31 44\n33 46\n34 49\n36 55\n41 60\n45 61\n48 66\n50 76\n51 77\n52 78\n64 79\n68 81\n69 85\n70 95\n73 97\n83 2\n84 9\n91 11\n92 13\n94 14\n1 16\n5 18\n8 19\n10 20\n15 26\n23 28\n27 29\n30 32\n31 35\n33 37\n34 39\n36 43\n38 44\n41 46\n45 47\n48 49\n50 55\n51 58..." }, { "input": "100 1000\n18 19 23 15 19 23 22 19 14 14 14 17 17 18 13 18 18 16 22 12 21 20 13 13 14 22 24 13 23 24 19 23 23 21 16 17 24 19 24 20 17 15 16 16 19 22 16 14 19 20 24 22 20 15 16 15 17 12 12 17 13 13 24 15 24 18 14 16 23 22 18 15 24 20 13 17 14 22 16 13 14 21 18 18 21 16 18 12 19 23 14 23 22 16 20 17 12 22 13 22", "output": "1 1000\n27 20\n30 58\n37 59\n39 88\n51 97\n63 15\n65 20\n73 23\n3 24\n6 28\n27 58\n29 59\n30 61\n32 62\n33 75\n37 80\n39 88\n51 97\n63 99\n65 9\n69 10\n73 11\n90 15\n92 20\n3 23\n6 24\n7 25\n19 28\n26 48\n27 58\n29 59\n30 61\n32 62\n33 67\n37 75\n39 77\n46 80\n51 81\n52 88\n63 91\n65 97\n69 99\n70 4\n73 9\n78 10\n90 11\n92 15\n93 20\n98 23\n100 24\n3 25\n6 28\n7 42\n19 48\n21 54\n26 56\n27 58\n29 59\n30 61\n32 62\n33 64\n34 67\n37 72\n39 75\n46 77\n51 80\n52 81\n63 88\n65 91\n69 97\n70 99\n73 4\n78 9\n82 1..." }, { "input": "100 1000\n19 21 14 23 21 13 17 19 25 20 21 20 17 22 22 23 13 18 15 25 17 19 19 20 16 25 20 22 20 18 22 23 24 16 21 25 21 13 13 17 14 14 22 18 25 23 23 20 23 20 24 23 21 13 13 19 15 26 19 18 25 20 26 25 16 23 15 13 20 24 21 24 14 23 16 14 14 14 22 18 26 18 22 13 15 17 15 18 20 24 15 25 19 19 18 24 16 23 21 18", "output": "1 1000\n58 6\n63 17\n81 38\n9 39\n20 54\n26 55\n36 68\n45 84\n58 3\n61 6\n63 17\n64 38\n81 39\n92 41\n9 42\n20 54\n26 55\n33 68\n36 73\n45 76\n51 77\n58 78\n61 84\n63 3\n64 6\n70 17\n72 19\n81 38\n90 39\n92 41\n96 42\n4 54\n9 55\n16 57\n20 67\n26 68\n32 73\n33 76\n36 77\n45 78\n46 84\n47 85\n49 87\n51 91\n52 3\n58 6\n61 17\n63 19\n64 25\n66 34\n70 38\n72 39\n74 41\n81 42\n90 54\n92 55\n96 57\n98 65\n4 67\n9 68\n14 73\n15 75\n16 76\n20 77\n26 78\n28 84\n31 85\n32 87\n33 91\n36 97\n43 3\n45 6\n46 7\n47 13\n4..." }, { "input": "100 1000\n28 27 21 24 21 19 24 22 18 21 19 22 19 18 19 17 14 16 27 22 17 25 22 14 14 18 26 27 23 24 25 16 27 26 15 16 24 23 25 28 20 23 19 23 19 16 23 26 22 18 23 24 24 15 25 15 23 15 20 22 21 20 24 15 28 17 28 28 14 25 17 18 27 20 20 24 27 20 14 22 22 26 26 18 21 25 15 24 27 28 16 25 19 26 16 21 26 25 18 25", "output": "1 1000\n1 17\n40 24\n65 25\n67 69\n68 79\n90 17\n1 24\n2 25\n19 35\n28 54\n33 56\n40 58\n65 64\n67 69\n68 79\n73 87\n77 17\n89 18\n90 24\n1 25\n2 32\n19 35\n27 36\n28 46\n33 54\n34 56\n40 58\n48 64\n65 69\n67 79\n68 87\n73 91\n77 95\n82 16\n83 17\n89 18\n90 21\n94 24\n97 25\n1 32\n2 35\n19 36\n22 46\n27 54\n28 56\n31 58\n33 64\n34 66\n39 69\n40 71\n48 79\n55 87\n65 91\n67 95\n68 9\n70 14\n73 16\n77 17\n82 18\n83 21\n86 24\n89 25\n90 26\n92 32\n94 35\n97 36\n98 46\n100 50\n1 54\n2 56\n4 58\n7 64\n19 66\n22 ..." }, { "input": "100 1000\n21 30 21 17 25 18 25 29 30 23 17 24 18 22 21 28 22 25 29 21 29 15 22 17 26 21 29 17 21 29 17 21 22 26 20 19 24 18 27 17 23 26 25 22 18 29 23 28 25 21 15 16 15 16 27 16 24 27 26 27 28 26 28 20 18 30 16 15 21 28 28 18 18 28 21 21 23 23 18 18 21 24 29 21 15 28 17 28 24 17 28 23 24 26 30 25 23 24 24 20", "output": "1 1000\n2 22\n9 51\n66 53\n95 68\n2 85\n8 22\n9 51\n19 52\n21 53\n27 54\n30 56\n46 67\n66 68\n83 85\n95 4\n2 11\n8 22\n9 24\n16 28\n19 31\n21 40\n27 51\n30 52\n46 53\n48 54\n61 56\n63 67\n66 68\n70 85\n71 87\n74 90\n83 4\n86 6\n88 11\n91 13\n95 22\n2 24\n8 28\n9 31\n16 38\n19 40\n21 45\n27 51\n30 52\n39 53\n46 54\n48 56\n55 65\n58 67\n60 68\n61 72\n63 73\n66 79\n70 80\n71 85\n74 87\n83 90\n86 4\n88 6\n91 11\n95 13\n2 22\n8 24\n9 28\n16 31\n19 36\n21 38\n25 40\n27 45\n30 51\n34 52\n39 53\n42 54\n46 56\n48 6..." }, { "input": "25 166\n7516 5616 98 9956 8158 983 3595 4018 2527 8817 2733 7227 9335 2777 611 9941 7640 9697 3350 3056 5024 4597 4279 1190 4580", "output": "9602 166\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 3\n4 3\n16 ..." }, { "input": "37 228\n1921 4643 8245 4529 7141 3713 193 3069 2058 3009 4874 2284 7088 5200 5144 1944 9882 9945 1385 5297 5243 3180 6136 2854 9563 8091 2437 5001 7489 8247 6627 5247 9162 7414 9188 3037 9441", "output": "9379 228\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 7\n18 7\n17 ..." }, { "input": "53 234\n6870 7317 2200 589 6125 4283 4087 8472 6454 9905 663 444 2138 726 5486 4491 5771 7089 3611 5378 9653 9604 1640 4518 1841 6681 3753 7657 2078 9238 205 1475 4872 1114 2777 1914 3395 7263 5105 7773 3567 4552 2673 1778 5603 4210 7133 6077 5475 8420 919 4794 8123", "output": "9232 234\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 31\n10 3..." }, { "input": "17 944\n1274 536 346 5161 2949 4309 7981 7523 8690 9905 3748 5501 435 6253 19 6495 5308", "output": "8391 944\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 15\n10 1..." }, { "input": "29 462\n9871 507 4301 7030 1932 687 4578 6574 7278 3153 1697 7854 5485 1779 6712 9042 4845 4482 6031 6756 2123 419 1705 6358 46 1702 8818 2967 2745", "output": "8946 462\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 25\n1 2..." }, { "input": "4 1\n10000 3 3 3", "output": "9996 1\n1 2" }, { "input": "4 4\n2 2 2 3", "output": "1 4\n4 1\n1 2\n2 1\n1 2" }, { "input": "2 1\n10000 1", "output": "9997 1\n1 2" }, { "input": "4 3\n10000 3 3 3", "output": "9993 3\n1 2\n1 3\n1 4" }, { "input": "2 2\n1 3", "output": "0 1\n2 1" } ]

1,687,674,450

2,147,483,647

PyPy 3-64

TIME_LIMIT_EXCEEDED

TESTS

4

1,000

2,457,600

import sys def main(): read = sys.stdin.readline n, moves = (int(i) for i in read().split()) values = [int(val) for i, val in enumerate(read().split())] diff = float('inf') history = [] if n == 1: print(0, 0) return while moves > 0: max_val_idx = values.index(max(values)) min_val_idx = values.index(min(values)) if min_val_idx != max_val_idx: values[max_val_idx] -= 1 values[min_val_idx] += 1 moves -= 1 history.append((str(max_val_idx + 1), str(min_val_idx + 1))) print(max(values) - min(values), len(history)) for r in history: print(' '.join(r)) if __name__ == '__main__': main()

Title: Towers Time Limit: None seconds Memory Limit: None megabytes Problem Description: As you know, all the kids in Berland love playing with cubes. Little Petya has *n* towers consisting of cubes of the same size. Tower with number *i* consists of *a**i* cubes stacked one on top of the other. Petya defines the instability of a set of towers as a value equal to the difference between the heights of the highest and the lowest of the towers. For example, if Petya built five cube towers with heights (8, 3, 2, 6, 3), the instability of this set is equal to 6 (the highest tower has height 8, the lowest one has height 2). The boy wants the instability of his set of towers to be as low as possible. All he can do is to perform the following operation several times: take the top cube from some tower and put it on top of some other tower of his set. Please note that Petya would never put the cube on the same tower from which it was removed because he thinks it's a waste of time. Before going to school, the boy will have time to perform no more than *k* such operations. Petya does not want to be late for class, so you have to help him accomplish this task. Input Specification: The first line contains two space-separated positive integers *n* and *k* (1<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=1000) — the number of towers in the given set and the maximum number of operations Petya can perform. The second line contains *n* space-separated positive integers *a**i* (1<=≤<=*a**i*<=≤<=104) — the towers' initial heights. Output Specification: In the first line print two space-separated non-negative integers *s* and *m* (*m*<=≤<=*k*). The first number is the value of the minimum possible instability that can be obtained after performing at most *k* operations, the second number is the number of operations needed for that. In the next *m* lines print the description of each operation as two positive integers *i* and *j*, each of them lies within limits from 1 to *n*. They represent that Petya took the top cube from the *i*-th tower and put in on the *j*-th one (*i*<=≠<=*j*). Note that in the process of performing operations the heights of some towers can become equal to zero. If there are multiple correct sequences at which the minimum possible instability is achieved, you are allowed to print any of them. Demo Input: ['3 2\n5 8 5\n', '3 4\n2 2 4\n', '5 3\n8 3 2 6 3\n'] Demo Output: ['0 2\n2 1\n2 3\n', '1 1\n3 2\n', '3 3\n1 3\n1 2\n1 3\n'] Note: In the first sample you need to move the cubes two times, from the second tower to the third one and from the second one to the first one. Then the heights of the towers are all the same and equal to 6.

```python import sys def main(): read = sys.stdin.readline n, moves = (int(i) for i in read().split()) values = [int(val) for i, val in enumerate(read().split())] diff = float('inf') history = [] if n == 1: print(0, 0) return while moves > 0: max_val_idx = values.index(max(values)) min_val_idx = values.index(min(values)) if min_val_idx != max_val_idx: values[max_val_idx] -= 1 values[min_val_idx] += 1 moves -= 1 history.append((str(max_val_idx + 1), str(min_val_idx + 1))) print(max(values) - min(values), len(history)) for r in history: print(' '.join(r)) if __name__ == '__main__': main() ```

0

976

C

Nested Segments

PROGRAMMING

1,500

[ "greedy", "implementation", "sortings" ]

null

You are given a sequence *a*1,<=*a*2,<=...,<=*a**n* of one-dimensional segments numbered 1 through *n*. Your task is to find two distinct indices *i* and *j* such that segment *a**i* lies within segment *a**j*. Segment [*l*1,<=*r*1] lies within segment [*l*2,<=*r*2] iff *l*1<=≥<=*l*2 and *r*1<=≤<=*r*2. Print indices *i* and *j*. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

The first line contains one integer *n* (1<=≤<=*n*<=≤<=3·105) — the number of segments. Each of the next *n* lines contains two integers *l**i* and *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=109) — the *i*-th segment.

Print two distinct indices *i* and *j* such that segment *a**i* lies within segment *a**j*. If there are multiple answers, print any of them. If no answer exists, print -1 -1.

[ "5\n1 10\n2 9\n3 9\n2 3\n2 9\n", "3\n1 5\n2 6\n6 20\n" ]

[ "2 1\n", "-1 -1\n" ]

In the first example the following pairs are considered correct: - (2, 1), (3, 1), (4, 1), (5, 1) — not even touching borders; - (3, 2), (4, 2), (3, 5), (4, 5) — touch one border; - (5, 2), (2, 5) — match exactly.

0

[ { "input": "5\n1 10\n2 9\n3 9\n2 3\n2 9", "output": "2 1" }, { "input": "3\n1 5\n2 6\n6 20", "output": "-1 -1" }, { "input": "1\n1 1000000000", "output": "-1 -1" }, { "input": "2\n1 1000000000\n1 1000000000", "output": "2 1" }, { "input": "2\n1 1000000000\n500000000 500000000", "output": "2 1" }, { "input": "2\n1 10\n2 10", "output": "2 1" }, { "input": "2\n10 20\n10 11", "output": "2 1" }, { "input": "3\n1 10\n10 20\n9 11", "output": "-1 -1" }, { "input": "3\n1 1\n2 3\n2 2", "output": "3 2" }, { "input": "4\n1 10\n2 11\n3 10000000\n3 100000000", "output": "3 4" }, { "input": "2\n3 7\n3 9", "output": "1 2" }, { "input": "3\n1 2\n2 3\n1 2", "output": "3 1" }, { "input": "3\n5 6\n4 7\n3 8", "output": "2 3" }, { "input": "3\n2 9\n1 7\n2 8", "output": "3 1" }, { "input": "2\n1 4\n1 5", "output": "1 2" }, { "input": "3\n1 2\n1 3\n4 4", "output": "1 2" }, { "input": "3\n1 2\n1 3\n67 1234567", "output": "1 2" }, { "input": "2\n1 1\n1 1", "output": "2 1" }, { "input": "3\n1 5\n4 7\n3 9", "output": "2 3" }, { "input": "2\n1 1\n1 10", "output": "1 2" }, { "input": "2\n1 2\n1 3", "output": "1 2" }, { "input": "2\n1 10\n1 11", "output": "1 2" }, { "input": "2\n1 1\n1 2", "output": "1 2" }, { "input": "2\n2 3\n2 4", "output": "1 2" }, { "input": "2\n1 3\n3 3", "output": "2 1" }, { "input": "3\n1 10\n11 13\n12 12", "output": "3 2" }, { "input": "2\n2 10\n1 10", "output": "1 2" }, { "input": "3\n1 3\n4 5\n4 4", "output": "3 2" }, { "input": "5\n1 1\n2 6\n3 5\n10 15\n20 25", "output": "3 2" }, { "input": "3\n1 1000\n1001 1007\n1002 1007", "output": "3 2" }, { "input": "3\n1 3\n2 5\n3 4", "output": "3 2" }, { "input": "3\n1 10\n2 11\n3 11", "output": "3 2" }, { "input": "2\n2000000 999999999\n1000000 1000000000", "output": "1 2" }, { "input": "3\n2 10\n11 12\n4 5", "output": "3 1" }, { "input": "2\n1 10\n1 19", "output": "1 2" }, { "input": "4\n1 3\n100 102\n108 110\n1 3", "output": "4 1" }, { "input": "3\n1 3\n5 9\n5 6", "output": "3 2" }, { "input": "3\n1 3\n3 4\n3 5", "output": "2 3" }, { "input": "3\n1 2\n1 3\n1 4", "output": "2 3" }, { "input": "4\n2 3\n1 4\n100 200\n1000 2000", "output": "1 2" }, { "input": "3\n1 1\n2 100\n3 99", "output": "3 2" }, { "input": "3\n1 2\n1 3\n12 1234", "output": "1 2" }, { "input": "3\n1 4\n2 6\n3 5", "output": "3 2" }, { "input": "3\n1 10\n2 12\n1 9", "output": "3 1" }, { "input": "2\n1 3\n1 5", "output": "1 2" }, { "input": "3\n1 2\n2 5\n2 3", "output": "3 2" }, { "input": "4\n1 3\n1 4\n5 10\n11 13", "output": "1 2" }, { "input": "4\n7 15\n6 9\n9 10\n10 11", "output": "3 1" }, { "input": "4\n2 3\n100 200\n1000 2000\n1 4", "output": "1 4" }, { "input": "3\n10 20\n5 9\n11 19", "output": "3 1" }, { "input": "10\n1 2\n2 3\n3 4\n4 5\n5 6\n6 6\n6 7\n7 8\n8 9\n9 10", "output": "6 7" }, { "input": "2\n1 4\n1 7", "output": "1 2" }, { "input": "3\n1 11\n2 12\n2 13", "output": "2 3" }, { "input": "2\n1 4\n1 8", "output": "1 2" }, { "input": "2\n2 5\n1 5", "output": "1 2" }, { "input": "2\n2 9\n1 10", "output": "1 2" }, { "input": "3\n2 4\n2 4\n1 3", "output": "2 1" }, { "input": "6\n10 11\n12 13\n15 16\n15 17\n18 19\n59 60", "output": "3 4" }, { "input": "2\n1 3\n1 7", "output": "1 2" }, { "input": "5\n4 6\n7 60\n80 90\n4 5\n8 80", "output": "4 1" }, { "input": "2\n1 3\n1 4", "output": "1 2" }, { "input": "3\n2 9\n1 7\n2 9", "output": "3 1" }, { "input": "2\n1 4\n1 6", "output": "1 2" }, { "input": "3\n4 4\n2 3\n4 5", "output": "1 3" }, { "input": "2\n1 5\n1 7", "output": "1 2" }, { "input": "2\n1 2\n1 4", "output": "1 2" }, { "input": "4\n1 1\n2 2\n5 10\n2 4", "output": "2 4" }, { "input": "3\n11 12\n11 15\n43 45", "output": "1 2" }, { "input": "3\n2 3\n2 4\n2 5", "output": "2 3" }, { "input": "2\n2 3\n2 5", "output": "1 2" }, { "input": "3\n1 3\n1 4\n1 5", "output": "2 3" }, { "input": "3\n1 1\n1 2\n1 3", "output": "2 3" }, { "input": "2\n2 3\n1 3", "output": "1 2" }, { "input": "11\n22226 28285\n9095 23314\n19162 25530\n255 13298\n4904 25801\n17914 23501\n8441 28117\n11880 29994\n11123 19874\n21505 27971\n7658 14109", "output": "11 5" }, { "input": "8\n4 11\n5 12\n6 13\n7 14\n8 15\n9 16\n10 17\n1 11", "output": "1 8" }, { "input": "4\n1 10\n12 15\n1 3\n17 18", "output": "3 1" }, { "input": "3\n1 5\n1 10\n1 20", "output": "2 3" }, { "input": "3\n1 1000\n1001 1003\n1 1", "output": "3 1" }, { "input": "3\n1 10\n2 11\n2 11", "output": "3 2" }, { "input": "2\n1 1\n1 3", "output": "1 2" }, { "input": "2\n1 5\n1 6", "output": "1 2" }, { "input": "3\n1 5\n3 6\n1 4", "output": "3 1" }, { "input": "4\n2 8\n1 3\n2 9\n1 2", "output": "4 2" }, { "input": "3\n3 6\n1 3\n3 9", "output": "1 3" }, { "input": "6\n2 40\n5 50\n10 60\n3 45\n1 40\n100 111", "output": "1 5" }, { "input": "4\n1 2\n4 4\n3 3\n2 3", "output": "3 4" }, { "input": "4\n1 1\n4 5\n7 9\n1 1", "output": "4 1" }, { "input": "6\n30 35\n18 29\n28 32\n4 9\n1002 129212\n8 281", "output": "2 6" }, { "input": "2\n10 13\n10 14", "output": "1 2" }, { "input": "5\n2 4\n3 6\n4 5\n222 333\n111 444", "output": "3 2" }, { "input": "3\n1 2\n4 5\n1 1", "output": "3 1" }, { "input": "2\n2 100\n1 100", "output": "1 2" }, { "input": "3\n1 10\n9 20\n3 5", "output": "3 1" }, { "input": "2\n1 9\n1 10", "output": "1 2" }, { "input": "3\n1 2\n1 4\n1 6", "output": "2 3" } ]

1,525,105,575

6,375

Python 3

TIME_LIMIT_EXCEEDED

TESTS

11

2,000

7,065,600

n = int(input()) pairs = [] found = False for i in range(n): pairs += [tuple(map(int, input().split()))] for j in range(len(pairs)-1): if pairs[i][0] >= pairs[j][0] and pairs[i][1] <= pairs[j][1]: print(i+1, j+1) found = True if found: break if not found: print(-1, -1)

Title: Nested Segments Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a sequence *a*1,<=*a*2,<=...,<=*a**n* of one-dimensional segments numbered 1 through *n*. Your task is to find two distinct indices *i* and *j* such that segment *a**i* lies within segment *a**j*. Segment [*l*1,<=*r*1] lies within segment [*l*2,<=*r*2] iff *l*1<=≥<=*l*2 and *r*1<=≤<=*r*2. Print indices *i* and *j*. If there are multiple answers, print any of them. If no answer exists, print -1 -1. Input Specification: The first line contains one integer *n* (1<=≤<=*n*<=≤<=3·105) — the number of segments. Each of the next *n* lines contains two integers *l**i* and *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=109) — the *i*-th segment. Output Specification: Print two distinct indices *i* and *j* such that segment *a**i* lies within segment *a**j*. If there are multiple answers, print any of them. If no answer exists, print -1 -1. Demo Input: ['5\n1 10\n2 9\n3 9\n2 3\n2 9\n', '3\n1 5\n2 6\n6 20\n'] Demo Output: ['2 1\n', '-1 -1\n'] Note: In the first example the following pairs are considered correct: - (2, 1), (3, 1), (4, 1), (5, 1) — not even touching borders; - (3, 2), (4, 2), (3, 5), (4, 5) — touch one border; - (5, 2), (2, 5) — match exactly.

```python n = int(input()) pairs = [] found = False for i in range(n): pairs += [tuple(map(int, input().split()))] for j in range(len(pairs)-1): if pairs[i][0] >= pairs[j][0] and pairs[i][1] <= pairs[j][1]: print(i+1, j+1) found = True if found: break if not found: print(-1, -1) ```

0

797

A

k-Factorization

PROGRAMMING

1,100

[ "implementation", "math", "number theory" ]

null

Given a positive integer *n*, find *k* integers (not necessary distinct) such that all these integers are strictly greater than 1, and their product is equal to *n*.

The first line contains two integers *n* and *k* (2<=≤<=*n*<=≤<=100000, 1<=≤<=*k*<=≤<=20).

If it's impossible to find the representation of *n* as a product of *k* numbers, print -1. Otherwise, print *k* integers in any order. Their product must be equal to *n*. If there are multiple answers, print any of them.

[ "100000 2\n", "100000 20\n", "1024 5\n" ]

[ "2 50000 \n", "-1\n", "2 64 2 2 2 \n" ]

none

0

[ { "input": "100000 2", "output": "2 50000 " }, { "input": "100000 20", "output": "-1" }, { "input": "1024 5", "output": "2 64 2 2 2 " }, { "input": "100000 10", "output": "2 2 2 2 2 5 5 5 5 5 " }, { "input": "99999 3", "output": "3 813 41 " }, { "input": "99999 4", "output": "3 3 41 271 " }, { "input": "99999 5", "output": "-1" }, { "input": "1024 10", "output": "2 2 2 2 2 2 2 2 2 2 " }, { "input": "1024 11", "output": "-1" }, { "input": "2048 11", "output": "2 2 2 2 2 2 2 2 2 2 2 " }, { "input": "2 1", "output": "2 " }, { "input": "2 2", "output": "-1" }, { "input": "2 3", "output": "-1" }, { "input": "2 4", "output": "-1" }, { "input": "2 5", "output": "-1" }, { "input": "2 1", "output": "2 " }, { "input": "3 1", "output": "3 " }, { "input": "3 2", "output": "-1" }, { "input": "349 2", "output": "-1" }, { "input": "8 1", "output": "8 " }, { "input": "66049 2", "output": "257 257 " }, { "input": "6557 2", "output": "83 79 " }, { "input": "9 2", "output": "3 3 " }, { "input": "4 2", "output": "2 2 " }, { "input": "2 2", "output": "-1" }, { "input": "4 4", "output": "-1" }, { "input": "12 1", "output": "12 " }, { "input": "17 1", "output": "17 " }, { "input": "8 2", "output": "2 4 " }, { "input": "14 2", "output": "7 2 " }, { "input": "99991 1", "output": "99991 " }, { "input": "30 2", "output": "3 10 " }, { "input": "97 1", "output": "97 " }, { "input": "92 2", "output": "2 46 " }, { "input": "4 1", "output": "4 " }, { "input": "4 3", "output": "-1" }, { "input": "30 4", "output": "-1" }, { "input": "2 6", "output": "-1" }, { "input": "3 1", "output": "3 " }, { "input": "3 2", "output": "-1" }, { "input": "3 3", "output": "-1" }, { "input": "3 4", "output": "-1" }, { "input": "3 5", "output": "-1" }, { "input": "3 6", "output": "-1" }, { "input": "4 1", "output": "4 " }, { "input": "4 2", "output": "2 2 " }, { "input": "4 3", "output": "-1" }, { "input": "4 4", "output": "-1" }, { "input": "4 5", "output": "-1" }, { "input": "4 6", "output": "-1" }, { "input": "5 1", "output": "5 " }, { "input": "5 2", "output": "-1" }, { "input": "5 3", "output": "-1" }, { "input": "5 4", "output": "-1" }, { "input": "5 5", "output": "-1" }, { "input": "5 6", "output": "-1" }, { "input": "6 1", "output": "6 " }, { "input": "6 2", "output": "3 2 " }, { "input": "6 3", "output": "-1" }, { "input": "6 4", "output": "-1" }, { "input": "6 5", "output": "-1" }, { "input": "6 6", "output": "-1" }, { "input": "7 1", "output": "7 " }, { "input": "7 2", "output": "-1" }, { "input": "7 3", "output": "-1" }, { "input": "7 4", "output": "-1" }, { "input": "7 5", "output": "-1" }, { "input": "7 6", "output": "-1" }, { "input": "8 1", "output": "8 " }, { "input": "8 2", "output": "2 4 " }, { "input": "8 3", "output": "2 2 2 " }, { "input": "8 4", "output": "-1" }, { "input": "8 5", "output": "-1" }, { "input": "8 6", "output": "-1" }, { "input": "9 1", "output": "9 " }, { "input": "9 2", "output": "3 3 " }, { "input": "9 3", "output": "-1" }, { "input": "9 4", "output": "-1" }, { "input": "9 5", "output": "-1" }, { "input": "9 6", "output": "-1" }, { "input": "10 1", "output": "10 " }, { "input": "10 2", "output": "5 2 " }, { "input": "10 3", "output": "-1" }, { "input": "10 4", "output": "-1" }, { "input": "10 5", "output": "-1" }, { "input": "10 6", "output": "-1" }, { "input": "11 1", "output": "11 " }, { "input": "11 2", "output": "-1" }, { "input": "11 3", "output": "-1" }, { "input": "11 4", "output": "-1" }, { "input": "11 5", "output": "-1" }, { "input": "11 6", "output": "-1" }, { "input": "12 1", "output": "12 " }, { "input": "12 2", "output": "2 6 " }, { "input": "12 3", "output": "2 2 3 " }, { "input": "12 4", "output": "-1" }, { "input": "12 5", "output": "-1" }, { "input": "12 6", "output": "-1" }, { "input": "13 1", "output": "13 " }, { "input": "13 2", "output": "-1" }, { "input": "13 3", "output": "-1" }, { "input": "13 4", "output": "-1" }, { "input": "13 5", "output": "-1" }, { "input": "13 6", "output": "-1" }, { "input": "14 1", "output": "14 " }, { "input": "14 2", "output": "7 2 " }, { "input": "14 3", "output": "-1" }, { "input": "14 4", "output": "-1" }, { "input": "14 5", "output": "-1" }, { "input": "14 6", "output": "-1" }, { "input": "15 1", "output": "15 " }, { "input": "15 2", "output": "5 3 " }, { "input": "15 3", "output": "-1" }, { "input": "15 4", "output": "-1" }, { "input": "15 5", "output": "-1" }, { "input": "15 6", "output": "-1" }, { "input": "16 1", "output": "16 " }, { "input": "16 2", "output": "2 8 " }, { "input": "16 3", "output": "2 4 2 " }, { "input": "16 4", "output": "2 2 2 2 " }, { "input": "16 5", "output": "-1" }, { "input": "16 6", "output": "-1" }, { "input": "17 1", "output": "17 " }, { "input": "17 2", "output": "-1" }, { "input": "17 3", "output": "-1" }, { "input": "17 4", "output": "-1" }, { "input": "17 5", "output": "-1" }, { "input": "17 6", "output": "-1" }, { "input": "18 1", "output": "18 " }, { "input": "18 2", "output": "3 6 " }, { "input": "18 3", "output": "3 2 3 " }, { "input": "18 4", "output": "-1" }, { "input": "18 5", "output": "-1" }, { "input": "18 6", "output": "-1" }, { "input": "19 1", "output": "19 " }, { "input": "19 2", "output": "-1" }, { "input": "19 3", "output": "-1" }, { "input": "19 4", "output": "-1" }, { "input": "19 5", "output": "-1" }, { "input": "19 6", "output": "-1" }, { "input": "20 1", "output": "20 " }, { "input": "20 2", "output": "2 10 " }, { "input": "20 3", "output": "2 2 5 " }, { "input": "20 4", "output": "-1" }, { "input": "20 5", "output": "-1" }, { "input": "20 6", "output": "-1" }, { "input": "94249 1", "output": "94249 " }, { "input": "94249 2", "output": "307 307 " }, { "input": "94249 3", "output": "-1" }, { "input": "94249 4", "output": "-1" }, { "input": "94249 5", "output": "-1" }, { "input": "95477 1", "output": "95477 " }, { "input": "95477 2", "output": "311 307 " }, { "input": "95477 3", "output": "-1" }, { "input": "95477 4", "output": "-1" }, { "input": "95477 5", "output": "-1" }, { "input": "35557 1", "output": "35557 " }, { "input": "35557 2", "output": "31 1147 " }, { "input": "35557 3", "output": "31 31 37 " }, { "input": "35557 4", "output": "-1" }, { "input": "35557 5", "output": "-1" }, { "input": "42439 1", "output": "42439 " }, { "input": "42439 2", "output": "37 1147 " }, { "input": "42439 3", "output": "37 31 37 " }, { "input": "42439 4", "output": "-1" }, { "input": "42439 5", "output": "-1" } ]

1,631,992,885

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

62

6,963,200

n, k = map(int, input().split()) c, i, a = 0,2, n ans = [] while c < k-1 and i < n//2: if a%i == 0: c+= 1 ans.append(i) a = a//i i = 1 i+= 1 if c < k-1: print(-1) else: print(*ans,a)

Title: k-Factorization Time Limit: None seconds Memory Limit: None megabytes Problem Description: Given a positive integer *n*, find *k* integers (not necessary distinct) such that all these integers are strictly greater than 1, and their product is equal to *n*. Input Specification: The first line contains two integers *n* and *k* (2<=≤<=*n*<=≤<=100000, 1<=≤<=*k*<=≤<=20). Output Specification: If it's impossible to find the representation of *n* as a product of *k* numbers, print -1. Otherwise, print *k* integers in any order. Their product must be equal to *n*. If there are multiple answers, print any of them. Demo Input: ['100000 2\n', '100000 20\n', '1024 5\n'] Demo Output: ['2 50000 \n', '-1\n', '2 64 2 2 2 \n'] Note: none

```python n, k = map(int, input().split()) c, i, a = 0,2, n ans = [] while c < k-1 and i < n//2: if a%i == 0: c+= 1 ans.append(i) a = a//i i = 1 i+= 1 if c < k-1: print(-1) else: print(*ans,a) ```

0

5

A

Chat Servers Outgoing Traffic

PROGRAMMING

1,000

[ "implementation" ]

A. Chat Server's Outgoing Traffic

1

64

Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands: - Include a person to the chat ('Add' command). - Remove a person from the chat ('Remove' command). - Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command). Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands. Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends *l* bytes to each participant of the chat, where *l* is the length of the message. As Polycarp has no time, he is asking for your help in solving this problem.

Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following: - +<name> for 'Add' command. - -<name> for 'Remove' command. - <sender_name>:<message_text> for 'Send' command. <name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line. It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc. All names are case-sensitive.

Print a single number — answer to the problem.

[ "+Mike\nMike:hello\n+Kate\n+Dmitry\n-Dmitry\nKate:hi\n-Kate\n", "+Mike\n-Mike\n+Mike\nMike:Hi I am here\n-Mike\n+Kate\n-Kate\n" ]

[ "9\n", "14\n" ]

none

0

[ { "input": "+Mike\nMike:hello\n+Kate\n+Dmitry\n-Dmitry\nKate:hi\n-Kate", "output": "9" }, { "input": "+Mike\n-Mike\n+Mike\nMike:Hi I am here\n-Mike\n+Kate\n-Kate", "output": "14" }, { "input": "+Dmitry\n+Mike\nDmitry:All letters will be used\nDmitry:qwertyuiopasdfghjklzxcvbnm QWERTYUIOPASDFGHJKLZXCVBNM\nDmitry:And digits too\nDmitry:1234567890 0987654321\n-Dmitry", "output": "224" }, { "input": "+Dmitry\n+Mike\n+Kate\nDmitry:", "output": "0" }, { "input": "+Dmitry\nDmitry:No phrases with spaces at the beginning and at the end\n+Mike\nDmitry:spaces spaces\n-Dmitry", "output": "86" }, { "input": "+XqD\n+aT537\nXqD:x6ZPjMR1DDKG2\nXqD:lLCriywPnB\n-XqD", "output": "46" }, { "input": "+8UjgAJ\n8UjgAJ:02hR7UBc1tqqfL\n-8UjgAJ\n+zdi\n-zdi", "output": "14" }, { "input": "+6JPKkgXDrA\n+j6JHjv70An\n+QGtsceK0zJ\n6JPKkgXDrA:o4\n+CSmwi9zDra\nQGtsceK0zJ:Zl\nQGtsceK0zJ:0\nj6JHjv70An:7\nj6JHjv70An:B\nQGtsceK0zJ:OO", "output": "34" }, { "input": "+1aLNq9S7uLV\n-1aLNq9S7uLV\n+O9ykq3xDJv\n-O9ykq3xDJv\n+54Yq1xJq14F\n+0zJ5Vo0RDZ\n-54Yq1xJq14F\n-0zJ5Vo0RDZ\n+lxlH7sdolyL\n-lxlH7sdolyL", "output": "0" }, { "input": "+qlHEc2AuYy\nqlHEc2AuYy:YYRwD0 edNZgpE nGfOguRWnMYpTpGUVM aXDKGXo1Gv1tHL9\nqlHEc2AuYy:yvh3GsPcImqrvoUcBNQcP6ezwpU0 xAVltaKZp94VKiNao\nqlHEc2AuYy:zuCO6Opey L eu7lTwysaSk00zjpv zrDfbt8l hpHfu\n+pErDMxgVgh\nqlHEc2AuYy:I1FLis mmQbZtd8Ui7y 1vcax6yZBMhVRdD6Ahlq7MNCw\nqlHEc2AuYy:lz MFUNJZhlqBYckHUDlNhLiEkmecRh1o0t7alXBvCRVEFVx\npErDMxgVgh:jCyMbu1dkuEj5TzbBOjyUhpfC50cL8R900Je3R KxRgAI dT\nqlHEc2AuYy:62b47eabo2hf vSUD7KioN ZHki6WB6gh3u GKv5rgwyfF\npErDMxgVgh:zD5 9 ympl4wR gy7a7eAGAn5xVdGP9FbL6hRCZAR6O4pT6zb", "output": "615" }, { "input": "+adabacaba0", "output": "0" }, { "input": "+acabadab\n+caba0aba", "output": "0" }, { "input": "+dabaca\n-dabaca\n+aba0ab", "output": "0" }, { "input": "+cab\n+abac\n-abac\n+baca", "output": "0" }, { "input": "+cabadabac\n-cabadabac\n+abacaba1ab\n-abacaba1ab\n+ba0abaca", "output": "0" }, { "input": "+adabacaba\n-adabacaba\n+aca\naca:caba\n-aca\n+bacaba\n-bacaba\n+aba\n-aba\n+bad", "output": "4" }, { "input": "+acabadab\n-acabadab\n+aba0abacab\n+baca\n+abacaba0ab\n-baca\n-abacaba0ab\n-aba0abacab\n+cab\n-cab\n+abacabada\n-abacabada\n+badabaca\n-badabaca\n+badaba", "output": "0" }, { "input": "+badabac\nbadabac:abacabad\n-badabac\n+0ab\n-0ab\n+dabacab\n-dabacab\n+a0ab\n-a0ab\n+0abaca\n-0abaca\n+dabac\n-dabac\n+abaca\n-abaca\n+bacabada\n-bacabada\n+aca\n-aca\n+abadabaca\n-abadabaca\n+acaba\n-acaba\n+abacabadab\n-abacabadab", "output": "8" } ]

1,670,380,775

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

30

0

# LUOGU_RID: 96738129 p=0 r=0 while (a:=input()): j=0 if a[0]=="+": p+=1 elif a[0]=="-": p-=1 else: for i in a: j+=1 if i==":": break r+=(len(a[j:])*p) print(r)

Title: Chat Servers Outgoing Traffic Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands: - Include a person to the chat ('Add' command). - Remove a person from the chat ('Remove' command). - Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command). Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands. Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends *l* bytes to each participant of the chat, where *l* is the length of the message. As Polycarp has no time, he is asking for your help in solving this problem. Input Specification: Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following: - +<name> for 'Add' command. - -<name> for 'Remove' command. - <sender_name>:<message_text> for 'Send' command. <name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line. It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc. All names are case-sensitive. Output Specification: Print a single number — answer to the problem. Demo Input: ['+Mike\nMike:hello\n+Kate\n+Dmitry\n-Dmitry\nKate:hi\n-Kate\n', '+Mike\n-Mike\n+Mike\nMike:Hi I am here\n-Mike\n+Kate\n-Kate\n'] Demo Output: ['9\n', '14\n'] Note: none

```python # LUOGU_RID: 96738129 p=0 r=0 while (a:=input()): j=0 if a[0]=="+": p+=1 elif a[0]=="-": p-=1 else: for i in a: j+=1 if i==":": break r+=(len(a[j:])*p) print(r) ```

-1

961

B

Lecture Sleep

PROGRAMMING

1,200

[ "data structures", "dp", "implementation", "two pointers" ]

null

Your friend Mishka and you attend a calculus lecture. Lecture lasts *n* minutes. Lecturer tells *a**i* theorems during the *i*-th minute. Mishka is really interested in calculus, though it is so hard to stay awake for all the time of lecture. You are given an array *t* of Mishka's behavior. If Mishka is asleep during the *i*-th minute of the lecture then *t**i* will be equal to 0, otherwise it will be equal to 1. When Mishka is awake he writes down all the theorems he is being told — *a**i* during the *i*-th minute. Otherwise he writes nothing. You know some secret technique to keep Mishka awake for *k* minutes straight. However you can use it only once. You can start using it at the beginning of any minute between 1 and *n*<=-<=*k*<=+<=1. If you use it on some minute *i* then Mishka will be awake during minutes *j* such that and will write down all the theorems lecturer tells. You task is to calculate the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up.

The first line of the input contains two integer numbers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=105) — the duration of the lecture in minutes and the number of minutes you can keep Mishka awake. The second line of the input contains *n* integer numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=104) — the number of theorems lecturer tells during the *i*-th minute. The third line of the input contains *n* integer numbers *t*1,<=*t*2,<=... *t**n* (0<=≤<=*t**i*<=≤<=1) — type of Mishka's behavior at the *i*-th minute of the lecture.

Print only one integer — the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up.

[ "6 3\n1 3 5 2 5 4\n1 1 0 1 0 0\n" ]

[ "16\n" ]

In the sample case the better way is to use the secret technique at the beginning of the third minute. Then the number of theorems Mishka will be able to write down will be equal to 16.

0

[ { "input": "6 3\n1 3 5 2 5 4\n1 1 0 1 0 0", "output": "16" }, { "input": "5 3\n1 9999 10000 10000 10000\n0 0 0 0 0", "output": "30000" }, { "input": "3 3\n10 10 10\n1 1 0", "output": "30" }, { "input": "1 1\n423\n0", "output": "423" }, { "input": "6 6\n1 3 5 2 5 4\n1 1 0 1 0 0", "output": "20" }, { "input": "5 2\n1 2 3 4 20\n0 0 0 1 0", "output": "24" }, { "input": "3 1\n1 2 3\n0 0 1", "output": "5" }, { "input": "4 2\n4 5 6 8\n1 0 1 0", "output": "18" }, { "input": "6 3\n1 3 5 2 1 15\n1 1 0 1 0 0", "output": "22" }, { "input": "5 5\n1 2 3 4 5\n1 1 1 0 1", "output": "15" }, { "input": "3 3\n3 3 3\n1 0 1", "output": "9" }, { "input": "5 5\n500 44 3 4 50\n1 0 0 0 0", "output": "601" }, { "input": "2 2\n3 2\n1 0", "output": "5" }, { "input": "7 6\n4 9 1 7 1 8 4\n0 0 0 1 0 1 0", "output": "30" }, { "input": "4 3\n6 5 9 6\n1 1 0 1", "output": "26" }, { "input": "2 1\n3 2\n0 0", "output": "3" }, { "input": "1 1\n10\n0", "output": "10" }, { "input": "2 1\n3 2\n1 0", "output": "5" }, { "input": "4 2\n3 6 7 2\n0 0 1 1", "output": "18" }, { "input": "10 5\n3 5 9 2 5 9 3 8 8 1\n0 1 1 1 0 1 0 0 0 0", "output": "49" }, { "input": "10 4\n9 5 6 4 3 9 5 1 10 7\n0 0 0 0 0 0 1 0 0 1", "output": "36" }, { "input": "9 8\n3 3 7 7 1 9 10 7 1\n1 1 1 1 1 1 1 1 1", "output": "48" }, { "input": "2 1\n3 4\n0 0", "output": "4" }, { "input": "2 1\n3 2\n0 1", "output": "5" }, { "input": "10 1\n6 6 8 7 6 6 3 2 5 6\n0 0 1 0 0 1 0 1 1 1", "output": "34" }, { "input": "3 2\n10 10 6\n0 0 0", "output": "20" }, { "input": "6 3\n1 3 5 2 5 4\n1 1 1 1 1 1", "output": "20" }, { "input": "10 5\n1 1 1 1 1 1 1 1 10000 1\n1 1 1 1 1 1 1 1 0 1", "output": "10009" } ]

1,672,689,739

2,147,483,647

Python 3

OK

TESTS

37

156

7,372,800

n, k = map(int, input().split()) points = list(map(int, input().split())) sleep_status = list(map(int, input().split())) l = 1 r = k window_gain = 0 for i in range(k): window_gain += points[i] * (sleep_status[i] == 0) current_window = window_gain for i in range(k, n): current_window -= points[i-k] * (sleep_status[i-k] == 0) current_window += points[i] * (sleep_status[i] == 0) window_gain = max(window_gain, current_window) result = window_gain for i in range(n): if sleep_status[i] == 1: result += points[i] print(result)

Title: Lecture Sleep Time Limit: None seconds Memory Limit: None megabytes Problem Description: Your friend Mishka and you attend a calculus lecture. Lecture lasts *n* minutes. Lecturer tells *a**i* theorems during the *i*-th minute. Mishka is really interested in calculus, though it is so hard to stay awake for all the time of lecture. You are given an array *t* of Mishka's behavior. If Mishka is asleep during the *i*-th minute of the lecture then *t**i* will be equal to 0, otherwise it will be equal to 1. When Mishka is awake he writes down all the theorems he is being told — *a**i* during the *i*-th minute. Otherwise he writes nothing. You know some secret technique to keep Mishka awake for *k* minutes straight. However you can use it only once. You can start using it at the beginning of any minute between 1 and *n*<=-<=*k*<=+<=1. If you use it on some minute *i* then Mishka will be awake during minutes *j* such that and will write down all the theorems lecturer tells. You task is to calculate the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up. Input Specification: The first line of the input contains two integer numbers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=105) — the duration of the lecture in minutes and the number of minutes you can keep Mishka awake. The second line of the input contains *n* integer numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=104) — the number of theorems lecturer tells during the *i*-th minute. The third line of the input contains *n* integer numbers *t*1,<=*t*2,<=... *t**n* (0<=≤<=*t**i*<=≤<=1) — type of Mishka's behavior at the *i*-th minute of the lecture. Output Specification: Print only one integer — the maximum number of theorems Mishka will be able to write down if you use your technique only once to wake him up. Demo Input: ['6 3\n1 3 5 2 5 4\n1 1 0 1 0 0\n'] Demo Output: ['16\n'] Note: In the sample case the better way is to use the secret technique at the beginning of the third minute. Then the number of theorems Mishka will be able to write down will be equal to 16.

```python n, k = map(int, input().split()) points = list(map(int, input().split())) sleep_status = list(map(int, input().split())) l = 1 r = k window_gain = 0 for i in range(k): window_gain += points[i] * (sleep_status[i] == 0) current_window = window_gain for i in range(k, n): current_window -= points[i-k] * (sleep_status[i-k] == 0) current_window += points[i] * (sleep_status[i] == 0) window_gain = max(window_gain, current_window) result = window_gain for i in range(n): if sleep_status[i] == 1: result += points[i] print(result) ```

3

670

B

Game of Robots

PROGRAMMING

1,000

[ "implementation" ]

null

In late autumn evening *n* robots gathered in the cheerful company of friends. Each robot has a unique identifier — an integer from 1 to 109. At some moment, robots decided to play the game "Snowball". Below there are the rules of this game. First, all robots stand in a row. Then the first robot says his identifier. After that the second robot says the identifier of the first robot and then says his own identifier. Then the third robot says the identifier of the first robot, then says the identifier of the second robot and after that says his own. This process continues from left to right until the *n*-th robot says his identifier. Your task is to determine the *k*-th identifier to be pronounced.

The first line contains two positive integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=*min*(2·109,<=*n*·(*n*<=+<=1)<=/<=2). The second line contains the sequence *id*1,<=*id*2,<=...,<=*id**n* (1<=≤<=*id**i*<=≤<=109) — identifiers of roborts. It is guaranteed that all identifiers are different.

Print the *k*-th pronounced identifier (assume that the numeration starts from 1).

[ "2 2\n1 2\n", "4 5\n10 4 18 3\n" ]

[ "1\n", "4\n" ]

In the first sample identifiers of robots will be pronounced in the following order: 1, 1, 2. As *k* = 2, the answer equals to 1. In the second test case identifiers of robots will be pronounced in the following order: 10, 10, 4, 10, 4, 18, 10, 4, 18, 3. As *k* = 5, the answer equals to 4.

750

[ { "input": "2 2\n1 2", "output": "1" }, { "input": "4 5\n10 4 18 3", "output": "4" }, { "input": "1 1\n4", "output": "4" }, { "input": "2 1\n5 1", "output": "5" }, { "input": "2 2\n1 4", "output": "1" }, { "input": "2 3\n6 7", "output": "7" }, { "input": "3 1\n4 5 6", "output": "4" }, { "input": "3 2\n4 5 6", "output": "4" }, { "input": "3 3\n4 5 6", "output": "5" }, { "input": "3 4\n4 5 6", "output": "4" }, { "input": "3 5\n4 5 6", "output": "5" }, { "input": "3 6\n4 5 6", "output": "6" }, { "input": "4 1\n5 1000000000 999999999 12", "output": "5" }, { "input": "4 2\n5 1000000000 999999999 12", "output": "5" }, { "input": "4 3\n5 1000000000 999999999 12", "output": "1000000000" }, { "input": "4 4\n5 1000000000 999999999 12", "output": "5" }, { "input": "4 5\n5 1000000000 999999999 12", "output": "1000000000" }, { "input": "4 6\n5 1000000000 999999999 12", "output": "999999999" }, { "input": "4 7\n5 1000000000 999999999 12", "output": "5" }, { "input": "4 8\n5 1000000000 999999999 12", "output": "1000000000" }, { "input": "4 9\n5 1000000000 999999999 12", "output": "999999999" }, { "input": "4 10\n5 1000000000 999999999 12", "output": "12" } ]

1,638,111,185

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

12

514

9,625,600

n, k = [int(x) for x in input().split(' ')] robots = [int(x) for x in input().split(' ')] def recursive_list(i, c, l): if i == c: return [l[c]] else: return [l[c]] + recursive_list(i, c + 1, l) lista = [] for i in range(len(robots)): lista += recursive_list(i, 0, robots) if len(lista) >= k: break print(lista[k - 1])

Title: Game of Robots Time Limit: None seconds Memory Limit: None megabytes Problem Description: In late autumn evening *n* robots gathered in the cheerful company of friends. Each robot has a unique identifier — an integer from 1 to 109. At some moment, robots decided to play the game "Snowball". Below there are the rules of this game. First, all robots stand in a row. Then the first robot says his identifier. After that the second robot says the identifier of the first robot and then says his own identifier. Then the third robot says the identifier of the first robot, then says the identifier of the second robot and after that says his own. This process continues from left to right until the *n*-th robot says his identifier. Your task is to determine the *k*-th identifier to be pronounced. Input Specification: The first line contains two positive integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=*min*(2·109,<=*n*·(*n*<=+<=1)<=/<=2). The second line contains the sequence *id*1,<=*id*2,<=...,<=*id**n* (1<=≤<=*id**i*<=≤<=109) — identifiers of roborts. It is guaranteed that all identifiers are different. Output Specification: Print the *k*-th pronounced identifier (assume that the numeration starts from 1). Demo Input: ['2 2\n1 2\n', '4 5\n10 4 18 3\n'] Demo Output: ['1\n', '4\n'] Note: In the first sample identifiers of robots will be pronounced in the following order: 1, 1, 2. As *k* = 2, the answer equals to 1. In the second test case identifiers of robots will be pronounced in the following order: 10, 10, 4, 10, 4, 18, 10, 4, 18, 3. As *k* = 5, the answer equals to 4.

```python n, k = [int(x) for x in input().split(' ')] robots = [int(x) for x in input().split(' ')] def recursive_list(i, c, l): if i == c: return [l[c]] else: return [l[c]] + recursive_list(i, c + 1, l) lista = [] for i in range(len(robots)): lista += recursive_list(i, 0, robots) if len(lista) >= k: break print(lista[k - 1]) ```

-1

343

B

Alternating Current

PROGRAMMING

1,600

[ "data structures", "greedy", "implementation" ]

null

Mad scientist Mike has just finished constructing a new device to search for extraterrestrial intelligence! He was in such a hurry to launch it for the first time that he plugged in the power wires without giving it a proper glance and started experimenting right away. After a while Mike observed that the wires ended up entangled and now have to be untangled again. The device is powered by two wires "plus" and "minus". The wires run along the floor from the wall (on the left) to the device (on the right). Both the wall and the device have two contacts in them on the same level, into which the wires are plugged in some order. The wires are considered entangled if there are one or more places where one wire runs above the other one. For example, the picture below has four such places (top view): Mike knows the sequence in which the wires run above each other. Mike also noticed that on the left side, the "plus" wire is always plugged into the top contact (as seen on the picture). He would like to untangle the wires without unplugging them and without moving the device. Determine if it is possible to do that. A wire can be freely moved and stretched on the floor, but cannot be cut. To understand the problem better please read the notes to the test samples.

The single line of the input contains a sequence of characters "+" and "-" of length *n* (1<=≤<=*n*<=≤<=100000). The *i*-th (1<=≤<=*i*<=≤<=*n*) position of the sequence contains the character "+", if on the *i*-th step from the wall the "plus" wire runs above the "minus" wire, and the character "-" otherwise.

Print either "Yes" (without the quotes) if the wires can be untangled or "No" (without the quotes) if the wires cannot be untangled.

[ "-++-\n", "+-\n", "++\n", "-\n" ]

[ "Yes\n", "No\n", "Yes\n", "No\n" ]

The first testcase corresponds to the picture in the statement. To untangle the wires, one can first move the "plus" wire lower, thus eliminating the two crosses in the middle, and then draw it under the "minus" wire, eliminating also the remaining two crosses. In the second testcase the "plus" wire makes one full revolution around the "minus" wire. Thus the wires cannot be untangled: In the third testcase the "plus" wire simply runs above the "minus" wire twice in sequence. The wires can be untangled by lifting "plus" and moving it higher: In the fourth testcase the "minus" wire runs above the "plus" wire once. The wires cannot be untangled without moving the device itself:

1,000

[ { "input": "-++-", "output": "Yes" }, { "input": "+-", "output": "No" }, { "input": "++", "output": "Yes" }, { "input": "-", "output": "No" }, { "input": "+-+-", "output": "No" }, { "input": "-+-", "output": "No" }, { "input": "-++-+--+", "output": "Yes" }, { "input": "+", "output": "No" }, { "input": "-+", "output": "No" }, { "input": "--", "output": "Yes" }, { "input": "+++", "output": "No" }, { "input": "--+", "output": "No" }, { "input": "++--++", "output": "Yes" }, { "input": "+-++-+", "output": "Yes" }, { "input": "+-+--+", "output": "No" }, { "input": "--++-+", "output": "No" }, { "input": "-+-+--", "output": "No" }, { "input": "+-+++-", "output": "No" }, { "input": "-+-+-+", "output": "No" }, { "input": "-++-+--++--+-++-", "output": "Yes" }, { "input": "+-----+-++---+------+++-++++", "output": "No" }, { "input": "-+-++--+++-++++---+--+----+--+-+-+++-+++-+---++-++++-+--+--+--+-+-++-+-+-++++++---++--+++++-+--++--+-+--++-----+--+-++---+++---++----+++-++++--++-++-", "output": "No" }, { "input": "-+-----++++--++-+-++", "output": "Yes" }, { "input": "+--+--+------+++++++-+-+++--++---+--+-+---+--+++-+++-------+++++-+-++++--+-+-+++++++----+----+++----+-+++-+++-----+++-+-++-+-+++++-+--++----+--+-++-----+-+-++++---+++---+-+-+-++++--+--+++---+++++-+---+-----+++-++--+++---++-++-+-+++-+-+-+---+++--+--++++-+-+--++-------+--+---++-----+++--+-+++--++-+-+++-++--+++-++++++++++-++-++++++-+++--+--++-+++--+++-++++----+++---+-+----++++-+-+", "output": "Yes" }, { "input": "-+-+-++-+-+-", "output": "Yes" }, { "input": "-+-++-+-", "output": "Yes" }, { "input": "-+-++-+-+-", "output": "No" }, { "input": "++-+-+-+-+--+", "output": "No" }, { "input": "+++---", "output": "No" }, { "input": "+-+-+-+-+--+-+-+-+-++--++--+", "output": "Yes" }, { "input": "+-+-++", "output": "No" }, { "input": "-++--+--+++-+-+-+-+-", "output": "No" }, { "input": "+---+-+-", "output": "No" }, { "input": "+-+--+-+", "output": "Yes" }, { "input": "+++---+++---", "output": "No" }, { "input": "-+++++", "output": "No" }, { "input": "-+-+-+-+-+-+-++-+-+-+-+-+-+-", "output": "Yes" }, { "input": "-+++--", "output": "No" }, { "input": "+---+", "output": "No" }, { "input": "-++", "output": "No" }, { "input": "-+--+-", "output": "Yes" }, { "input": "+---++--++", "output": "No" }, { "input": "+++-", "output": "No" }, { "input": "--+++", "output": "No" }, { "input": "++-+", "output": "No" } ]

1,646,475,604

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

6

62

0

n = input() stack = [n[0]] for i in range(1,len(n)): if n[i]==stack[-1]: stack.pop() else: stack.append(n[i]) # print(stack) if len(stack)==0: print("Yes") else: print("No")

Title: Alternating Current Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mad scientist Mike has just finished constructing a new device to search for extraterrestrial intelligence! He was in such a hurry to launch it for the first time that he plugged in the power wires without giving it a proper glance and started experimenting right away. After a while Mike observed that the wires ended up entangled and now have to be untangled again. The device is powered by two wires "plus" and "minus". The wires run along the floor from the wall (on the left) to the device (on the right). Both the wall and the device have two contacts in them on the same level, into which the wires are plugged in some order. The wires are considered entangled if there are one or more places where one wire runs above the other one. For example, the picture below has four such places (top view): Mike knows the sequence in which the wires run above each other. Mike also noticed that on the left side, the "plus" wire is always plugged into the top contact (as seen on the picture). He would like to untangle the wires without unplugging them and without moving the device. Determine if it is possible to do that. A wire can be freely moved and stretched on the floor, but cannot be cut. To understand the problem better please read the notes to the test samples. Input Specification: The single line of the input contains a sequence of characters "+" and "-" of length *n* (1<=≤<=*n*<=≤<=100000). The *i*-th (1<=≤<=*i*<=≤<=*n*) position of the sequence contains the character "+", if on the *i*-th step from the wall the "plus" wire runs above the "minus" wire, and the character "-" otherwise. Output Specification: Print either "Yes" (without the quotes) if the wires can be untangled or "No" (without the quotes) if the wires cannot be untangled. Demo Input: ['-++-\n', '+-\n', '++\n', '-\n'] Demo Output: ['Yes\n', 'No\n', 'Yes\n', 'No\n'] Note: The first testcase corresponds to the picture in the statement. To untangle the wires, one can first move the "plus" wire lower, thus eliminating the two crosses in the middle, and then draw it under the "minus" wire, eliminating also the remaining two crosses. In the second testcase the "plus" wire makes one full revolution around the "minus" wire. Thus the wires cannot be untangled: In the third testcase the "plus" wire simply runs above the "minus" wire twice in sequence. The wires can be untangled by lifting "plus" and moving it higher: In the fourth testcase the "minus" wire runs above the "plus" wire once. The wires cannot be untangled without moving the device itself:

```python n = input() stack = [n[0]] for i in range(1,len(n)): if n[i]==stack[-1]: stack.pop() else: stack.append(n[i]) # print(stack) if len(stack)==0: print("Yes") else: print("No") ```

-1

120

C

Winnie-the-Pooh and honey

PROGRAMMING

1,100

[ "implementation", "math" ]

null

As we all know, Winnie-the-Pooh just adores honey. Ones he and the Piglet found out that the Rabbit has recently gotten hold of an impressive amount of this sweet and healthy snack. As you may guess, Winnie and the Piglet asked to come at the Rabbit's place. Thus, there are *n* jars of honey lined up in front of Winnie-the-Pooh, jar number *i* contains *a**i* kilos of honey. Winnie-the-Pooh eats the honey like that: each time he chooses a jar containing most honey. If the jar has less that *k* kilos of honey or if Winnie-the-Pooh has already eaten from it three times, he gives the jar to Piglet. Otherwise he eats exactly *k* kilos of honey from the jar and puts it back. Winnie does so until he gives all jars to the Piglet. Count how much honey Piglet will overall get after Winnie satisfies his hunger.

The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*k*<=≤<=100). The second line contains *n* integers *a*1, *a*2, ..., *a**n*, separated by spaces (1<=≤<=*a**i*<=≤<=100).

Print a single number — how many kilos of honey gets Piglet.

[ "3 3\n15 8 10\n" ]

[ "9\n" ]

none

0

[ { "input": "3 3\n15 8 10", "output": "9" }, { "input": "1 3\n3", "output": "0" }, { "input": "3 4\n3 8 2", "output": "5" }, { "input": "3 2\n95 25 49", "output": "151" }, { "input": "3 1\n8 3 2", "output": "5" }, { "input": "5 1\n4 7 9 5 7", "output": "17" }, { "input": "8 6\n19 15 1 14 7 2 10 14", "output": "16" }, { "input": "8 5\n5 2 17 12 16 12 17 3", "output": "14" }, { "input": "10 7\n26 11 10 8 5 20 9 27 30 9", "output": "43" }, { "input": "10 10\n20 82 19 82 18 96 40 99 87 2", "output": "325" }, { "input": "10 10\n75 52 78 83 60 31 46 28 33 17", "output": "233" }, { "input": "20 5\n33 45 36 13 46 40 15 11 29 44 43 50 14 19 46 46 46 26 42 6", "output": "375" }, { "input": "20 2\n4 2 6 9 8 4 4 7 2 3 7 7 10 6 3 5 2 9 8 5", "output": "21" }, { "input": "30 3\n20 37 89 77 74 6 52 87 19 58 3 38 40 38 42 12 1 23 29 38 12 65 15 1 92 45 23 94 61 73", "output": "1021" }, { "input": "30 2\n10 5 46 30 28 18 24 35 73 2 10 24 72 86 97 95 71 12 14 57 27 94 81 59 43 77 22 58 16 96", "output": "1208" }, { "input": "50 13\n53 55 51 81 59 22 11 20 30 80 38 17 8 38 69 52 11 74 16 38 80 97 39 74 78 56 75 28 4 58 80 88 78 89 95 8 13 70 36 29 49 15 74 44 19 52 42 59 92 37", "output": "1012" }, { "input": "100 33\n84 70 12 53 10 38 4 66 42 1 100 98 42 10 31 26 22 94 19 43 86 5 37 64 77 98 81 40 17 66 52 43 5 7 79 92 44 78 9 95 10 86 42 56 34 91 12 17 26 16 24 99 11 37 89 100 60 74 32 66 13 29 3 24 41 99 93 87 85 74 5 3 70 46 23 12 43 10 24 32 95 2 57 86 29 100 29 62 17 24 4 40 40 73 29 11 69 89 10 31", "output": "1467" }, { "input": "100 12\n90 59 100 12 82 31 66 28 7 13 43 42 48 94 60 32 20 92 37 39 22 55 14 23 77 56 21 55 10 89 93 79 5 80 40 80 6 15 56 82 68 61 32 100 23 7 13 92 32 82 17 85 49 85 13 75 4 7 42 14 84 22 50 12 11 75 4 85 32 96 56 13 34 100 66 37 58 58 24 58 81 63 59 55 89 97 90 69 29 11 71 58 58 43 72 96 81 72 14 64", "output": "2377" }, { "input": "100 3\n92 51 91 67 32 97 40 24 78 72 93 90 57 77 66 13 55 24 17 90 65 35 69 97 79 31 85 2 90 80 49 44 73 77 34 45 74 75 35 14 34 56 60 54 36 55 16 49 12 54 92 68 70 71 5 79 67 89 64 80 20 84 4 39 55 84 53 59 68 11 89 89 15 73 67 86 91 78 49 24 58 83 55 34 82 97 27 29 78 15 20 48 9 87 41 34 91 76 82 44", "output": "4839" }, { "input": "100 1\n85 75 55 65 39 26 47 16 9 11 3 4 70 23 56 64 36 34 16 13 18 28 32 80 8 79 76 4 21 75 93 51 85 86 100 88 91 71 97 28 66 22 47 87 91 95 3 56 81 53 88 90 21 30 74 45 58 73 36 40 70 51 28 75 20 54 69 52 14 48 52 53 91 81 32 68 16 48 60 66 91 32 55 42 93 51 3 46 23 64 39 1 30 42 20 83 99 29 35 59", "output": "4801" } ]

1,563,172,091

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

2

248

0

import sys sys.stdin=open("input.txt",'r') sys.stdout=open("output.txt",'w') n,k=map(int,input().split()) a=list(map(int,input().split())) x=0 for i in range(n): if a[i]>9: x+=a[i]-9 else: x+=a[i]%3 print(x)

Title: Winnie-the-Pooh and honey Time Limit: None seconds Memory Limit: None megabytes Problem Description: As we all know, Winnie-the-Pooh just adores honey. Ones he and the Piglet found out that the Rabbit has recently gotten hold of an impressive amount of this sweet and healthy snack. As you may guess, Winnie and the Piglet asked to come at the Rabbit's place. Thus, there are *n* jars of honey lined up in front of Winnie-the-Pooh, jar number *i* contains *a**i* kilos of honey. Winnie-the-Pooh eats the honey like that: each time he chooses a jar containing most honey. If the jar has less that *k* kilos of honey or if Winnie-the-Pooh has already eaten from it three times, he gives the jar to Piglet. Otherwise he eats exactly *k* kilos of honey from the jar and puts it back. Winnie does so until he gives all jars to the Piglet. Count how much honey Piglet will overall get after Winnie satisfies his hunger. Input Specification: The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*k*<=≤<=100). The second line contains *n* integers *a*1, *a*2, ..., *a**n*, separated by spaces (1<=≤<=*a**i*<=≤<=100). Output Specification: Print a single number — how many kilos of honey gets Piglet. Demo Input: ['3 3\n15 8 10\n'] Demo Output: ['9\n'] Note: none

```python import sys sys.stdin=open("input.txt",'r') sys.stdout=open("output.txt",'w') n,k=map(int,input().split()) a=list(map(int,input().split())) x=0 for i in range(n): if a[i]>9: x+=a[i]-9 else: x+=a[i]%3 print(x) ```

0

496

A

Minimum Difficulty

PROGRAMMING

900

[ "brute force", "implementation", "math" ]

null

Mike is trying rock climbing but he is awful at it. There are *n* holds on the wall, *i*-th hold is at height *a**i* off the ground. Besides, let the sequence *a**i* increase, that is, *a**i*<=<<=*a**i*<=+<=1 for all *i* from 1 to *n*<=-<=1; we will call such sequence a track. Mike thinks that the track *a*1, ..., *a**n* has difficulty . In other words, difficulty equals the maximum distance between two holds that are adjacent in height. Today Mike decided to cover the track with holds hanging on heights *a*1, ..., *a**n*. To make the problem harder, Mike decided to remove one hold, that is, remove one element of the sequence (for example, if we take the sequence (1,<=2,<=3,<=4,<=5) and remove the third element from it, we obtain the sequence (1,<=2,<=4,<=5)). However, as Mike is awful at climbing, he wants the final difficulty (i.e. the maximum difference of heights between adjacent holds after removing the hold) to be as small as possible among all possible options of removing a hold. The first and last holds must stay at their positions. Help Mike determine the minimum difficulty of the track after removing one hold.

The first line contains a single integer *n* (3<=≤<=*n*<=≤<=100) — the number of holds. The next line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=1000), where *a**i* is the height where the hold number *i* hangs. The sequence *a**i* is increasing (i.e. each element except for the first one is strictly larger than the previous one).

Print a single number — the minimum difficulty of the track after removing a single hold.

[ "3\n1 4 6\n", "5\n1 2 3 4 5\n", "5\n1 2 3 7 8\n" ]

[ "5\n", "2\n", "4\n" ]

In the first sample you can remove only the second hold, then the sequence looks like (1, 6), the maximum difference of the neighboring elements equals 5. In the second test after removing every hold the difficulty equals 2. In the third test you can obtain sequences (1, 3, 7, 8), (1, 2, 7, 8), (1, 2, 3, 8), for which the difficulty is 4, 5 and 5, respectively. Thus, after removing the second element we obtain the optimal answer — 4.

500

[ { "input": "3\n1 4 6", "output": "5" }, { "input": "5\n1 2 3 4 5", "output": "2" }, { "input": "5\n1 2 3 7 8", "output": "4" }, { "input": "3\n1 500 1000", "output": "999" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "2" }, { "input": "10\n1 4 9 16 25 36 49 64 81 100", "output": "19" }, { "input": "10\n300 315 325 338 350 365 379 391 404 416", "output": "23" }, { "input": "15\n87 89 91 92 93 95 97 99 101 103 105 107 109 111 112", "output": "2" }, { "input": "60\n3 5 7 8 15 16 18 21 24 26 40 41 43 47 48 49 50 51 52 54 55 60 62 71 74 84 85 89 91 96 406 407 409 412 417 420 423 424 428 431 432 433 436 441 445 446 447 455 458 467 469 471 472 475 480 485 492 493 497 500", "output": "310" }, { "input": "3\n159 282 405", "output": "246" }, { "input": "81\n6 7 22 23 27 38 40 56 59 71 72 78 80 83 86 92 95 96 101 122 125 127 130 134 154 169 170 171 172 174 177 182 184 187 195 197 210 211 217 223 241 249 252 253 256 261 265 269 274 277 291 292 297 298 299 300 302 318 338 348 351 353 381 386 387 397 409 410 419 420 428 430 453 460 461 473 478 493 494 500 741", "output": "241" }, { "input": "10\n218 300 388 448 535 629 680 740 836 925", "output": "111" }, { "input": "100\n6 16 26 36 46 56 66 76 86 96 106 116 126 136 146 156 166 176 186 196 206 216 226 236 246 256 266 276 286 296 306 316 326 336 346 356 366 376 386 396 406 416 426 436 446 456 466 476 486 496 506 516 526 536 546 556 566 576 586 596 606 616 626 636 646 656 666 676 686 696 706 716 726 736 746 756 766 776 786 796 806 816 826 836 846 856 866 876 886 896 906 916 926 936 946 956 966 976 986 996", "output": "20" }, { "input": "100\n1 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 46 47 48 49 50 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000", "output": "901" }, { "input": "100\n1 9 15 17 28 29 30 31 32 46 48 49 52 56 62 77 82 85 90 91 94 101 102 109 111 113 116 118 124 125 131 132 136 138 139 143 145 158 161 162 165 167 171 173 175 177 179 183 189 196 801 802 804 806 817 819 827 830 837 840 842 846 850 855 858 862 863 866 869 870 878 881 883 884 896 898 899 901 904 906 908 909 910 911 912 917 923 924 925 935 939 943 945 956 963 964 965 972 976 978", "output": "605" }, { "input": "100\n2 43 47 49 50 57 59 67 74 98 901 903 904 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 938 939 940 942 943 944 945 946 947 948 949 950 952 953 954 956 957 958 959 960 961 962 963 965 966 967 968 969 970 971 972 973 974 975 976 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 998 999", "output": "803" }, { "input": "72\n178 186 196 209 217 226 236 248 260 273 281 291 300 309 322 331 343 357 366 377 389 399 409 419 429 442 450 459 469 477 491 501 512 524 534 548 557 568 582 593 602 616 630 643 652 660 670 679 693 707 715 728 737 750 759 768 776 789 797 807 815 827 837 849 863 873 881 890 901 910 920 932", "output": "17" }, { "input": "38\n1 28 55 82 109 136 163 190 217 244 271 298 325 352 379 406 433 460 487 514 541 568 595 622 649 676 703 730 757 784 811 838 865 892 919 946 973 1000", "output": "54" }, { "input": "28\n1 38 75 112 149 186 223 260 297 334 371 408 445 482 519 556 593 630 667 704 741 778 815 852 889 926 963 1000", "output": "74" } ]

1,617,015,908

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

93

0

n = int(input()) a = list(map(int,input().split())) m = -1 ans = 0 for i in range(1,n-1): d = min(m,abs(a[i-1]-a[i+1])) if m==d: p=i break a.remove(a[p]) for i in range(n-2): ans = max(ans,abs(a[i]-a[i+1])) print(ans)

Title: Minimum Difficulty Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mike is trying rock climbing but he is awful at it. There are *n* holds on the wall, *i*-th hold is at height *a**i* off the ground. Besides, let the sequence *a**i* increase, that is, *a**i*<=<<=*a**i*<=+<=1 for all *i* from 1 to *n*<=-<=1; we will call such sequence a track. Mike thinks that the track *a*1, ..., *a**n* has difficulty . In other words, difficulty equals the maximum distance between two holds that are adjacent in height. Today Mike decided to cover the track with holds hanging on heights *a*1, ..., *a**n*. To make the problem harder, Mike decided to remove one hold, that is, remove one element of the sequence (for example, if we take the sequence (1,<=2,<=3,<=4,<=5) and remove the third element from it, we obtain the sequence (1,<=2,<=4,<=5)). However, as Mike is awful at climbing, he wants the final difficulty (i.e. the maximum difference of heights between adjacent holds after removing the hold) to be as small as possible among all possible options of removing a hold. The first and last holds must stay at their positions. Help Mike determine the minimum difficulty of the track after removing one hold. Input Specification: The first line contains a single integer *n* (3<=≤<=*n*<=≤<=100) — the number of holds. The next line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=1000), where *a**i* is the height where the hold number *i* hangs. The sequence *a**i* is increasing (i.e. each element except for the first one is strictly larger than the previous one). Output Specification: Print a single number — the minimum difficulty of the track after removing a single hold. Demo Input: ['3\n1 4 6\n', '5\n1 2 3 4 5\n', '5\n1 2 3 7 8\n'] Demo Output: ['5\n', '2\n', '4\n'] Note: In the first sample you can remove only the second hold, then the sequence looks like (1, 6), the maximum difference of the neighboring elements equals 5. In the second test after removing every hold the difficulty equals 2. In the third test you can obtain sequences (1, 3, 7, 8), (1, 2, 7, 8), (1, 2, 3, 8), for which the difficulty is 4, 5 and 5, respectively. Thus, after removing the second element we obtain the optimal answer — 4.

```python n = int(input()) a = list(map(int,input().split())) m = -1 ans = 0 for i in range(1,n-1): d = min(m,abs(a[i-1]-a[i+1])) if m==d: p=i break a.remove(a[p]) for i in range(n-2): ans = max(ans,abs(a[i]-a[i+1])) print(ans) ```

0

41

A

Translation

PROGRAMMING

800

[ "implementation", "strings" ]

A. Translation

2

256

The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly.

The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols.

If the word *t* is a word *s*, written reversely, print YES, otherwise print NO.

[ "code\nedoc\n", "abb\naba\n", "code\ncode\n" ]

[ "YES\n", "NO\n", "NO\n" ]

none

500

[ { "input": "code\nedoc", "output": "YES" }, { "input": "abb\naba", "output": "NO" }, { "input": "code\ncode", "output": "NO" }, { "input": "abacaba\nabacaba", "output": "YES" }, { "input": "q\nq", "output": "YES" }, { "input": "asrgdfngfnmfgnhweratgjkk\nasrgdfngfnmfgnhweratgjkk", "output": "NO" }, { "input": "z\na", "output": "NO" }, { "input": "asd\ndsa", "output": "YES" }, { "input": "abcdef\nfecdba", "output": "NO" }, { "input": "ywjjbirapvskozubvxoemscfwl\ngnduubaogtfaiowjizlvjcu", "output": "NO" }, { "input": "mfrmqxtzvgaeuleubcmcxcfqyruwzenguhgrmkuhdgnhgtgkdszwqyd\nmfxufheiperjnhyczclkmzyhcxntdfskzkzdwzzujdinf", "output": "NO" }, { "input": "bnbnemvybqizywlnghlykniaxxxlkhftppbdeqpesrtgkcpoeqowjwhrylpsziiwcldodcoonpimudvrxejjo\ntiynnekmlalogyvrgptbinkoqdwzuiyjlrldxhzjmmp", "output": "NO" }, { "input": "pwlpubwyhzqvcitemnhvvwkmwcaawjvdiwtoxyhbhbxerlypelevasmelpfqwjk\nstruuzebbcenziscuoecywugxncdwzyfozhljjyizpqcgkyonyetarcpwkqhuugsqjuixsxptmbnlfupdcfigacdhhrzb", "output": "NO" }, { "input": "gdvqjoyxnkypfvdxssgrihnwxkeojmnpdeobpecytkbdwujqfjtxsqspxvxpqioyfagzjxupqqzpgnpnpxcuipweunqch\nkkqkiwwasbhezqcfeceyngcyuogrkhqecwsyerdniqiocjehrpkljiljophqhyaiefjpavoom", "output": "NO" }, { "input": "umeszdawsvgkjhlqwzents\nhxqhdungbylhnikwviuh", "output": "NO" }, { "input": "juotpscvyfmgntshcealgbsrwwksgrwnrrbyaqqsxdlzhkbugdyx\nibqvffmfktyipgiopznsqtrtxiijntdbgyy", "output": "NO" }, { "input": "zbwueheveouatecaglziqmudxemhrsozmaujrwlqmppzoumxhamwugedikvkblvmxwuofmpafdprbcftew\nulczwrqhctbtbxrhhodwbcxwimncnexosksujlisgclllxokrsbnozthajnnlilyffmsyko", "output": "NO" }, { "input": "nkgwuugukzcv\nqktnpxedwxpxkrxdvgmfgoxkdfpbzvwsduyiybynbkouonhvmzakeiruhfmvrktghadbfkmwxduoqv", "output": "NO" }, { "input": "incenvizhqpcenhjhehvjvgbsnfixbatrrjstxjzhlmdmxijztphxbrldlqwdfimweepkggzcxsrwelodpnryntepioqpvk\ndhjbjjftlvnxibkklxquwmzhjfvnmwpapdrslioxisbyhhfymyiaqhlgecpxamqnocizwxniubrmpyubvpenoukhcobkdojlybxd", "output": "NO" }, { "input": "w\nw", "output": "YES" }, { "input": "vz\nzv", "output": "YES" }, { "input": "ry\nyr", "output": "YES" }, { "input": "xou\nuox", "output": "YES" }, { "input": "axg\ngax", "output": "NO" }, { "input": "zdsl\nlsdz", "output": "YES" }, { "input": "kudl\nldku", "output": "NO" }, { "input": "zzlzwnqlcl\nlclqnwzlzz", "output": "YES" }, { "input": "vzzgicnzqooejpjzads\nsdazjpjeooqzncigzzv", "output": "YES" }, { "input": "raqhmvmzuwaykjpyxsykr\nxkysrypjkyawuzmvmhqar", "output": "NO" }, { "input": "ngedczubzdcqbxksnxuavdjaqtmdwncjnoaicvmodcqvhfezew\nwezefhvqcdomvciaonjcnwdmtqajdvauxnskxbqcdzbuzcdegn", "output": "YES" }, { "input": "muooqttvrrljcxbroizkymuidvfmhhsjtumksdkcbwwpfqdyvxtrlymofendqvznzlmim\nmimlznzvqdnefomylrtxvydqfpwwbckdskmutjshhmfvdiumykziorbxcjlrrvttqooum", "output": "YES" }, { "input": "vxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaivg\ngviayyikkitmuomcpiakhbxszgbnhvwyzkftwoagzixaearxpjacrnvpvbuzenvovehkmmxvblqyxvctroddksdsgebcmlluqpxv", "output": "YES" }, { "input": "mnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfdc\ncdfmkdgrdptkpewbsqvszipgxvgvuiuzbkkwuowbafkikgvnqdkxnayzdjygvezmtsgywnupocdntipiyiorblqkrzjpzatxahnm", "output": "NO" }, { "input": "dgxmzbqofstzcdgthbaewbwocowvhqpinehpjatnnbrijcolvsatbblsrxabzrpszoiecpwhfjmwuhqrapvtcgvikuxtzbftydkw\nwkdytfbztxukivgctvparqhuwmjfhwpceiozsprzbaxrslbbqasvlocjirbnntajphenipthvwocowbweabhtgdcztsfoqbzmxgd", "output": "NO" }, { "input": "gxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwgeh\nhegwxvocotmzstqfbmpjvijgkcyodlxyjawrpkczpmdspsuhoiruavnnnuwvtwohglkdxjetshkboalvzqbgjgthoteceixioxg", "output": "YES" }, { "input": "sihxuwvmaambplxvjfoskinghzicyfqebjtkysotattkahssumfcgrkheotdxwjckpvapbkaepqrxseyfrwtyaycmrzsrsngkh\nhkgnsrszrmcyaytwrfyesxrqpeakbpavpkcjwxdtoehkrgcfmusshakttatosyktjbeqfycizhgniksofjvxlpbmaamvwuxhis", "output": "YES" }, { "input": "ycnahksbughnonldzrhkysujmylcgcfuludjvjiahtkyzqvkopzqcnwhltbzfugzojqkjjlggmvnultascmygelkiktmfieok\nkoeifmtkiklegkmcsatlunvmggkjjlqjozgufzbtlhwncqzpokvqzykthaijvjdulufcgclymjusyyhrzdlnonhgubskhancy", "output": "NO" }, { "input": "wbqasaehtkfojruzyhrlgwmtyiovmzyfifslvlemhqheyaelzwnthrenjsbmntwaoryzwfbxmscmypvxlfmzpnkkjlvwvmtz\nztmvwvljkknpzmflxvpymcsmxbfwzyroawtnmbsjnerhtnwzleayehqhmelvlsfifyzmvoiytmwglrhyzurjofktheasaqbw", "output": "YES" }, { "input": "imippqurprbhfugngtgifelytadegwrgaefnfhbjjnmzikvjaccotqzemufqieqldgnbmviisgkynzeldlhqxuqphjfmyij\njiymfjhpquxqhldleznykgsiivmbngdlqeiqfumezqtoccajvkizmnjjbhfnfeagrwgedatylefigtgngufhbrpruqppimi", "output": "YES" }, { "input": "bikydffiuisckpvzqlteqfhegsagimodb\nbdomigasgehfqetlqzvpkcsiuiffdykib", "output": "YES" } ]

1,680,526,750

2,147,483,647

Python 3

OK

TESTS

40

92

0

def SameChar(s, t): l = len(s) s2 = "" for i in s : if i in t: s2 = i+ s2 else: return False return t == s2 def IS_Same(s, t): if len(s) == len(t): if SameChar(s, t): print("YES") else : print("NO") else : print("NO") s = input() t = input() IS_Same(s, t)

Title: Translation Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: The translation from the Berland language into the Birland language is not an easy task. Those languages are very similar: a berlandish word differs from a birlandish word with the same meaning a little: it is spelled (and pronounced) reversely. For example, a Berlandish word code corresponds to a Birlandish word edoc. However, it's easy to make a mistake during the «translation». Vasya translated word *s* from Berlandish into Birlandish as *t*. Help him: find out if he translated the word correctly. Input Specification: The first line contains word *s*, the second line contains word *t*. The words consist of lowercase Latin letters. The input data do not consist unnecessary spaces. The words are not empty and their lengths do not exceed 100 symbols. Output Specification: If the word *t* is a word *s*, written reversely, print YES, otherwise print NO. Demo Input: ['code\nedoc\n', 'abb\naba\n', 'code\ncode\n'] Demo Output: ['YES\n', 'NO\n', 'NO\n'] Note: none

```python def SameChar(s, t): l = len(s) s2 = "" for i in s : if i in t: s2 = i+ s2 else: return False return t == s2 def IS_Same(s, t): if len(s) == len(t): if SameChar(s, t): print("YES") else : print("NO") else : print("NO") s = input() t = input() IS_Same(s, t) ```

3.977

721

A

One-dimensional Japanese Crossword

PROGRAMMING

800

[ "implementation" ]

null

Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized *a*<=×<=*b* squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia [https://en.wikipedia.org/wiki/Japanese_crossword](https://en.wikipedia.org/wiki/Japanese_crossword)). Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of *n* squares (e.g. japanese crossword sized 1<=×<=*n*), which he wants to encrypt in the same way as in japanese crossword. Help Adaltik find the numbers encrypting the row he drew.

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the length of the row. The second line of the input contains a single string consisting of *n* characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).

The first line should contain a single integer *k* — the number of integers encrypting the row, e.g. the number of groups of black squares in the row. The second line should contain *k* integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.

[ "3\nBBW\n", "5\nBWBWB\n", "4\nWWWW\n", "4\nBBBB\n", "13\nWBBBBWWBWBBBW\n" ]

[ "1\n2 ", "3\n1 1 1 ", "0\n", "1\n4 ", "3\n4 1 3 " ]

The last sample case correspond to the picture in the statement.

500

[ { "input": "3\nBBW", "output": "1\n2 " }, { "input": "5\nBWBWB", "output": "3\n1 1 1 " }, { "input": "4\nWWWW", "output": "0" }, { "input": "4\nBBBB", "output": "1\n4 " }, { "input": "13\nWBBBBWWBWBBBW", "output": "3\n4 1 3 " }, { "input": "1\nB", "output": "1\n1 " }, { "input": "2\nBB", "output": "1\n2 " }, { "input": "100\nWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWB", "output": "50\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 " }, { "input": "1\nW", "output": "0" }, { "input": "2\nWW", "output": "0" }, { "input": "2\nWB", "output": "1\n1 " }, { "input": "2\nBW", "output": "1\n1 " }, { "input": "3\nBBB", "output": "1\n3 " }, { "input": "3\nBWB", "output": "2\n1 1 " }, { "input": "3\nWBB", "output": "1\n2 " }, { "input": "3\nWWB", "output": "1\n1 " }, { "input": "3\nWBW", "output": "1\n1 " }, { "input": "3\nBWW", "output": "1\n1 " }, { "input": "3\nWWW", "output": "0" }, { "input": "100\nBBBWWWWWWBBWWBBWWWBBWBBBBBBBBBBBWBBBWBBWWWBBWWBBBWBWWBBBWWBBBWBBBBBWWWBWWBBWWWWWWBWBBWWBWWWBWBWWWWWB", "output": "21\n3 2 2 2 11 3 2 2 3 1 3 3 5 1 2 1 2 1 1 1 1 " }, { "input": "5\nBBBWB", "output": "2\n3 1 " }, { "input": "5\nBWWWB", "output": "2\n1 1 " }, { "input": "5\nWWWWB", "output": "1\n1 " }, { "input": "5\nBWWWW", "output": "1\n1 " }, { "input": "5\nBBBWW", "output": "1\n3 " }, { "input": "5\nWWBBB", "output": "1\n3 " }, { "input": "10\nBBBBBWWBBB", "output": "2\n5 3 " }, { "input": "10\nBBBBWBBWBB", "output": "3\n4 2 2 " }, { "input": "20\nBBBBBWWBWBBWBWWBWBBB", "output": "6\n5 1 2 1 1 3 " }, { "input": "20\nBBBWWWWBBWWWBWBWWBBB", "output": "5\n3 2 1 1 3 " }, { "input": "20\nBBBBBBBBWBBBWBWBWBBB", "output": "5\n8 3 1 1 3 " }, { "input": "20\nBBBWBWBWWWBBWWWWBWBB", "output": "6\n3 1 1 2 1 2 " }, { "input": "40\nBBBBBBWWWWBWBWWWBWWWWWWWWWWWBBBBBBBBBBBB", "output": "5\n6 1 1 1 12 " }, { "input": "40\nBBBBBWBWWWBBWWWBWBWWBBBBWWWWBWBWBBBBBBBB", "output": "9\n5 1 2 1 1 4 1 1 8 " }, { "input": "50\nBBBBBBBBBBBWWWWBWBWWWWBBBBBBBBWWWWWWWBWWWWBWBBBBBB", "output": "7\n11 1 1 8 1 1 6 " }, { "input": "50\nWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW", "output": "0" }, { "input": "50\nBBBBBWWWWWBWWWBWWWWWBWWWBWWWWWWBBWBBWWWWBWWWWWWWBW", "output": "9\n5 1 1 1 1 2 2 1 1 " }, { "input": "50\nWWWWBWWBWWWWWWWWWWWWWWWWWWWWWWWWWBWBWBWWWWWWWBBBBB", "output": "6\n1 1 1 1 1 5 " }, { "input": "50\nBBBBBWBWBWWBWBWWWWWWBWBWBWWWWWWWWWWWWWBWBWWWWBWWWB", "output": "12\n5 1 1 1 1 1 1 1 1 1 1 1 " }, { "input": "50\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "1\n50 " }, { "input": "100\nBBBBBBBBBBBWBWWWWBWWBBWBBWWWWWWWWWWBWBWWBWWWWWWWWWWWBBBWWBBWWWWWBWBWWWWBWWWWWWWWWWWBWWWWWBBBBBBBBBBB", "output": "15\n11 1 1 2 2 1 1 1 3 2 1 1 1 1 11 " }, { "input": "100\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "1\n100 " }, { "input": "100\nBBBBBBBBBBBBBBBBBBBBWBWBWWWWWBWWWWWWWWWWWWWWBBWWWBWWWWBWWBWWWWWWBWWWWWWWWWWWWWBWBBBBBBBBBBBBBBBBBBBB", "output": "11\n20 1 1 1 2 1 1 1 1 1 20 " }, { "input": "100\nBBBBWWWWWWWWWWWWWWWWWWWWWWWWWBWBWWWWWBWBWWWWWWBBWWWWWWWWWWWWBWWWWBWWWWWWWWWWWWBWWWWWWWBWWWWWWWBBBBBB", "output": "11\n4 1 1 1 1 2 1 1 1 1 6 " }, { "input": "5\nBWBWB", "output": "3\n1 1 1 " }, { "input": "10\nWWBWWWBWBB", "output": "3\n1 1 2 " }, { "input": "50\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "1\n50 " }, { "input": "50\nBBBBBBBBBBBBBBBBBWWBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "2\n17 31 " }, { "input": "100\nBBBBBBBBBBBBBBBBBBBBBBBBWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "2\n24 42 " }, { "input": "90\nWWBWWBWBBWBBWWBWBWBBBWBWBBBWBWBWBWBWBWBWBWBBBBBWBBWWWWBWBBWBWWBBBWBWBWWBWBWBWBWWWWWWBWBBBB", "output": "30\n1 1 2 2 1 1 3 1 3 1 1 1 1 1 1 1 5 2 1 2 1 3 1 1 1 1 1 1 1 4 " }, { "input": "100\nBWWWBWBWBBBBBWBWWBWBWWWBWBWBWWBBWWBBBWBBBWWBWBWWBBBBWBWBBBWBWBBWWWWWWBWWBBBBWBWBWWBWBWWWBWBWWBWBWWWB", "output": "31\n1 1 1 5 1 1 1 1 1 1 2 3 3 1 1 4 1 3 1 2 1 4 1 1 1 1 1 1 1 1 1 " }, { "input": "90\nWBWBBBBBBWWWBBWWBWWWBBWWBWWWBWBBWBWBBWWWWBWBWBBWBBWBWWWBBWBBWWWWBWBBWWWBBBWBBWBWBBBBWWBWWB", "output": "25\n1 6 2 1 2 1 1 2 1 2 1 1 2 2 1 2 2 1 2 3 2 1 4 1 1 " }, { "input": "80\nBBWWBBBWBBWWWWBBWBWBBWWWWWBWBBWWBWBWBWBWBWWBWWBWWWBWBBWBBWBBWBBBWWBBBBBBBWBBBWBB", "output": "23\n2 3 2 2 1 2 1 2 1 1 1 1 1 1 1 1 2 2 2 3 7 3 2 " }, { "input": "65\nWWWWBWWWBBBBBWWWWWWBBBWWBBBBWWWWWWWWBBBWWWWBWBWWBBWWWWBWWWBBWBBBB", "output": "11\n1 5 3 4 3 1 1 2 1 2 4 " } ]

1,619,553,512

2,147,483,647

Python 3

OK

TESTS

54

92

0

# HW 4a # input n, length of the row n = input() n = int(n) #input string of W and B WB = input() groups = [] was_white = True i = 0 while i < n: if WB[i] == 'B': if was_white: groups.insert(len(groups), 1) else: groups[len(groups) - 1] += 1 was_white = False else: was_white = True i += 1 # output k, the number of groups of black squares # print number of things in list B print(len(groups)) # output k integers that sequentially lists the size of each group of black squares # print list B print(*groups)

Title: One-dimensional Japanese Crossword Time Limit: None seconds Memory Limit: None megabytes Problem Description: Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized *a*<=×<=*b* squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia [https://en.wikipedia.org/wiki/Japanese_crossword](https://en.wikipedia.org/wiki/Japanese_crossword)). Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of *n* squares (e.g. japanese crossword sized 1<=×<=*n*), which he wants to encrypt in the same way as in japanese crossword. Help Adaltik find the numbers encrypting the row he drew. Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the length of the row. The second line of the input contains a single string consisting of *n* characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew). Output Specification: The first line should contain a single integer *k* — the number of integers encrypting the row, e.g. the number of groups of black squares in the row. The second line should contain *k* integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right. Demo Input: ['3\nBBW\n', '5\nBWBWB\n', '4\nWWWW\n', '4\nBBBB\n', '13\nWBBBBWWBWBBBW\n'] Demo Output: ['1\n2 ', '3\n1 1 1 ', '0\n', '1\n4 ', '3\n4 1 3 '] Note: The last sample case correspond to the picture in the statement.

```python # HW 4a # input n, length of the row n = input() n = int(n) #input string of W and B WB = input() groups = [] was_white = True i = 0 while i < n: if WB[i] == 'B': if was_white: groups.insert(len(groups), 1) else: groups[len(groups) - 1] += 1 was_white = False else: was_white = True i += 1 # output k, the number of groups of black squares # print number of things in list B print(len(groups)) # output k integers that sequentially lists the size of each group of black squares # print list B print(*groups) ```

3

0

none

0

[ "none" ]

null

One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane *n* rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other. Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible. Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length

The first line contains single integer *n* (1<=≤<=*n*<=≤<=5·105) — the number of rectangles. *n* lines follow. The *i*-th of these lines contains four integers *x*1, *y*1, *x*2 and *y*2 (<=-<=109<=≤<=*x*1<=<<=*x*2<=≤<=109, <=-<=109<=≤<=*y*1<=<<=*y*2<=≤<=109), that means that points (*x*1,<=*y*1) and (*x*2,<=*y*2) are the coordinates of two opposite corners of the *i*-th rectangle. It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.

Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color. Otherwise, print "YES" in the first line. Then print *n* lines, in the *i*-th of them print single integer *c**i* (1<=≤<=*c**i*<=≤<=4) — the color of *i*-th rectangle.

[ "8\n0 0 5 3\n2 -1 5 0\n-3 -4 2 -1\n-1 -1 2 0\n-3 0 0 5\n5 2 10 3\n7 -3 10 2\n4 -2 7 -1\n" ]

[ "YES\n1\n2\n2\n3\n2\n2\n4\n1\n" ]

none

0

[ { "input": "8\n0 0 5 3\n2 -1 5 0\n-3 -4 2 -1\n-1 -1 2 0\n-3 0 0 5\n5 2 10 3\n7 -3 10 2\n4 -2 7 -1", "output": "YES\n1\n4\n3\n2\n3\n3\n2\n1" }, { "input": "1\n0 0 1 1", "output": "YES\n1" }, { "input": "4\n0 0 1 1\n1 0 2 1\n1 1 2 2\n0 1 1 2", "output": "YES\n1\n3\n4\n2" }, { "input": "3\n0 0 1 3\n1 0 4 1\n1 1 2 2", "output": "YES\n1\n3\n4" }, { "input": "6\n0 1 1 4\n0 4 1 7\n1 0 2 3\n1 3 2 4\n1 4 2 5\n2 3 3 4", "output": "YES\n2\n1\n3\n4\n3\n2" }, { "input": "25\n0 0 7 7\n0 18 7 29\n7 36 12 41\n7 18 12 29\n15 29 26 36\n7 7 12 18\n12 36 15 41\n15 7 26 18\n12 0 15 7\n12 7 15 18\n7 29 12 36\n12 29 15 36\n15 18 26 29\n26 18 27 29\n12 18 15 29\n26 29 27 36\n0 7 7 18\n26 0 27 7\n7 0 12 7\n15 36 26 41\n26 7 27 18\n26 36 27 41\n15 0 26 7\n0 36 7 41\n0 29 7 36", "output": "YES\n1\n1\n3\n3\n4\n4\n1\n4\n1\n2\n4\n2\n3\n1\n1\n2\n2\n1\n3\n3\n2\n1\n3\n1\n2" }, { "input": "25\n76 0 85 9\n46 0 55 9\n6 0 13 9\n86 0 95 9\n56 0 65 9\n152 0 157 9\n146 0 151 9\n14 0 21 9\n0 0 1 9\n180 0 189 9\n120 0 125 9\n96 0 99 9\n126 0 133 9\n158 0 169 9\n22 0 27 9\n100 0 107 9\n170 0 179 9\n2 0 5 9\n134 0 141 9\n114 0 119 9\n108 0 113 9\n66 0 75 9\n36 0 45 9\n142 0 145 9\n28 0 35 9", "output": "YES\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1" }, { "input": "28\n0 0 3 1\n0 1 1 6\n0 6 1 9\n0 9 1 12\n0 12 1 13\n0 13 3 14\n1 1 2 4\n1 4 2 7\n1 7 2 10\n1 10 2 13\n2 1 3 2\n2 2 3 5\n2 5 3 8\n2 8 3 13\n3 0 6 1\n3 1 4 6\n3 6 4 9\n3 9 4 12\n3 12 4 13\n3 13 6 14\n4 1 5 4\n4 4 5 7\n4 7 5 10\n4 10 5 13\n5 1 6 2\n5 2 6 5\n5 5 6 8\n5 8 6 13", "output": "YES\n1\n2\n1\n2\n1\n2\n4\n3\n4\n3\n2\n1\n2\n1\n3\n4\n3\n4\n3\n4\n2\n1\n2\n1\n4\n3\n4\n3" }, { "input": "4\n3 3 10 12\n5 0 14 3\n0 3 3 12\n0 0 5 3", "output": "YES\n4\n3\n2\n1" }, { "input": "4\n3 11 12 18\n0 0 1 11\n0 11 3 18\n1 0 8 11", "output": "YES\n4\n1\n2\n3" } ]

1,486,063,619

2,147,483,647

Python 3

OK

TESTS

47

1,513

4,608,000

n = int(input()) print("YES") for i in range(n): x1, y1, x2, y2 = input().split() x1 = int(x1) y1 = int(y1) print((x1 % 2) * 2 + (y1 % 2) + 1)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane *n* rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other. Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible. Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length Input Specification: The first line contains single integer *n* (1<=≤<=*n*<=≤<=5·105) — the number of rectangles. *n* lines follow. The *i*-th of these lines contains four integers *x*1, *y*1, *x*2 and *y*2 (<=-<=109<=≤<=*x*1<=<<=*x*2<=≤<=109, <=-<=109<=≤<=*y*1<=<<=*y*2<=≤<=109), that means that points (*x*1,<=*y*1) and (*x*2,<=*y*2) are the coordinates of two opposite corners of the *i*-th rectangle. It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other. Output Specification: Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color. Otherwise, print "YES" in the first line. Then print *n* lines, in the *i*-th of them print single integer *c**i* (1<=≤<=*c**i*<=≤<=4) — the color of *i*-th rectangle. Demo Input: ['8\n0 0 5 3\n2 -1 5 0\n-3 -4 2 -1\n-1 -1 2 0\n-3 0 0 5\n5 2 10 3\n7 -3 10 2\n4 -2 7 -1\n'] Demo Output: ['YES\n1\n2\n2\n3\n2\n2\n4\n1\n'] Note: none

```python n = int(input()) print("YES") for i in range(n): x1, y1, x2, y2 = input().split() x1 = int(x1) y1 = int(y1) print((x1 % 2) * 2 + (y1 % 2) + 1) ```

3

327

A

Flipping Game

PROGRAMMING

1,200

[ "brute force", "dp", "implementation" ]

null

Iahub got bored, so he invented a game to be played on paper. He writes *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Each of those integers can be either 0 or 1. He's allowed to do exactly one move: he chooses two indices *i* and *j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) and flips all values *a**k* for which their positions are in range [*i*,<=*j*] (that is *i*<=≤<=*k*<=≤<=*j*). Flip the value of *x* means to apply operation *x*<==<=1 - *x*. The goal of the game is that after exactly one move to obtain the maximum number of ones. Write a program to solve the little game of Iahub.

The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=100). In the second line of the input there are *n* integers: *a*1,<=*a*2,<=...,<=*a**n*. It is guaranteed that each of those *n* values is either 0 or 1.

Print an integer — the maximal number of 1s that can be obtained after exactly one move.

[ "5\n1 0 0 1 0\n", "4\n1 0 0 1\n" ]

[ "4\n", "4\n" ]

In the first case, flip the segment from 2 to 5 (*i* = 2, *j* = 5). That flip changes the sequence, it becomes: [1 1 1 0 1]. So, it contains four ones. There is no way to make the whole sequence equal to [1 1 1 1 1]. In the second case, flipping only the second and the third element (*i* = 2, *j* = 3) will turn all numbers into 1.

500

[ { "input": "5\n1 0 0 1 0", "output": "4" }, { "input": "4\n1 0 0 1", "output": "4" }, { "input": "1\n1", "output": "0" }, { "input": "1\n0", "output": "1" }, { "input": "8\n1 0 0 0 1 0 0 0", "output": "7" }, { "input": "18\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "18" }, { "input": "23\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "22" }, { "input": "100\n0 1 0 1 1 1 0 1 0 1 0 0 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 0 1 1 0 0 0 1 1 1 1 0 0 1 1 1 0 0 1 1 0 1 1 1 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1", "output": "70" }, { "input": "100\n0 1 1 0 1 0 0 1 0 0 0 1 1 0 0 0 1 1 1 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 0 1 0 0 1 1 0 1 0 0 1 1 0 0 0 0 1 0 0 0 0 1 1 1 1", "output": "60" }, { "input": "18\n0 1 0 1 0 1 0 1 0 1 1 0 1 1 0 1 1 0", "output": "11" }, { "input": "25\n0 1 0 0 0 0 0 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 1 0 1", "output": "18" }, { "input": "55\n0 0 1 1 0 0 0 1 0 1 1 0 1 1 1 0 1 1 1 1 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 1 0 1 1 1 1 0 1 1 0 0 0 0 1 1 0 1 1 1 1", "output": "36" }, { "input": "75\n1 1 0 1 0 1 1 0 0 0 0 0 1 1 1 1 1 0 1 0 1 0 0 0 0 1 1 1 0 1 0 0 1 1 0 1 0 0 1 1 0 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 0 0 1 0 1 1 0 0 0 0 1 1 0 0 0 1 0 0 0", "output": "44" }, { "input": "100\n0 0 1 0 1 0 0 1 1 0 1 1 0 1 0 1 1 0 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 1 1 0 0 1 1 1 0 0 0 0 1 0 1 1 1 0 0 1 0 1 1 1 1 1 1 1 0 1 0 1 0 0 1 0 1 1 1 0 0 0 0 1 0 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 0 0 1 1 0 1 0 1", "output": "61" }, { "input": "100\n0 0 0 1 0 0 0 1 0 1 1 0 1 1 1 1 1 0 1 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1 1 0 1 1 0 0 0 1 1 1 1 0 1 1 0 1 1 1 1 0 1 0 0 1 0 1 0 0 0 0 1 1 0 0 1 0 0 1 1 0 1 1 0 1 0 0 1 1 0 1 1 1 1 0 1 0 0 1 0 1 1 1 0 1 1 0", "output": "61" }, { "input": "100\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "100" }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "99" }, { "input": "100\n0 0 1 1 1 0 1 1 0 0 1 0 1 0 1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 0 1 0 0 1 0 0 0 0 1 1 1 0 1 1 1 0 1 1 1 0 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 0 0 1 0 0 1 0 1 0 0 0 0 0 0 1 1 1 0 1 1 1 0 1 1 1 1 1 0 0 0 0 1 0", "output": "61" }, { "input": "100\n0 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 0 1 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 1 1 0 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1", "output": "59" }, { "input": "99\n1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0 0 0 0 1 1 0 0 1 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 1 0 0 1 1 0 1 0 0 0 1 1 1 1 0 1 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 1 0 1 1 1", "output": "61" }, { "input": "2\n1 1", "output": "1" } ]

1,685,423,286

2,147,483,647

PyPy 3-64

OK

TESTS

21

186

3,584,000

def score(i, j, a): b = [x for x in a] for i in range(i, j+1): if b[i] == 0: b[i] = 1 else: b[i] = 0 return b.count(1) def findMax(n, a): ans = 0 for i in range(n): for j in range(i, n): ans = max(ans, score(i, j, a)) return ans n = int(input()) a = list(map(int, input().split())) print(findMax(n, a))

Title: Flipping Game Time Limit: None seconds Memory Limit: None megabytes Problem Description: Iahub got bored, so he invented a game to be played on paper. He writes *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Each of those integers can be either 0 or 1. He's allowed to do exactly one move: he chooses two indices *i* and *j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) and flips all values *a**k* for which their positions are in range [*i*,<=*j*] (that is *i*<=≤<=*k*<=≤<=*j*). Flip the value of *x* means to apply operation *x*<==<=1 - *x*. The goal of the game is that after exactly one move to obtain the maximum number of ones. Write a program to solve the little game of Iahub. Input Specification: The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=100). In the second line of the input there are *n* integers: *a*1,<=*a*2,<=...,<=*a**n*. It is guaranteed that each of those *n* values is either 0 or 1. Output Specification: Print an integer — the maximal number of 1s that can be obtained after exactly one move. Demo Input: ['5\n1 0 0 1 0\n', '4\n1 0 0 1\n'] Demo Output: ['4\n', '4\n'] Note: In the first case, flip the segment from 2 to 5 (*i* = 2, *j* = 5). That flip changes the sequence, it becomes: [1 1 1 0 1]. So, it contains four ones. There is no way to make the whole sequence equal to [1 1 1 1 1]. In the second case, flipping only the second and the third element (*i* = 2, *j* = 3) will turn all numbers into 1.

```python def score(i, j, a): b = [x for x in a] for i in range(i, j+1): if b[i] == 0: b[i] = 1 else: b[i] = 0 return b.count(1) def findMax(n, a): ans = 0 for i in range(n): for j in range(i, n): ans = max(ans, score(i, j, a)) return ans n = int(input()) a = list(map(int, input().split())) print(findMax(n, a)) ```

3

41

B

Martian Dollar

PROGRAMMING

1,400

[ "brute force" ]

B. Martian Dollar

2

256

One day Vasya got hold of information on the Martian dollar course in bourles for the next *n* days. The buying prices and the selling prices for one dollar on day *i* are the same and are equal to *a**i*. Vasya has *b* bourles. He can buy a certain number of dollars and then sell it no more than once in *n* days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day *n*?

The first line contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=2000) — the number of days and the initial number of money in bourles. The next line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=2000) — the prices of Martian dollars.

Print the single number — which maximal sum of money in bourles can Vasya get by the end of day *n*.

[ "2 4\n3 7\n", "4 10\n4 3 2 1\n", "4 10\n4 2 3 1\n" ]

[ "8\n", "10\n", "15\n" ]

none

1,000

[ { "input": "2 4\n3 7", "output": "8" }, { "input": "4 10\n4 3 2 1", "output": "10" }, { "input": "4 10\n4 2 3 1", "output": "15" }, { "input": "2 755\n51 160", "output": "2281" }, { "input": "3 385\n978 1604 1888", "output": "385" }, { "input": "4 1663\n1904 1049 1622 472", "output": "2236" }, { "input": "5 1293\n1183 142 1356 889 134", "output": "12219" }, { "input": "1 1472\n784", "output": "1472" }, { "input": "1 478\n1955", "output": "478" }, { "input": "1 1483\n1126", "output": "1483" }, { "input": "10 595\n881 832 1159 171 230 750 361 1800 516 567", "output": "5482" }, { "input": "93 867\n97 1270 616 1027 1685 27 1662 947 1480 20 1394 1528 191 1348 67 1694 1772 1706 1394 109 1391 878 1474 307 101 663 1064 116 143 1239 386 651 1534 1348 1604 636 793 1188 1293 24 1729 1204 1656 1579 1644 661 1470 341 1709 1860 1081 1539 5 1892 1732 1049 419 25 1086 1263 967 1284 1229 1013 1348 1046 927 1492 1459 1523 459 1907 68 853 822 994 912 266 850 1991 714 1803 513 835 947 313 1287 1183 285 182 1053 1192 615", "output": "344445" }, { "input": "23 1966\n625 1474 1628 1770 1365 922 120 844 826 1145 878 1479 1489 10 1081 1182 1862 303 101 100 14 1319 326", "output": "364958" }, { "input": "43 1427\n651 1624 295 6 1615 1683 741 183 734 1056 1487 633 1368 1267 1782 1091 541 1277 1263 1703 785 223 184 1837 1724 1581 1400 1483 445 1490 580 643 1998 41 1581 873 1906 846 1607 1503 1131 1858 1861", "output": "473531" }, { "input": "39 897\n18 38 122 130 337 471 492 518 541 557 568 637 688 861 927 989 1018 1046 1158 1292 1309 1316 1347 1380 1430 1530 1589 1637 1651 1696 1798 1821 1829 1830 1838 1883 1896 1912 1917", "output": "93948" } ]

1,645,578,037

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

60

0

#بسم الله الرحمن الرحيم n, b = [int(i) for i in input().split()] dolars_price =[int(i) for i in input().split()] i=j=0 fin =[0] for i in range(len(dolars_price)-1): for j in range(i,len(dolars_price)-1): if dolars_price[j]>dolars_price[i] and b>=dolars_price[i]: z=b%dolars_price[i] cost= ((b-z)/dolars_price[i]) * (dolars_price[j]-dolars_price[i]) fin.append(cost) print(int(max(fin)+b))

Title: Martian Dollar Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: One day Vasya got hold of information on the Martian dollar course in bourles for the next *n* days. The buying prices and the selling prices for one dollar on day *i* are the same and are equal to *a**i*. Vasya has *b* bourles. He can buy a certain number of dollars and then sell it no more than once in *n* days. According to Martian laws, one can buy only an integer number of dollars. Which maximal sum of money in bourles can Vasya get by the end of day *n*? Input Specification: The first line contains two integers *n* and *b* (1<=≤<=*n*,<=*b*<=≤<=2000) — the number of days and the initial number of money in bourles. The next line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=2000) — the prices of Martian dollars. Output Specification: Print the single number — which maximal sum of money in bourles can Vasya get by the end of day *n*. Demo Input: ['2 4\n3 7\n', '4 10\n4 3 2 1\n', '4 10\n4 2 3 1\n'] Demo Output: ['8\n', '10\n', '15\n'] Note: none

```python #بسم الله الرحمن الرحيم n, b = [int(i) for i in input().split()] dolars_price =[int(i) for i in input().split()] i=j=0 fin =[0] for i in range(len(dolars_price)-1): for j in range(i,len(dolars_price)-1): if dolars_price[j]>dolars_price[i] and b>=dolars_price[i]: z=b%dolars_price[i] cost= ((b-z)/dolars_price[i]) * (dolars_price[j]-dolars_price[i]) fin.append(cost) print(int(max(fin)+b)) ```

0

522

A

Reposts

PROGRAMMING

1,200

[ "*special", "dfs and similar", "dp", "graphs", "trees" ]

null

One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on. These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed. Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.

The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive. We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.

Print a single integer — the maximum length of a repost chain.

[ "5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya\n", "6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp\n", "1\nSoMeStRaNgEgUe reposted PoLyCaRp\n" ]

[ "6\n", "2\n", "2\n" ]

none

500

[ { "input": "5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya", "output": "6" }, { "input": "6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp", "output": "2" }, { "input": "1\nSoMeStRaNgEgUe reposted PoLyCaRp", "output": "2" }, { "input": "1\niuNtwVf reposted POlYcarP", "output": "2" }, { "input": "10\ncs reposted poLYCaRp\nAFIkDrY7Of4V7Mq reposted CS\nsoBiwyN7KOvoFUfbhux reposted aFikDry7Of4v7MQ\nvb6LbwA reposted sObIWYN7KOvoFufBHUx\nDtWKIcVwIHgj4Rcv reposted vb6lbwa\nkt reposted DTwKicvwihgJ4rCV\n75K reposted kT\njKzyxx1 reposted 75K\nuoS reposted jkZyXX1\npZJskHTCIqE3YyZ5ME reposted uoS", "output": "11" }, { "input": "10\nvxrUpCXvx8Isq reposted pOLYcaRP\nICb1 reposted vXRUpCxvX8ISq\nJFMt4b8jZE7iF2m8by7y2 reposted Icb1\nqkG6ZkMIf9QRrBFQU reposted ICb1\nnawsNfcR2palIMnmKZ reposted pOlYcaRP\nKksyH reposted jFMT4b8JzE7If2M8by7y2\nwJtWwQS5FvzN0h8CxrYyL reposted NawsNfcR2paLIMnmKz\nDpBcBPYAcTXEdhldI6tPl reposted NaWSnFCr2pALiMnmkZ\nlEnwTVnlwdQg2vaIRQry reposted kKSYh\nQUVFgwllaWO reposted Wjtwwqs5FVzN0H8cxRyyl", "output": "6" }, { "input": "10\nkkuLGEiHv reposted POLYcArp\n3oX1AoUqyw1eR3nCADY9hLwd reposted kkuLGeIHV\nwf97dqq5bx1dPIchCoT reposted 3OX1AOuQYW1eR3ncAdY9hLwD\nWANr8h reposted Wf97dQQ5bx1dpIcHcoT\n3Fb736lkljZK2LtSbfL reposted wANR8h\n6nq9xLOn reposted 3fB736lKlJZk2LtSbFL\nWL reposted 3Fb736lKLjZk2LTSbfl\ndvxn4Xtc6SBcvKf1 reposted wF97DQq5bX1dPiChCOt\nMCcPLIMISqxDzrj reposted 6nQ9XLOn\nxsQL4Z2Iu reposted MCcpLiMiSqxdzrj", "output": "9" }, { "input": "10\nsMA4 reposted pOLyCARP\nlq3 reposted pOlycARp\nEa16LSFTQxLJnE reposted polYcARp\nkvZVZhJwXcWsnC7NA1DV2WvS reposted polYCArp\nEYqqlrjRwddI reposted pOlyCArP\nsPqQCA67Y6PBBbcaV3EhooO reposted ea16LSFTqxLJne\njjPnneZdF6WLZ3v reposted Ea16LSFTqxLjNe\nWEoi6UpnfBUx79 reposted ea16LSFtqXljNe\nqi4yra reposted eYqqlRJrWDDI\ncw7E1UCSUD reposted eYqqLRJRwDdI", "output": "3" } ]

1,600,185,564

2,147,483,647

Python 3

OK

TESTS

36

109

307,200

global maxval maxval = 0 def dfs(node, g, val): global maxval maxval = max(maxval, val) if node in g: for i in g[node]: dfs(i, g, val+1) n = int(input()) g={} for i in range(n): s = input() s = s.lower().split() if s[2] in g: g[s[2]].append(s[0]) else: g[s[2]] = [s[0]] dfs("polycarp", g, 1) print(maxval)

Title: Reposts Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on. These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed. Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke. Input Specification: The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive. We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user. Output Specification: Print a single integer — the maximum length of a repost chain. Demo Input: ['5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya\n', '6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp\n', '1\nSoMeStRaNgEgUe reposted PoLyCaRp\n'] Demo Output: ['6\n', '2\n', '2\n'] Note: none

```python global maxval maxval = 0 def dfs(node, g, val): global maxval maxval = max(maxval, val) if node in g: for i in g[node]: dfs(i, g, val+1) n = int(input()) g={} for i in range(n): s = input() s = s.lower().split() if s[2] in g: g[s[2]].append(s[0]) else: g[s[2]] = [s[0]] dfs("polycarp", g, 1) print(maxval) ```

3

166

A

Rank List

PROGRAMMING

1,100

[ "binary search", "implementation", "sortings" ]

null

Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place. You know the rules of comparing the results of two given teams very well. Let's say that team *a* solved *p**a* problems with total penalty time *t**a* and team *b* solved *p**b* problems with total penalty time *t**b*. Team *a* gets a higher place than team *b* in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team *a* gets a higher place than team *b* in the final results' table if either *p**a*<=><=*p**b*, or *p**a*<==<=*p**b* and *t**a*<=<<=*t**b*. It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of *x* teams that solved the same number of problems with the same penalty time. Let's also say that *y* teams performed better than the teams from this group. In this case all teams from the group share places *y*<=+<=1, *y*<=+<=2, ..., *y*<=+<=*x*. The teams that performed worse than the teams from this group, get their places in the results table starting from the *y*<=+<=*x*<=+<=1-th place. Your task is to count what number of teams from the given list shared the *k*-th place.

The first line contains two integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=50). Then *n* lines contain the description of the teams: the *i*-th line contains two integers *p**i* and *t**i* (1<=≤<=*p**i*,<=*t**i*<=≤<=50) — the number of solved problems and the total penalty time of the *i*-th team, correspondingly. All numbers in the lines are separated by spaces.

In the only line print the sought number of teams that got the *k*-th place in the final results' table.

[ "7 2\n4 10\n4 10\n4 10\n3 20\n2 1\n2 1\n1 10\n", "5 4\n3 1\n3 1\n5 3\n3 1\n3 1\n" ]

[ "3\n", "4\n" ]

The final results' table for the first sample is: - 1-3 places — 4 solved problems, the penalty time equals 10 - 4 place — 3 solved problems, the penalty time equals 20 - 5-6 places — 2 solved problems, the penalty time equals 1 - 7 place — 1 solved problem, the penalty time equals 10 The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams. The final table for the second sample is: - 1 place — 5 solved problems, the penalty time equals 3 - 2-5 places — 3 solved problems, the penalty time equals 1 The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.

500

[ { "input": "7 2\n4 10\n4 10\n4 10\n3 20\n2 1\n2 1\n1 10", "output": "3" }, { "input": "5 4\n3 1\n3 1\n5 3\n3 1\n3 1", "output": "4" }, { "input": "5 1\n2 2\n1 1\n1 1\n1 1\n2 2", "output": "2" }, { "input": "6 3\n2 2\n3 1\n2 2\n4 5\n2 2\n4 5", "output": "1" }, { "input": "5 5\n3 1\n10 2\n2 2\n1 10\n10 2", "output": "1" }, { "input": "3 2\n3 3\n3 3\n3 3", "output": "3" }, { "input": "4 3\n10 3\n6 10\n5 2\n5 2", "output": "2" }, { "input": "5 3\n10 10\n10 10\n1 1\n10 10\n4 3", "output": "3" }, { "input": "3 1\n2 1\n1 1\n1 2", "output": "1" }, { "input": "1 1\n28 28", "output": "1" }, { "input": "2 2\n1 2\n1 2", "output": "2" }, { "input": "5 3\n2 3\n4 2\n5 3\n2 4\n3 5", "output": "1" }, { "input": "50 22\n4 9\n8 1\n3 7\n1 2\n3 8\n9 8\n8 5\n2 10\n5 8\n1 3\n1 8\n2 3\n7 9\n10 2\n9 9\n7 3\n8 6\n10 6\n5 4\n8 1\n1 5\n6 8\n9 5\n9 5\n3 2\n3 3\n3 8\n7 5\n4 5\n8 10\n8 2\n3 5\n3 2\n1 1\n7 2\n2 7\n6 8\n10 4\n7 5\n1 7\n6 5\n3 1\n4 9\n2 3\n3 6\n5 8\n4 10\n10 7\n7 10\n9 8", "output": "1" }, { "input": "50 6\n11 20\n18 13\n1 13\n3 11\n4 17\n15 10\n15 8\n9 16\n11 17\n16 3\n3 20\n14 13\n12 15\n9 10\n14 2\n12 12\n13 17\n6 10\n20 9\n2 8\n13 7\n7 20\n15 3\n1 20\n2 13\n2 5\n14 7\n10 13\n15 12\n15 5\n17 6\n9 11\n18 5\n10 1\n15 14\n3 16\n6 12\n4 1\n14 9\n7 14\n8 17\n17 13\n4 6\n19 16\n5 6\n3 15\n4 19\n15 20\n2 10\n20 10", "output": "1" }, { "input": "50 12\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "50" }, { "input": "50 28\n2 2\n1 1\n2 1\n1 2\n1 1\n1 1\n1 1\n2 2\n2 2\n2 2\n2 1\n2 2\n2 1\n2 1\n1 2\n1 2\n1 2\n1 1\n2 2\n1 2\n2 2\n2 2\n2 1\n1 1\n1 2\n1 2\n1 1\n1 1\n1 1\n2 2\n2 1\n2 1\n2 2\n1 2\n1 2\n1 2\n1 1\n2 2\n1 2\n1 1\n2 2\n2 2\n1 1\n2 1\n2 1\n1 1\n2 2\n2 2\n2 2\n2 2", "output": "13" }, { "input": "50 40\n2 3\n3 1\n2 1\n2 1\n2 1\n3 1\n1 1\n1 2\n2 3\n1 3\n1 3\n2 1\n3 1\n1 1\n3 1\n3 1\n2 2\n1 1\n3 3\n3 1\n3 2\n2 3\n3 3\n3 1\n1 3\n2 3\n2 1\n3 2\n3 3\n3 1\n2 1\n2 2\n1 3\n3 3\n1 1\n3 2\n1 2\n2 3\n2 1\n2 2\n3 2\n1 3\n3 1\n1 1\n3 3\n2 3\n2 1\n2 3\n2 3\n1 2", "output": "5" }, { "input": "50 16\n2 1\n3 2\n5 2\n2 2\n3 4\n4 4\n3 3\n4 1\n2 3\n1 5\n4 1\n2 2\n1 5\n3 2\n2 1\n5 4\n5 2\n5 4\n1 1\n3 5\n2 1\n4 5\n5 1\n5 5\n5 4\n2 4\n1 2\n5 5\n4 4\n1 5\n4 2\n5 1\n2 4\n2 5\n2 2\n3 4\n3 1\n1 1\n5 5\n2 2\n3 4\n2 4\n5 2\n4 1\n3 1\n1 1\n4 1\n4 4\n1 4\n1 3", "output": "1" }, { "input": "50 32\n6 6\n4 2\n5 5\n1 1\n2 4\n6 5\n2 3\n6 5\n2 3\n6 3\n1 4\n1 6\n3 3\n2 4\n3 2\n6 2\n4 1\n3 3\n3 1\n5 5\n1 2\n2 1\n5 4\n3 1\n4 4\n5 6\n4 1\n2 5\n3 1\n4 6\n2 3\n1 1\n6 5\n2 6\n3 3\n2 6\n2 3\n2 6\n3 4\n2 6\n4 5\n5 4\n1 6\n3 2\n5 1\n4 1\n4 6\n4 2\n1 2\n5 2", "output": "1" }, { "input": "50 48\n5 1\n6 4\n3 2\n2 1\n4 7\n3 6\n7 1\n7 5\n6 5\n5 6\n4 7\n5 7\n5 7\n5 5\n7 3\n3 5\n4 3\n5 4\n6 2\n1 6\n6 3\n6 5\n5 2\n4 2\n3 1\n1 1\n5 6\n1 3\n6 5\n3 7\n1 5\n7 5\n6 5\n3 6\n2 7\n5 3\n5 3\n4 7\n5 2\n6 5\n5 7\n7 1\n2 3\n5 5\n2 6\n4 1\n6 2\n6 5\n3 3\n1 6", "output": "1" }, { "input": "50 8\n5 3\n7 3\n4 3\n7 4\n2 2\n4 4\n5 4\n1 1\n7 7\n4 8\n1 1\n6 3\n1 5\n7 3\n6 5\n4 5\n8 6\n3 6\n2 1\n3 2\n2 5\n7 6\n5 8\n1 3\n5 5\n8 4\n4 5\n4 4\n8 8\n7 2\n7 2\n3 6\n2 8\n8 3\n3 2\n4 5\n8 1\n3 2\n8 7\n6 3\n2 3\n5 1\n3 4\n7 2\n6 3\n7 3\n3 3\n6 4\n2 2\n5 1", "output": "3" }, { "input": "20 16\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "20" }, { "input": "20 20\n1 2\n2 2\n1 1\n2 1\n2 2\n1 1\n1 1\n2 1\n1 1\n1 2\n2 2\n1 2\n1 2\n2 2\n2 2\n1 2\n2 1\n2 1\n1 2\n2 2", "output": "6" }, { "input": "30 16\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "30" }, { "input": "30 22\n2 1\n1 2\n2 1\n2 2\n2 1\n1 2\n2 2\n1 2\n2 2\n1 2\n2 2\n1 2\n1 2\n2 1\n1 2\n2 2\n2 2\n1 2\n2 1\n1 1\n1 2\n1 2\n1 1\n1 2\n1 2\n2 2\n1 2\n2 2\n2 1\n1 1", "output": "13" }, { "input": "30 22\n1 1\n1 3\n2 3\n3 1\n2 3\n3 1\n1 2\n3 3\n2 1\n2 1\n2 2\n3 1\n3 2\n2 3\n3 1\n1 3\n2 3\n3 1\n1 2\n1 2\n2 3\n2 1\n3 3\n3 2\n1 3\n3 3\n3 3\n3 3\n3 3\n3 1", "output": "5" }, { "input": "50 16\n2 1\n3 2\n5 2\n2 2\n3 4\n4 4\n3 3\n4 1\n2 3\n1 5\n4 1\n2 2\n1 5\n3 2\n2 1\n5 4\n5 2\n5 4\n1 1\n3 5\n2 1\n4 5\n5 1\n5 5\n5 4\n2 4\n1 2\n5 5\n4 4\n1 5\n4 2\n5 1\n2 4\n2 5\n2 2\n3 4\n3 1\n1 1\n5 5\n2 2\n3 4\n2 4\n5 2\n4 1\n3 1\n1 1\n4 1\n4 4\n1 4\n1 3", "output": "1" }, { "input": "50 22\n4 9\n8 1\n3 7\n1 2\n3 8\n9 8\n8 5\n2 10\n5 8\n1 3\n1 8\n2 3\n7 9\n10 2\n9 9\n7 3\n8 6\n10 6\n5 4\n8 1\n1 5\n6 8\n9 5\n9 5\n3 2\n3 3\n3 8\n7 5\n4 5\n8 10\n8 2\n3 5\n3 2\n1 1\n7 2\n2 7\n6 8\n10 4\n7 5\n1 7\n6 5\n3 1\n4 9\n2 3\n3 6\n5 8\n4 10\n10 7\n7 10\n9 8", "output": "1" }, { "input": "50 22\n29 15\n18 10\n6 23\n38 28\n34 40\n40 1\n16 26\n22 33\n14 30\n26 7\n15 16\n22 40\n14 15\n6 28\n32 27\n33 3\n38 22\n40 17\n16 27\n21 27\n34 26\n5 15\n34 9\n38 23\n7 36\n17 6\n19 37\n40 1\n10 28\n9 14\n8 31\n40 8\n14 2\n24 16\n38 33\n3 37\n2 9\n21 21\n40 26\n28 33\n24 31\n10 12\n27 27\n17 4\n38 5\n21 31\n5 12\n29 7\n39 12\n26 14", "output": "1" }, { "input": "50 14\n4 20\n37 50\n46 19\n20 25\n47 10\n6 34\n12 41\n47 9\n22 28\n41 34\n47 40\n12 42\n9 4\n15 15\n27 8\n38 9\n4 17\n8 13\n47 7\n9 38\n30 48\n50 7\n41 34\n23 11\n16 37\n2 32\n18 46\n37 48\n47 41\n13 9\n24 50\n46 14\n33 49\n9 50\n35 30\n49 44\n42 49\n39 15\n33 42\n3 18\n44 15\n44 28\n9 17\n16 4\n10 36\n4 22\n47 17\n24 12\n2 31\n6 30", "output": "2" }, { "input": "2 1\n50 50\n50 50", "output": "2" }, { "input": "2 2\n50 50\n50 50", "output": "2" }, { "input": "2 1\n50 50\n50 49", "output": "1" }, { "input": "2 2\n50 50\n50 49", "output": "1" }, { "input": "50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50", "output": "50" }, { "input": "50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n49 50", "output": "1" }, { "input": "50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 50\n50 49", "output": "49" }, { "input": "10 1\n3 1\n3 2\n3 2\n2 3\n2 3\n2 3\n2 4\n2 4\n2 4\n2 4", "output": "1" }, { "input": "4 3\n1 1\n1 2\n2 1\n2 2", "output": "1" }, { "input": "4 2\n1 2\n1 3\n1 5\n1 2", "output": "2" }, { "input": "6 1\n4 3\n4 2\n5 1\n5 2\n5 3\n5 3", "output": "1" }, { "input": "5 3\n2 1\n1 3\n1 2\n1 1\n1 1", "output": "2" }, { "input": "3 1\n1 1\n1 2\n1 3", "output": "1" }, { "input": "10 10\n3 1\n3 2\n3 2\n2 3\n2 3\n2 3\n2 4\n2 4\n2 4\n2 4", "output": "4" }, { "input": "5 1\n5 5\n5 6\n5 7\n5 8\n5 5", "output": "2" }, { "input": "4 1\n1 1\n1 1\n1 2\n1 3", "output": "2" } ]

1,664,993,030

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

92

0

n,k=str(input()).split() n,k=int(n),int(k) a=[] mx=0 for i in range(n): p,t=map(int,str(input()).split()) a.append([p,t]) for j in range(n-1): if a[j][0]<a[j+1][0] or a[j][1]>a[j+1][1]: y=a[j] u=a[j+1] a[j]=u a[j+1]=y t=a[k-1] if t in a: print(a.count(t)) else: print(1)

Title: Rank List Time Limit: None seconds Memory Limit: None megabytes Problem Description: Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place. You know the rules of comparing the results of two given teams very well. Let's say that team *a* solved *p**a* problems with total penalty time *t**a* and team *b* solved *p**b* problems with total penalty time *t**b*. Team *a* gets a higher place than team *b* in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team *a* gets a higher place than team *b* in the final results' table if either *p**a*<=><=*p**b*, or *p**a*<==<=*p**b* and *t**a*<=<<=*t**b*. It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of *x* teams that solved the same number of problems with the same penalty time. Let's also say that *y* teams performed better than the teams from this group. In this case all teams from the group share places *y*<=+<=1, *y*<=+<=2, ..., *y*<=+<=*x*. The teams that performed worse than the teams from this group, get their places in the results table starting from the *y*<=+<=*x*<=+<=1-th place. Your task is to count what number of teams from the given list shared the *k*-th place. Input Specification: The first line contains two integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=50). Then *n* lines contain the description of the teams: the *i*-th line contains two integers *p**i* and *t**i* (1<=≤<=*p**i*,<=*t**i*<=≤<=50) — the number of solved problems and the total penalty time of the *i*-th team, correspondingly. All numbers in the lines are separated by spaces. Output Specification: In the only line print the sought number of teams that got the *k*-th place in the final results' table. Demo Input: ['7 2\n4 10\n4 10\n4 10\n3 20\n2 1\n2 1\n1 10\n', '5 4\n3 1\n3 1\n5 3\n3 1\n3 1\n'] Demo Output: ['3\n', '4\n'] Note: The final results' table for the first sample is: - 1-3 places — 4 solved problems, the penalty time equals 10 - 4 place — 3 solved problems, the penalty time equals 20 - 5-6 places — 2 solved problems, the penalty time equals 1 - 7 place — 1 solved problem, the penalty time equals 10 The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams. The final table for the second sample is: - 1 place — 5 solved problems, the penalty time equals 3 - 2-5 places — 3 solved problems, the penalty time equals 1 The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.

```python n,k=str(input()).split() n,k=int(n),int(k) a=[] mx=0 for i in range(n): p,t=map(int,str(input()).split()) a.append([p,t]) for j in range(n-1): if a[j][0]<a[j+1][0] or a[j][1]>a[j+1][1]: y=a[j] u=a[j+1] a[j]=u a[j+1]=y t=a[k-1] if t in a: print(a.count(t)) else: print(1) ```

0

907

A

Masha and Bears

PROGRAMMING

1,300

[ "brute force", "implementation" ]

null

A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son bear can climb into the smallest car and he likes it. It's known that the largest car is strictly larger than the middle car, and the middle car is strictly larger than the smallest car. Masha came to test these cars. She could climb into all cars, but she liked only the smallest car. It's known that a character with size *a* can climb into some car with size *b* if and only if *a*<=≤<=*b*, he or she likes it if and only if he can climb into this car and 2*a*<=≥<=*b*. You are given sizes of bears and Masha. Find out some possible integer non-negative sizes of cars.

You are given four integers *V*1, *V*2, *V*3, *V**m*(1<=≤<=*V**i*<=≤<=100) — sizes of father bear, mother bear, son bear and Masha, respectively. It's guaranteed that *V*1<=><=*V*2<=><=*V*3.

Output three integers — sizes of father bear's car, mother bear's car and son bear's car, respectively. If there are multiple possible solutions, print any. If there is no solution, print "-1" (without quotes).

[ "50 30 10 10\n", "100 50 10 21\n" ]

[ "50\n30\n10\n", "-1\n" ]

In first test case all conditions for cars' sizes are satisfied. In second test case there is no answer, because Masha should be able to climb into smallest car (so size of smallest car in not less than 21), but son bear should like it, so maximum possible size of it is 20.

500

[ { "input": "50 30 10 10", "output": "50\n30\n10" }, { "input": "100 50 10 21", "output": "-1" }, { "input": "100 50 19 10", "output": "100\n50\n19" }, { "input": "99 50 25 49", "output": "100\n99\n49" }, { "input": "3 2 1 1", "output": "4\n3\n1" }, { "input": "100 99 98 100", "output": "-1" }, { "input": "100 40 30 40", "output": "-1" }, { "input": "100 50 19 25", "output": "100\n51\n25" }, { "input": "100 50 19 30", "output": "100\n61\n30" }, { "input": "49 48 25 49", "output": "-1" }, { "input": "48 47 23 46", "output": "94\n93\n46" }, { "input": "37 23 16 20", "output": "42\n41\n20" }, { "input": "98 2 1 1", "output": "98\n3\n1" }, { "input": "99 22 13 14", "output": "99\n29\n14" }, { "input": "97 95 3 2", "output": "97\n95\n3" }, { "input": "27 3 2 3", "output": "-1" }, { "input": "13 7 6 2", "output": "-1" }, { "input": "19 17 11 6", "output": "19\n17\n11" }, { "input": "15 6 4 5", "output": "15\n11\n5" }, { "input": "21 3 1 3", "output": "-1" }, { "input": "100 99 98 97", "output": "196\n195\n98" }, { "input": "99 32 13 5", "output": "-1" }, { "input": "5 4 3 1", "output": "-1" }, { "input": "50 20 4 8", "output": "50\n20\n8" }, { "input": "60 30 10 1", "output": "-1" }, { "input": "100 50 10 1", "output": "-1" }, { "input": "40 30 20 10", "output": "40\n30\n20" }, { "input": "50 49 5 10", "output": "50\n49\n10" }, { "input": "99 98 50 97", "output": "196\n195\n97" }, { "input": "50 30 10 5", "output": "50\n30\n10" }, { "input": "4 3 2 1", "output": "4\n3\n2" }, { "input": "100 50 3 1", "output": "-1" } ]

1,514,039,017

1,117

Python 3

OK

TESTS

32

62

5,529,600

v1, v2, v3, vm = map(int, input().split()) if vm > 2*v3 or v3> 2*vm or vm >= v2 or vm >= v1: print(-1) else: print(2*v1) print(2*v2) print(max(v3, vm))

Title: Masha and Bears Time Limit: None seconds Memory Limit: None megabytes Problem Description: A family consisting of father bear, mother bear and son bear owns three cars. Father bear can climb into the largest car and he likes it. Also, mother bear can climb into the middle car and she likes it. Moreover, son bear can climb into the smallest car and he likes it. It's known that the largest car is strictly larger than the middle car, and the middle car is strictly larger than the smallest car. Masha came to test these cars. She could climb into all cars, but she liked only the smallest car. It's known that a character with size *a* can climb into some car with size *b* if and only if *a*<=≤<=*b*, he or she likes it if and only if he can climb into this car and 2*a*<=≥<=*b*. You are given sizes of bears and Masha. Find out some possible integer non-negative sizes of cars. Input Specification: You are given four integers *V*1, *V*2, *V*3, *V**m*(1<=≤<=*V**i*<=≤<=100) — sizes of father bear, mother bear, son bear and Masha, respectively. It's guaranteed that *V*1<=><=*V*2<=><=*V*3. Output Specification: Output three integers — sizes of father bear's car, mother bear's car and son bear's car, respectively. If there are multiple possible solutions, print any. If there is no solution, print "-1" (without quotes). Demo Input: ['50 30 10 10\n', '100 50 10 21\n'] Demo Output: ['50\n30\n10\n', '-1\n'] Note: In first test case all conditions for cars' sizes are satisfied. In second test case there is no answer, because Masha should be able to climb into smallest car (so size of smallest car in not less than 21), but son bear should like it, so maximum possible size of it is 20.

```python v1, v2, v3, vm = map(int, input().split()) if vm > 2*v3 or v3> 2*vm or vm >= v2 or vm >= v1: print(-1) else: print(2*v1) print(2*v2) print(max(v3, vm)) ```

3

450

A

Jzzhu and Children

PROGRAMMING

1,000

[ "implementation" ]

null

There are *n* children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to *n*. The *i*-th child wants to get at least *a**i* candies. Jzzhu asks children to line up. Initially, the *i*-th child stands at the *i*-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm: 1. Give *m* candies to the first child of the line. 1. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home. 1. Repeat the first two steps while the line is not empty. Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order?

The first line contains two integers *n*,<=*m* (1<=≤<=*n*<=≤<=100; 1<=≤<=*m*<=≤<=100). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100).

Output a single integer, representing the number of the last child.

[ "5 2\n1 3 1 4 2\n", "6 4\n1 1 2 2 3 3\n" ]

[ "4\n", "6\n" ]

Let's consider the first sample. Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home. Child 4 is the last one who goes home.

500

[ { "input": "5 2\n1 3 1 4 2", "output": "4" }, { "input": "6 4\n1 1 2 2 3 3", "output": "6" }, { "input": "7 3\n6 1 5 4 2 3 1", "output": "4" }, { "input": "10 5\n2 7 3 6 2 5 1 3 4 5", "output": "4" }, { "input": "100 1\n1 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 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 93 94 95 96 97 98 99 100", "output": "100" }, { "input": "9 3\n9 5 2 3 7 1 8 4 6", "output": "7" }, { "input": "20 10\n58 4 32 10 73 7 30 39 47 6 59 21 24 66 79 79 46 13 29 58", "output": "16" }, { "input": "50 5\n89 56 3 2 40 37 56 52 83 59 43 83 43 59 29 74 22 58 53 41 53 67 78 30 57 32 58 29 95 46 45 85 60 49 41 82 8 71 52 40 45 26 6 71 84 91 4 93 40 54", "output": "48" }, { "input": "50 1\n4 3 9 7 6 8 3 7 10 9 8 8 10 2 9 3 2 4 4 10 4 6 8 10 9 9 4 2 8 9 4 4 9 5 1 5 2 4 4 9 10 2 5 10 7 2 8 6 8 1", "output": "44" }, { "input": "50 5\n3 9 10 8 3 3 4 6 8 2 9 9 3 1 2 10 6 8 7 2 7 4 2 7 5 10 2 2 2 5 10 5 6 6 8 7 10 4 3 2 10 8 6 6 8 6 4 4 1 3", "output": "46" }, { "input": "50 2\n56 69 72 15 95 92 51 1 74 87 100 29 46 54 18 81 84 72 84 83 20 63 71 27 45 74 50 89 48 8 21 15 47 3 39 73 80 84 6 99 17 25 56 3 74 64 71 39 89 78", "output": "40" }, { "input": "50 3\n31 39 64 16 86 3 1 9 25 54 98 42 20 3 49 41 73 37 55 62 33 77 64 22 33 82 26 13 10 13 7 40 48 18 46 79 94 72 19 12 11 61 16 37 10 49 14 94 48 69", "output": "11" }, { "input": "50 100\n67 67 61 68 42 29 70 77 12 61 71 27 4 73 87 52 59 38 93 90 31 27 87 47 26 57 76 6 28 72 81 68 50 84 69 79 39 93 52 6 88 12 46 13 90 68 71 38 90 95", "output": "50" }, { "input": "100 3\n4 14 20 11 19 11 14 20 5 7 6 12 11 17 5 11 7 6 2 10 13 5 12 8 5 17 20 18 7 19 11 7 7 20 20 8 10 17 17 19 20 5 15 16 19 7 11 16 4 17 2 10 1 20 20 16 19 9 9 11 5 7 12 9 9 6 20 18 13 19 8 4 8 1 2 4 10 11 15 14 1 7 17 12 13 19 12 2 3 14 15 15 5 17 14 12 17 14 16 9", "output": "86" }, { "input": "100 5\n16 8 14 16 12 11 17 19 19 2 8 9 5 6 19 9 11 18 6 9 14 16 14 18 17 17 17 5 15 20 19 7 7 10 10 5 14 20 5 19 11 16 16 19 17 9 7 12 14 10 2 11 14 5 20 8 10 11 19 2 14 14 19 17 5 10 8 8 4 2 1 10 20 12 14 11 7 6 6 15 1 5 9 15 3 17 16 17 5 14 11 9 16 15 1 11 10 6 15 7", "output": "93" }, { "input": "100 1\n58 94 18 50 17 14 96 62 83 80 75 5 9 22 25 41 3 96 74 45 66 37 2 37 13 85 68 54 77 11 85 19 25 21 52 59 90 61 72 89 82 22 10 16 3 68 61 29 55 76 28 85 65 76 27 3 14 10 56 37 86 18 35 38 56 68 23 88 33 38 52 87 55 83 94 34 100 41 83 56 91 77 32 74 97 13 67 31 57 81 53 39 5 88 46 1 79 4 49 42", "output": "77" }, { "input": "100 2\n1 51 76 62 34 93 90 43 57 59 52 78 3 48 11 60 57 48 5 54 28 81 87 23 44 77 67 61 14 73 29 53 21 89 67 41 47 9 63 37 1 71 40 85 4 14 77 40 78 75 89 74 4 70 32 65 81 95 49 90 72 41 76 55 69 83 73 84 85 93 46 6 74 90 62 37 97 7 7 37 83 30 37 88 34 16 11 59 85 19 57 63 85 20 63 97 97 65 61 48", "output": "97" }, { "input": "100 3\n30 83 14 55 61 66 34 98 90 62 89 74 45 93 33 31 75 35 82 100 63 69 48 18 99 2 36 71 14 30 70 76 96 85 97 90 49 36 6 76 37 94 70 3 63 73 75 48 39 29 13 2 46 26 9 56 1 18 54 53 85 34 2 12 1 93 75 67 77 77 14 26 33 25 55 9 57 70 75 6 87 66 18 3 41 69 73 24 49 2 20 72 39 58 91 54 74 56 66 78", "output": "20" }, { "input": "100 4\n69 92 76 3 32 50 15 38 21 22 14 3 67 41 95 12 10 62 83 52 78 1 18 58 94 35 62 71 58 75 13 73 60 34 50 97 50 70 19 96 53 10 100 26 20 39 62 59 88 26 24 83 70 68 66 8 6 38 16 93 2 91 81 89 78 74 21 8 31 56 28 53 77 5 81 5 94 42 77 75 92 15 59 36 61 18 55 45 69 68 81 51 12 42 85 74 98 31 17 41", "output": "97" }, { "input": "100 5\n2 72 10 60 6 50 72 34 97 77 35 43 80 64 40 53 46 6 90 22 29 70 26 68 52 19 72 88 83 18 55 32 99 81 11 21 39 42 41 63 60 97 30 23 55 78 89 35 24 50 99 52 27 76 24 8 20 27 51 37 17 82 69 18 46 19 26 77 52 83 76 65 43 66 84 84 13 30 66 88 84 23 37 1 17 26 11 50 73 56 54 37 40 29 35 8 1 39 50 82", "output": "51" }, { "input": "100 7\n6 73 7 54 92 33 66 65 80 47 2 53 28 59 61 16 54 89 37 48 77 40 49 59 27 52 17 22 78 80 81 80 8 93 50 7 87 57 29 16 89 55 20 7 51 54 30 98 44 96 27 70 1 1 32 61 22 92 84 98 31 89 91 90 28 56 49 25 86 49 55 16 19 1 18 8 88 47 16 18 73 86 2 96 16 91 74 49 38 98 94 25 34 85 29 27 99 31 31 58", "output": "97" }, { "input": "100 9\n36 4 45 16 19 6 10 87 44 82 71 49 70 35 83 19 40 76 45 94 44 96 10 54 82 77 86 63 11 37 21 3 15 89 80 88 89 16 72 23 25 9 51 25 10 45 96 5 6 18 51 31 42 57 41 51 42 15 89 61 45 82 16 48 61 67 19 40 9 33 90 36 78 36 79 79 16 10 83 87 9 22 84 12 23 76 36 14 2 81 56 33 56 23 57 84 76 55 35 88", "output": "47" }, { "input": "100 10\n75 81 39 64 90 58 92 28 75 9 96 78 92 83 77 68 76 71 14 46 58 60 80 25 78 11 13 63 22 82 65 68 47 6 33 63 90 50 85 43 73 94 80 48 67 11 83 17 22 15 94 80 66 99 66 4 46 35 52 1 62 39 96 57 37 47 97 49 64 12 36 63 90 16 4 75 85 82 85 56 13 4 92 45 44 93 17 35 22 46 18 44 29 7 52 4 100 98 87 51", "output": "98" }, { "input": "100 20\n21 19 61 70 54 97 98 14 61 72 25 94 24 56 55 25 12 80 76 11 35 17 80 26 11 94 52 47 84 61 10 2 74 25 10 21 2 79 55 50 30 75 10 64 44 5 60 96 52 16 74 41 20 77 20 44 8 86 74 36 49 61 99 13 54 64 19 99 50 43 12 73 48 48 83 55 72 73 63 81 30 27 95 9 97 82 24 3 89 90 33 14 47 88 22 78 12 75 58 67", "output": "94" }, { "input": "100 30\n56 79 59 23 11 23 67 82 81 80 99 79 8 58 93 36 98 81 46 39 34 67 3 50 4 68 70 71 2 21 52 30 75 23 33 21 16 100 56 43 8 27 40 8 56 24 17 40 94 10 67 49 61 36 95 87 17 41 7 94 33 19 17 50 26 11 94 54 38 46 77 9 53 35 98 42 50 20 43 6 78 6 38 24 100 45 43 16 1 50 16 46 14 91 95 88 10 1 50 19", "output": "95" }, { "input": "100 40\n86 11 97 17 38 95 11 5 13 83 67 75 50 2 46 39 84 68 22 85 70 23 64 46 59 93 39 80 35 78 93 21 83 19 64 1 49 59 99 83 44 81 70 58 15 82 83 47 55 65 91 10 2 92 4 77 37 32 12 57 78 11 42 8 59 21 96 69 61 30 44 29 12 70 91 14 10 83 11 75 14 10 19 39 8 98 5 81 66 66 79 55 36 29 22 45 19 24 55 49", "output": "88" }, { "input": "100 50\n22 39 95 69 94 53 80 73 33 90 40 60 2 4 84 50 70 38 92 12 36 74 87 70 51 36 57 5 54 6 35 81 52 17 55 100 95 81 32 76 21 1 100 1 95 1 40 91 98 59 84 19 11 51 79 19 47 86 45 15 62 2 59 77 31 68 71 92 17 33 10 33 85 57 5 2 88 97 91 99 63 20 63 54 79 93 24 62 46 27 30 87 3 64 95 88 16 50 79 1", "output": "99" }, { "input": "100 70\n61 48 89 17 97 6 93 13 64 50 66 88 24 52 46 99 6 65 93 64 82 37 57 41 47 1 84 5 97 83 79 46 16 35 40 7 64 15 44 96 37 17 30 92 51 67 26 3 14 56 27 68 66 93 36 39 51 6 40 55 79 26 71 54 8 48 18 2 71 12 55 60 29 37 31 97 26 37 25 68 67 70 3 87 100 41 5 82 65 92 24 66 76 48 89 8 40 93 31 95", "output": "100" }, { "input": "100 90\n87 32 30 15 10 52 93 63 84 1 82 41 27 51 75 32 42 94 39 53 70 13 4 22 99 35 44 38 5 23 18 100 61 80 9 12 42 93 9 77 3 7 60 95 66 78 95 42 69 8 1 88 93 66 96 20 76 63 15 36 92 52 2 72 36 57 48 63 29 20 74 88 49 47 81 61 94 74 70 93 47 3 19 52 59 41 5 40 22 3 76 97 91 37 95 88 91 99 76 15", "output": "98" }, { "input": "100 100\n79 75 7 28 6 96 38 35 57 95 41 74 24 96 32 78 81 13 63 84 24 95 3 23 66 1 60 6 96 49 41 5 14 18 31 97 66 19 49 89 49 70 51 28 20 99 18 1 28 77 24 46 69 21 40 32 31 66 28 6 66 97 9 16 70 90 91 30 34 82 93 41 65 11 39 52 1 88 63 43 80 50 60 49 28 56 18 76 24 57 74 1 28 99 36 35 79 54 18 16", "output": "100" }, { "input": "1 3\n5", "output": "1" }, { "input": "1 1\n100", "output": "1" }, { "input": "2 3\n4 2", "output": "1" }, { "input": "2 5\n99 97", "output": "2" }, { "input": "3 4\n7 5 2", "output": "2" }, { "input": "3 50\n47 86 51", "output": "3" }, { "input": "5 100\n82 100 85 1 37", "output": "5" }, { "input": "5 20\n40 39 21 5 20", "output": "3" }, { "input": "1 27\n81", "output": "1" }, { "input": "20 13\n7 8 29 83 74 28 93 85 7 8 3 9 8 70 49 50 39 41 57 1", "output": "7" }, { "input": "2 1\n100 2", "output": "1" }, { "input": "2 2\n6 4", "output": "1" }, { "input": "5 2\n6 4 4 1 1", "output": "1" }, { "input": "1 4\n3", "output": "1" }, { "input": "3 2\n1 5 3", "output": "2" }, { "input": "3 1\n3 2 2", "output": "1" }, { "input": "3 1\n2 3 2", "output": "2" }, { "input": "5 1\n5 1 1 1 1", "output": "1" }, { "input": "2 3\n7 4", "output": "1" } ]

1,640,417,999

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

46

0

n, m = map(int, input().split()) a = list(map(int, input().split())) maxi = max(a) if maxi <= m: print(len(a)) else: val = -1 for i in range(len(a)): if val < a[i]: val = i + 1 print(val)

Title: Jzzhu and Children Time Limit: None seconds Memory Limit: None megabytes Problem Description: There are *n* children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to *n*. The *i*-th child wants to get at least *a**i* candies. Jzzhu asks children to line up. Initially, the *i*-th child stands at the *i*-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm: 1. Give *m* candies to the first child of the line. 1. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home. 1. Repeat the first two steps while the line is not empty. Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order? Input Specification: The first line contains two integers *n*,<=*m* (1<=≤<=*n*<=≤<=100; 1<=≤<=*m*<=≤<=100). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100). Output Specification: Output a single integer, representing the number of the last child. Demo Input: ['5 2\n1 3 1 4 2\n', '6 4\n1 1 2 2 3 3\n'] Demo Output: ['4\n', '6\n'] Note: Let's consider the first sample. Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home. Child 4 is the last one who goes home.

```python n, m = map(int, input().split()) a = list(map(int, input().split())) maxi = max(a) if maxi <= m: print(len(a)) else: val = -1 for i in range(len(a)): if val < a[i]: val = i + 1 print(val) ```

0

520

A

Pangram

PROGRAMMING

800

[ "implementation", "strings" ]

null

A word or a sentence in some language is called a pangram if all the characters of the alphabet of this language appear in it at least once. Pangrams are often used to demonstrate fonts in printing or test the output devices. You are given a string consisting of lowercase and uppercase Latin letters. Check whether this string is a pangram. We say that the string contains a letter of the Latin alphabet if this letter occurs in the string in uppercase or lowercase.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of characters in the string. The second line contains the string. The string consists only of uppercase and lowercase Latin letters.

Output "YES", if the string is a pangram and "NO" otherwise.

[ "12\ntoosmallword\n", "35\nTheQuickBrownFoxJumpsOverTheLazyDog\n" ]

[ "NO\n", "YES\n" ]

none

500

[ { "input": "12\ntoosmallword", "output": "NO" }, { "input": "35\nTheQuickBrownFoxJumpsOverTheLazyDog", "output": "YES" }, { "input": "1\na", "output": "NO" }, { "input": "26\nqwertyuiopasdfghjklzxcvbnm", "output": "YES" }, { "input": "26\nABCDEFGHIJKLMNOPQRSTUVWXYZ", "output": "YES" }, { "input": "48\nthereisasyetinsufficientdataforameaningfulanswer", "output": "NO" }, { "input": "30\nToBeOrNotToBeThatIsTheQuestion", "output": "NO" }, { "input": "30\njackdawslovemybigsphinxofquarz", "output": "NO" }, { "input": "31\nTHEFIVEBOXINGWIZARDSJUMPQUICKLY", "output": "YES" }, { "input": "26\naaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "NO" }, { "input": "26\nMGJYIZDKsbhpVeNFlquRTcWoAx", "output": "YES" }, { "input": "26\nfWMOhAPsbIVtyUEZrGNQXDklCJ", "output": "YES" }, { "input": "26\nngPMVFSThiRCwLEuyOAbKxQzDJ", "output": "YES" }, { "input": "25\nnxYTzLFwzNolAumjgcAboyxAj", "output": "NO" }, { "input": "26\npRWdodGdxUESvcScPGbUoooZsC", "output": "NO" }, { "input": "66\nBovdMlDzTaqKllZILFVfxbLGsRnzmtVVTmqiIDTYrossLEPlmsPrkUYtWEsGHVOnFj", "output": "NO" }, { "input": "100\nmKtsiDRJypUieHIkvJaMFkwaKxcCIbBszZQLIyPpCDCjhNpAnYFngLjRpnKWpKWtGnwoSteeZXuFHWQxxxOpFlNeYTwKocsXuCoa", "output": "YES" }, { "input": "26\nEoqxUbsLjPytUHMiFnvcGWZdRK", "output": "NO" }, { "input": "26\nvCUFRKElZOnjmXGylWQaHDiPst", "output": "NO" }, { "input": "26\nWtrPuaHdXLKJMsnvQfgOiJZBEY", "output": "NO" }, { "input": "26\npGiFluRteQwkaVoPszJyNBChxM", "output": "NO" }, { "input": "26\ncTUpqjPmANrdbzSFhlWIoKxgVY", "output": "NO" }, { "input": "26\nLndjgvAEuICHKxPwqYztosrmBN", "output": "NO" }, { "input": "26\nMdaXJrCipnOZLykfqHWEStevbU", "output": "NO" }, { "input": "26\nEjDWsVxfKTqGXRnUMOLYcIzPba", "output": "NO" }, { "input": "26\nxKwzRMpunYaqsdfaBgJcVElTHo", "output": "NO" }, { "input": "26\nnRYUQsTwCPLZkgshfEXvBdoiMa", "output": "NO" }, { "input": "26\nHNCQPfJutyAlDGsvRxZWMEbIdO", "output": "NO" }, { "input": "26\nDaHJIpvKznQcmUyWsTGObXRFDe", "output": "NO" }, { "input": "26\nkqvAnFAiRhzlJbtyuWedXSPcOG", "output": "NO" }, { "input": "26\nhlrvgdwsIOyjcmUZXtAKEqoBpF", "output": "NO" }, { "input": "26\njLfXXiMhBTcAwQVReGnpKzdsYu", "output": "NO" }, { "input": "26\nlNMcVuwItjxRBGAekjhyDsQOzf", "output": "NO" }, { "input": "26\nRkSwbNoYldUGtAZvpFMcxhIJFE", "output": "NO" }, { "input": "26\nDqspXZJTuONYieKgaHLMBwfVSC", "output": "NO" }, { "input": "26\necOyUkqNljFHRVXtIpWabGMLDz", "output": "NO" }, { "input": "26\nEKAvqZhBnPmVCDRlgWJfOusxYI", "output": "NO" }, { "input": "26\naLbgqeYchKdMrsZxIPFvTOWNjA", "output": "NO" }, { "input": "26\nxfpBLsndiqtacOCHGmeWUjRkYz", "output": "NO" }, { "input": "26\nXsbRKtqleZPNIVCdfUhyagAomJ", "output": "NO" }, { "input": "26\nAmVtbrwquEthZcjKPLiyDgSoNF", "output": "NO" }, { "input": "26\nOhvXDcwqAUmSEPRZGnjFLiKtNB", "output": "NO" }, { "input": "26\nEKWJqCFLRmstxVBdYuinpbhaOg", "output": "NO" }, { "input": "26\nmnbvcxxlkjhgfdsapoiuytrewq", "output": "NO" }, { "input": "26\naAbcdefghijklmnopqrstuvwxy", "output": "NO" }, { "input": "30\nABCDEFGHTYRIOPLabcdefghtyriopl", "output": "NO" }, { "input": "25\nabcdefghijklmnopqrstuvwxy", "output": "NO" }, { "input": "26\nabcdefhijklmnopqrstVxyzABC", "output": "NO" }, { "input": "25\nqwertyuiopasdfghjklxcvbnm", "output": "NO" }, { "input": "34\nTheQuickBrownFoxJumpsOverTheLayDog", "output": "NO" }, { "input": "26\nabcdefghigklmnopqrstuvwxyz", "output": "NO" }, { "input": "26\nabcdefghijklmnopqrstuvwxyA", "output": "NO" }, { "input": "50\nqazwsxedcrfvtgbyhnujmikolQWERTYUIOASDFGHJKLZXCVBNM", "output": "NO" }, { "input": "35\nTheQuickBrownFoxJumpsOverTheLasyDog", "output": "NO" }, { "input": "25\nbcdefghijklmnopqrstuvwxyz", "output": "NO" }, { "input": "38\nAbCdEfGhIjKlMnOpQrStVwXyZzzzzzzaaaaaaa", "output": "NO" }, { "input": "26\nabcdefghiklmnopqrstvxyzABC", "output": "NO" }, { "input": "26\nabcdefghijklmnopqrstuvwxzZ", "output": "NO" }, { "input": "50\nabcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY", "output": "NO" } ]

1,699,820,918

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

31

0

n = int(input()) chara = input() if n<26: print("NO") else: for char in chara: if not((65 <= ord(char) <= 90) or (97 <= ord(char) <= 122)): print("NO") break print("YES")

Title: Pangram Time Limit: None seconds Memory Limit: None megabytes Problem Description: A word or a sentence in some language is called a pangram if all the characters of the alphabet of this language appear in it at least once. Pangrams are often used to demonstrate fonts in printing or test the output devices. You are given a string consisting of lowercase and uppercase Latin letters. Check whether this string is a pangram. We say that the string contains a letter of the Latin alphabet if this letter occurs in the string in uppercase or lowercase. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of characters in the string. The second line contains the string. The string consists only of uppercase and lowercase Latin letters. Output Specification: Output "YES", if the string is a pangram and "NO" otherwise. Demo Input: ['12\ntoosmallword\n', '35\nTheQuickBrownFoxJumpsOverTheLazyDog\n'] Demo Output: ['NO\n', 'YES\n'] Note: none

```python n = int(input()) chara = input() if n<26: print("NO") else: for char in chara: if not((65 <= ord(char) <= 90) or (97 <= ord(char) <= 122)): print("NO") break print("YES") ```

0

385

A

Bear and Raspberry

PROGRAMMING

1,000

[ "brute force", "greedy", "implementation" ]

null

The bear decided to store some raspberry for the winter. He cunningly found out the price for a barrel of honey in kilos of raspberry for each of the following *n* days. According to the bear's data, on the *i*-th (1<=≤<=*i*<=≤<=*n*) day, the price for one barrel of honey is going to is *x**i* kilos of raspberry. Unfortunately, the bear has neither a honey barrel, nor the raspberry. At the same time, the bear's got a friend who is ready to lend him a barrel of honey for exactly one day for *c* kilograms of raspberry. That's why the bear came up with a smart plan. He wants to choose some day *d* (1<=≤<=*d*<=<<=*n*), lent a barrel of honey and immediately (on day *d*) sell it according to a daily exchange rate. The next day (*d*<=+<=1) the bear wants to buy a new barrel of honey according to a daily exchange rate (as he's got some raspberry left from selling the previous barrel) and immediately (on day *d*<=+<=1) give his friend the borrowed barrel of honey as well as *c* kilograms of raspberry for renting the barrel. The bear wants to execute his plan at most once and then hibernate. What maximum number of kilograms of raspberry can he earn? Note that if at some point of the plan the bear runs out of the raspberry, then he won't execute such a plan.

The first line contains two space-separated integers, *n* and *c* (2<=≤<=*n*<=≤<=100,<=0<=≤<=*c*<=≤<=100), — the number of days and the number of kilos of raspberry that the bear should give for borrowing the barrel. The second line contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=≤<=100), the price of a honey barrel on day *i*.

Print a single integer — the answer to the problem.

[ "5 1\n5 10 7 3 20\n", "6 2\n100 1 10 40 10 40\n", "3 0\n1 2 3\n" ]

[ "3\n", "97\n", "0\n" ]

In the first sample the bear will lend a honey barrel at day 3 and then sell it for 7. Then the bear will buy a barrel for 3 and return it to the friend. So, the profit is (7 - 3 - 1) = 3. In the second sample bear will lend a honey barrel at day 1 and then sell it for 100. Then the bear buy the barrel for 1 at the day 2. So, the profit is (100 - 1 - 2) = 97.

500

[ { "input": "5 1\n5 10 7 3 20", "output": "3" }, { "input": "6 2\n100 1 10 40 10 40", "output": "97" }, { "input": "3 0\n1 2 3", "output": "0" }, { "input": "2 0\n2 1", "output": "1" }, { "input": "10 5\n10 1 11 2 12 3 13 4 14 5", "output": "4" }, { "input": "100 4\n2 57 70 8 44 10 88 67 50 44 93 79 72 50 69 19 21 9 71 47 95 13 46 10 68 72 54 40 15 83 57 92 58 25 4 22 84 9 8 55 87 0 16 46 86 58 5 21 32 28 10 46 11 29 13 33 37 34 78 33 33 21 46 70 77 51 45 97 6 21 68 61 87 54 8 91 37 12 76 61 57 9 100 45 44 88 5 71 98 98 26 45 37 87 34 50 33 60 64 77", "output": "87" }, { "input": "100 5\n15 91 86 53 18 52 26 89 8 4 5 100 11 64 88 91 35 57 67 72 71 71 69 73 97 23 11 1 59 86 37 82 6 67 71 11 7 31 11 68 21 43 89 54 27 10 3 33 8 57 79 26 90 81 6 28 24 7 33 50 24 13 27 85 4 93 14 62 37 67 33 40 7 48 41 4 14 9 95 10 64 62 7 93 23 6 28 27 97 64 26 83 70 0 97 74 11 82 70 93", "output": "84" }, { "input": "6 100\n10 9 8 7 6 5", "output": "0" }, { "input": "100 9\n66 71 37 41 23 38 77 11 74 13 51 26 93 56 81 17 12 70 85 37 54 100 14 99 12 83 44 16 99 65 13 48 92 32 69 33 100 57 58 88 25 45 44 85 5 41 82 15 37 18 21 45 3 68 33 9 52 64 8 73 32 41 87 99 26 26 47 24 79 93 9 44 11 34 85 26 14 61 49 38 25 65 49 81 29 82 28 23 2 64 38 13 77 68 67 23 58 57 83 46", "output": "78" }, { "input": "100 100\n9 72 46 37 26 94 80 1 43 85 26 53 58 18 24 19 67 2 100 52 61 81 48 15 73 41 97 93 45 1 73 54 75 51 28 79 0 14 41 42 24 50 70 18 96 100 67 1 68 48 44 39 63 77 78 18 10 51 32 53 26 60 1 13 66 39 55 27 23 71 75 0 27 88 73 31 16 95 87 84 86 71 37 40 66 70 65 83 19 4 81 99 26 51 67 63 80 54 23 44", "output": "0" }, { "input": "43 65\n32 58 59 75 85 18 57 100 69 0 36 38 79 95 82 47 7 55 28 88 27 88 63 71 80 86 67 53 69 37 99 54 81 19 55 12 2 17 84 77 25 26 62", "output": "4" }, { "input": "12 64\n14 87 40 24 32 36 4 41 38 77 68 71", "output": "0" }, { "input": "75 94\n80 92 25 48 78 17 69 52 79 73 12 15 59 55 25 61 96 27 98 43 30 43 36 94 67 54 86 99 100 61 65 8 65 19 18 21 75 31 2 98 55 87 14 1 17 97 94 11 57 29 34 71 76 67 45 0 78 29 86 82 29 23 77 100 48 43 65 62 88 34 7 28 13 1 1", "output": "0" }, { "input": "59 27\n76 61 24 66 48 18 69 84 21 8 64 90 19 71 36 90 9 36 30 37 99 37 100 56 9 79 55 37 54 63 11 11 49 71 91 70 14 100 10 44 52 23 21 19 96 13 93 66 52 79 76 5 62 6 90 35 94 7 27", "output": "63" }, { "input": "86 54\n41 84 16 5 20 79 73 13 23 24 42 73 70 80 69 71 33 44 62 29 86 88 40 64 61 55 58 19 16 23 84 100 38 91 89 98 47 50 55 87 12 94 2 12 0 1 4 26 50 96 68 34 94 80 8 22 60 3 72 84 65 89 44 52 50 9 24 34 81 28 56 17 38 85 78 90 62 60 1 40 91 2 7 41 84 22", "output": "38" }, { "input": "37 2\n65 36 92 92 92 76 63 56 15 95 75 26 15 4 73 50 41 92 26 20 19 100 63 55 25 75 61 96 35 0 14 6 96 3 28 41 83", "output": "91" }, { "input": "19 4\n85 2 56 70 33 75 89 60 100 81 42 28 18 92 29 96 49 23 14", "output": "79" }, { "input": "89 1\n50 53 97 41 68 27 53 66 93 19 11 78 46 49 38 69 96 9 43 16 1 63 95 64 96 6 34 34 45 40 19 4 53 8 11 18 95 25 50 16 64 33 97 49 23 81 63 10 30 73 76 55 7 70 9 98 6 36 75 78 3 92 85 75 40 75 55 71 9 91 15 17 47 55 44 35 55 88 53 87 61 22 100 56 14 87 36 84 24", "output": "91" }, { "input": "67 0\n40 48 15 46 90 7 65 52 24 15 42 81 2 6 71 94 32 18 97 67 83 98 48 51 10 47 8 68 36 46 65 75 90 30 62 9 5 35 80 60 69 58 62 68 58 73 80 9 22 46 56 64 44 11 93 73 62 54 15 20 17 69 16 33 85 62 49", "output": "83" }, { "input": "96 0\n38 97 82 43 80 40 1 99 50 94 81 63 92 13 57 24 4 10 25 32 79 56 96 19 25 14 69 56 66 22 23 78 87 76 37 30 75 77 61 64 35 64 62 32 44 62 6 84 91 44 99 5 71 19 17 12 35 52 1 14 35 18 8 36 54 42 4 67 80 11 88 44 34 35 12 38 66 42 4 90 45 10 1 44 37 96 23 28 100 90 75 17 27 67 51 70", "output": "94" }, { "input": "14 14\n87 63 62 31 59 47 40 89 92 43 80 30 99 42", "output": "43" }, { "input": "12 0\n100 1 100 2 100 3 100 4 100 5 100 0", "output": "100" }, { "input": "3 1\n1 2 3", "output": "0" }, { "input": "3 2\n3 3 3", "output": "0" }, { "input": "3 3\n3 2 1", "output": "0" }, { "input": "3 100\n1 2 3", "output": "0" }, { "input": "2 100\n0 0", "output": "0" }, { "input": "2 90\n10 5", "output": "0" }, { "input": "2 5\n5 4", "output": "0" }, { "input": "3 1\n19 20 1", "output": "18" }, { "input": "5 1\n5 10 7 4 20", "output": "2" }, { "input": "5 1\n1 2 3 4 5", "output": "0" } ]

1,635,948,975

2,147,483,647

Python 3

OK

TESTS

32

46

4,505,600

n,c=map(int, input().split()) x=list(map(int, input().split())) ans=0 for i in range(n-1): if x[i]-x[i+1]>ans: ans = x[i]-x[i+1] ans-=c if ans<=0: print(0) else: print(ans)

Title: Bear and Raspberry Time Limit: None seconds Memory Limit: None megabytes Problem Description: The bear decided to store some raspberry for the winter. He cunningly found out the price for a barrel of honey in kilos of raspberry for each of the following *n* days. According to the bear's data, on the *i*-th (1<=≤<=*i*<=≤<=*n*) day, the price for one barrel of honey is going to is *x**i* kilos of raspberry. Unfortunately, the bear has neither a honey barrel, nor the raspberry. At the same time, the bear's got a friend who is ready to lend him a barrel of honey for exactly one day for *c* kilograms of raspberry. That's why the bear came up with a smart plan. He wants to choose some day *d* (1<=≤<=*d*<=<<=*n*), lent a barrel of honey and immediately (on day *d*) sell it according to a daily exchange rate. The next day (*d*<=+<=1) the bear wants to buy a new barrel of honey according to a daily exchange rate (as he's got some raspberry left from selling the previous barrel) and immediately (on day *d*<=+<=1) give his friend the borrowed barrel of honey as well as *c* kilograms of raspberry for renting the barrel. The bear wants to execute his plan at most once and then hibernate. What maximum number of kilograms of raspberry can he earn? Note that if at some point of the plan the bear runs out of the raspberry, then he won't execute such a plan. Input Specification: The first line contains two space-separated integers, *n* and *c* (2<=≤<=*n*<=≤<=100,<=0<=≤<=*c*<=≤<=100), — the number of days and the number of kilos of raspberry that the bear should give for borrowing the barrel. The second line contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=≤<=100), the price of a honey barrel on day *i*. Output Specification: Print a single integer — the answer to the problem. Demo Input: ['5 1\n5 10 7 3 20\n', '6 2\n100 1 10 40 10 40\n', '3 0\n1 2 3\n'] Demo Output: ['3\n', '97\n', '0\n'] Note: In the first sample the bear will lend a honey barrel at day 3 and then sell it for 7. Then the bear will buy a barrel for 3 and return it to the friend. So, the profit is (7 - 3 - 1) = 3. In the second sample bear will lend a honey barrel at day 1 and then sell it for 100. Then the bear buy the barrel for 1 at the day 2. So, the profit is (100 - 1 - 2) = 97.

```python n,c=map(int, input().split()) x=list(map(int, input().split())) ans=0 for i in range(n-1): if x[i]-x[i+1]>ans: ans = x[i]-x[i+1] ans-=c if ans<=0: print(0) else: print(ans) ```

3

16

D

Logging

PROGRAMMING

1,900

[ "implementation", "strings" ]

D. Logging

1

64

The main server of Gomble company received a log of one top-secret process, the name of which can't be revealed. The log was written in the following format: «[date:time]: message», where for each «[date:time]» value existed not more than 10 lines. All the files were encoded in a very complicated manner, and only one programmer — Alex — managed to decode them. The code was so complicated that Alex needed four weeks to decode it. Right after the decoding process was finished, all the files were deleted. But after the files deletion, Alex noticed that he saved the recordings in format «[time]: message». So, information about the dates was lost. However, as the lines were added into the log in chronological order, it's not difficult to say if the recordings could appear during one day or not. It is possible also to find the minimum amount of days during which the log was written. So, to make up for his mistake Alex has to find the minimum amount of days covered by the log. Note that Alex doesn't have to find the minimum amount of days between the beginning and the end of the logging, he has to find the minimum amount of dates in which records could be done. (See Sample test 2 for further clarifications). We should remind you that the process made not more than 10 recordings in a minute. Consider that a midnight belongs to coming day.

The first input line contains number *n* (1<=≤<=*n*<=≤<=100). The following *n* lines contain recordings in format «[time]: message», where time is given in format «hh:mm x.m.». For hh two-digit numbers from 01 to 12 are used, for mm two-digit numbers from 00 to 59 are used, and x is either character «a» or character «p». A message is a non-empty sequence of Latin letters and/or spaces, it doesn't start or end with a space. The length of each message doesn't exceed 20.

Output one number — the minimum amount of days covered by the log.

[ "5\n[05:00 a.m.]: Server is started\n[05:00 a.m.]: Rescan initialized\n[01:13 p.m.]: Request processed\n[01:10 p.m.]: Request processed\n[11:40 p.m.]: Rescan completed\n", "3\n[09:00 a.m.]: User logged in\n[08:00 a.m.]: User logged in\n[07:00 a.m.]: User logged in\n" ]

[ "2\n", "3\n" ]

Formally the 12-hour time format is described at: - http://en.wikipedia.org/wiki/12-hour_clock.

0

[ { "input": "5\n[05:00 a.m.]: Server is started\n[05:00 a.m.]: Rescan initialized\n[01:13 p.m.]: Request processed\n[01:10 p.m.]: Request processed\n[11:40 p.m.]: Rescan completed", "output": "2" }, { "input": "3\n[09:00 a.m.]: User logged in\n[08:00 a.m.]: User logged in\n[07:00 a.m.]: User logged in", "output": "3" }, { "input": "1\n[10:41 a.m.]: apppmama", "output": "1" }, { "input": "2\n[06:00 p.m.]: uNzO VN Nz h\n[06:00 a.m.]: bTJv", "output": "2" }, { "input": "2\n[06:00 p.m.]: uNzO VN Nz h\n[06:00 a.m.]: bTJv", "output": "2" }, { "input": "2\n[11:35 a.m.]: ampapaammaamamaam\n[11:35 a.m.]: ppammpmmppmam", "output": "1" }, { "input": "3\n[01:58 p.m.]: pamapmppmmampaaama\n[01:58 p.m.]: pamapmammapaam\n[01:58 p.m.]: paap", "output": "1" }, { "input": "3\n[05:33 p.m.]: apm\n[05:24 p.m.]: mapammmapaaa\n[06:01 p.m.]: mpmmmpa", "output": "2" }, { "input": "1\n[12:00 a.m.]: asZv MF", "output": "1" }, { "input": "3\n[09:00 p.m.]: Y UnDuXrgurr J\n[09:00 p.m.]: Fn FAGSAcNQ\n[03:00 p.m.]: YpwvM", "output": "2" }, { "input": "4\n[05:42 a.m.]: aaaamampmp\n[06:18 a.m.]: pamapammpp\n[06:08 p.m.]: apa\n[11:05 p.m.]: mapmamappmmmpmm", "output": "1" }, { "input": "4\n[11:15 p.m.]: apmammaampmaap\n[11:18 p.m.]: maaaaappmmma\n[11:13 p.m.]: pmpaamppmmpamaa\n[11:17 p.m.]: ppm", "output": "2" }, { "input": "4\n[08:49 a.m.]: pmampaamappapmap\n[08:49 a.m.]: mampama\n[08:10 p.m.]: pamaaampppaa\n[08:10 p.m.]: mmppmmapmmpaa", "output": "1" }, { "input": "4\n[07:23 p.m.]: y vTNVMa VWxb rpE\n[12:00 a.m.]: wkr EcZc\n[05:16 a.m.]: nWf lypg NT\n[04:22 a.m.]: UQIXmL", "output": "3" }, { "input": "5\n[10:25 p.m.]: pmpapm\n[10:34 p.m.]: pappaaa\n[04:36 a.m.]: mmaammpmpmpppaamammm\n[05:53 p.m.]: mmmmpmmapaapap\n[04:07 p.m.]: mmmmp", "output": "3" }, { "input": "5\n[04:39 p.m.]: pmmmpapaampap\n[04:39 p.m.]: aappmaaamampapaam\n[04:39 p.m.]: ma\n[05:02 p.m.]: ppaa\n[08:06 p.m.]: maaammmmpmpmp", "output": "1" }, { "input": "5\n[11:49 a.m.]: maapapm\n[10:05 a.m.]: apampmmapapa\n[08:48 a.m.]: pampmapmaaappmpa\n[11:15 a.m.]: pmmamppmmapmmpmm\n[08:01 a.m.]: mmammppmapppmpapma", "output": "4" }, { "input": "5\n[12:00 a.m.]: sZvvEvtky\n[12:00 a.m.]: rCmNMmEDY\n[12:00 a.m.]: tX R mPCwu\n[12:00 a.m.]: VEDt LZNguynilskN SK\n[12:00 a.m.]: jPFLOr rBoyyBvGerKK", "output": "1" }, { "input": "5\n[07:47 a.m.]: mam\n[06:54 a.m.]: pp\n[05:38 a.m.]: mppmm\n[05:07 a.m.]: papmaamppmamppp\n[04:09 p.m.]: pppmpammpmpap", "output": "4" }, { "input": "5\n[09:22 a.m.]: xYv\n[12:00 a.m.]: wEMdbcKw jspxiF\n[07:57 a.m.]: zNp PU\n[03:06 a.m.]: IaH c eGuRQ\n[07:46 a.m.]: io r jjhyEP", "output": "3" }, { "input": "14\n[03:08 p.m.]: aaamm\n[01:49 a.m.]: a\n[04:55 p.m.]: ammma\n[06:00 a.m.]: mamppmapaa\n[04:01 a.m.]: amammmaa\n[01:24 p.m.]: papmmmpamaapaaampmaa\n[05:40 a.m.]: amaaamamammmaa\n[03:50 p.m.]: apmp\n[07:37 p.m.]: mmpappm\n[02:48 a.m.]: aammpampmmmappapam\n[05:05 a.m.]: mppmppaam\n[04:00 a.m.]: mamammpaaaamamapampa\n[05:11 a.m.]: mmpmmppmaapp\n[01:07 p.m.]: aappm", "output": "7" }, { "input": "14\n[12:07 p.m.]: mamaa\n[12:36 a.m.]: amaamppa\n[01:31 a.m.]: pmpp\n[05:47 a.m.]: paapappapaaampm\n[12:07 a.m.]: ppamammm\n[01:03 a.m.]: aapapmpampamamaaa\n[07:55 a.m.]: mpappmmapmpa\n[02:49 a.m.]: papmppppmpamppa\n[03:12 a.m.]: aaaaaaamam\n[04:40 a.m.]: paap\n[01:13 a.m.]: ap\n[03:22 a.m.]: mpmppmmapmmpp\n[01:27 a.m.]: maaamaapmaaaamamam\n[12:49 a.m.]: pppmappmammpmamampp", "output": "7" }, { "input": "14\n[09:37 p.m.]: pamammapampmapaa\n[09:37 p.m.]: ppmm\n[09:37 p.m.]: aapapppaampmappppppm\n[09:37 p.m.]: pmppmpmmpm\n[09:37 p.m.]: mmppppamamaa\n[09:37 p.m.]: mm\n[09:37 p.m.]: apamppmaaapaa\n[09:37 p.m.]: pmaammpaa\n[09:37 p.m.]: m\n[09:37 p.m.]: pppmppa\n[09:37 p.m.]: ppmpmm\n[09:37 p.m.]: mpamappmpmpamaampmpm\n[05:10 a.m.]: a\n[05:10 a.m.]: aaapamppaaamppapa", "output": "3" }, { "input": "14\n[10:19 a.m.]: iC ySL\n[06:44 a.m.]: F yD\n[06:44 a.m.]: i ZtfBlWwC\n[06:44 a.m.]: K F f t Feq\n[06:44 a.m.]: Vt vJj cRkqG mN\n[06:44 a.m.]: Ca\n[06:44 a.m.]: cC\n[06:44 a.m.]: aqIM FQIahCaVxdwCEG\n[04:13 a.m.]: WKeux icvt\n[12:44 a.m.]: mC\n[02:46 p.m.]: qEM kbX q\n[10:36 p.m.]: WFym ja W s ab\n[03:07 p.m.]: xMV hC u\n[12:40 p.m.]: U", "output": "6" } ]

1,597,592,040

2,147,483,647

Python 3

OK

TESTS

54

109

307,200

n=int(input()) pr,cnt=0,1 E=0 for i in range(n): s=input().split() a,b=int(s[0][1:3]),int(s[0][4:6]) e='p' in s[1] a%=12 t=60*a+b+12*60*e if(t==pr): E+=1 if(E>10): cnt+=1 E=1 else: E=1 if(t<pr): cnt+=1 pr=t #print(a,b,e,t) print(cnt)

Title: Logging Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: The main server of Gomble company received a log of one top-secret process, the name of which can't be revealed. The log was written in the following format: «[date:time]: message», where for each «[date:time]» value existed not more than 10 lines. All the files were encoded in a very complicated manner, and only one programmer — Alex — managed to decode them. The code was so complicated that Alex needed four weeks to decode it. Right after the decoding process was finished, all the files were deleted. But after the files deletion, Alex noticed that he saved the recordings in format «[time]: message». So, information about the dates was lost. However, as the lines were added into the log in chronological order, it's not difficult to say if the recordings could appear during one day or not. It is possible also to find the minimum amount of days during which the log was written. So, to make up for his mistake Alex has to find the minimum amount of days covered by the log. Note that Alex doesn't have to find the minimum amount of days between the beginning and the end of the logging, he has to find the minimum amount of dates in which records could be done. (See Sample test 2 for further clarifications). We should remind you that the process made not more than 10 recordings in a minute. Consider that a midnight belongs to coming day. Input Specification: The first input line contains number *n* (1<=≤<=*n*<=≤<=100). The following *n* lines contain recordings in format «[time]: message», where time is given in format «hh:mm x.m.». For hh two-digit numbers from 01 to 12 are used, for mm two-digit numbers from 00 to 59 are used, and x is either character «a» or character «p». A message is a non-empty sequence of Latin letters and/or spaces, it doesn't start or end with a space. The length of each message doesn't exceed 20. Output Specification: Output one number — the minimum amount of days covered by the log. Demo Input: ['5\n[05:00 a.m.]: Server is started\n[05:00 a.m.]: Rescan initialized\n[01:13 p.m.]: Request processed\n[01:10 p.m.]: Request processed\n[11:40 p.m.]: Rescan completed\n', '3\n[09:00 a.m.]: User logged in\n[08:00 a.m.]: User logged in\n[07:00 a.m.]: User logged in\n'] Demo Output: ['2\n', '3\n'] Note: Formally the 12-hour time format is described at: - http://en.wikipedia.org/wiki/12-hour_clock.

```python n=int(input()) pr,cnt=0,1 E=0 for i in range(n): s=input().split() a,b=int(s[0][1:3]),int(s[0][4:6]) e='p' in s[1] a%=12 t=60*a+b+12*60*e if(t==pr): E+=1 if(E>10): cnt+=1 E=1 else: E=1 if(t<pr): cnt+=1 pr=t #print(a,b,e,t) print(cnt) ```

3.943211

80

A

Panoramix's Prediction

PROGRAMMING

800

[ "brute force" ]

A. Panoramix's Prediction

2

256

A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not. The next prime number after *x* is the smallest prime number greater than *x*. For example, the next prime number after 2 is 3, and the next prime number after 3 is 5. Note that there is exactly one next prime number after each number. So 5 is not the next prime number for 2. One cold April morning Panoramix predicted that soon Kakofonix will break free from his straitjacket, and this will be a black day for the residents of the Gallic countryside. Panoramix's prophecy tells that if some day Asterix and Obelix beat exactly *x* Roman soldiers, where *x* is a prime number, and next day they beat exactly *y* Roman soldiers, where *y* is the next prime number after *x*, then it's time to wait for Armageddon, for nothing can shut Kakofonix up while he sings his infernal song. Yesterday the Gauls beat *n* Roman soldiers and it turned out that the number *n* was prime! Today their victims were a troop of *m* Romans (*m*<=><=*n*). Determine whether the Gauls should wait for the black day after today's victory of Asterix and Obelix?

The first and only input line contains two positive integers — *n* and *m* (2<=≤<=*n*<=<<=*m*<=≤<=50). It is guaranteed that *n* is prime. Pretests contain all the cases with restrictions 2<=≤<=*n*<=<<=*m*<=≤<=4.

Print YES, if *m* is the next prime number after *n*, or NO otherwise.

[ "3 5\n", "7 11\n", "7 9\n" ]

[ "YES", "YES", "NO" ]

none

500

[ { "input": "3 5", "output": "YES" }, { "input": "7 11", "output": "YES" }, { "input": "7 9", "output": "NO" }, { "input": "2 3", "output": "YES" }, { "input": "2 4", "output": "NO" }, { "input": "3 4", "output": "NO" }, { "input": "3 5", "output": "YES" }, { "input": "5 7", "output": "YES" }, { "input": "7 11", "output": "YES" }, { "input": "11 13", "output": "YES" }, { "input": "13 17", "output": "YES" }, { "input": "17 19", "output": "YES" }, { "input": "19 23", "output": "YES" }, { "input": "23 29", "output": "YES" }, { "input": "29 31", "output": "YES" }, { "input": "31 37", "output": "YES" }, { "input": "37 41", "output": "YES" }, { "input": "41 43", "output": "YES" }, { "input": "43 47", "output": "YES" }, { "input": "2 5", "output": "NO" }, { "input": "2 7", "output": "NO" }, { "input": "2 6", "output": "NO" }, { "input": "2 11", "output": "NO" }, { "input": "3 6", "output": "NO" }, { "input": "3 7", "output": "NO" }, { "input": "3 9", "output": "NO" }, { "input": "5 6", "output": "NO" }, { "input": "5 9", "output": "NO" }, { "input": "5 11", "output": "NO" }, { "input": "5 13", "output": "NO" }, { "input": "5 15", "output": "NO" }, { "input": "7 8", "output": "NO" }, { "input": "7 13", "output": "NO" }, { "input": "13 15", "output": "NO" }, { "input": "13 17", "output": "YES" }, { "input": "19 21", "output": "NO" }, { "input": "13 20", "output": "NO" }, { "input": "41 49", "output": "NO" }, { "input": "43 49", "output": "NO" }, { "input": "47 50", "output": "NO" }, { "input": "47 49", "output": "NO" }, { "input": "47 48", "output": "NO" }, { "input": "23 25", "output": "NO" }, { "input": "2 50", "output": "NO" }, { "input": "31 33", "output": "NO" } ]

1,625,643,355

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

122

0

a, b = list(map(int, input().split())) answer = [2, 3, 5, 7] for i in range(10, 51): for j in range(2, i // 2): if i % j == 0: break else: answer.append(i) temp = answer.index(b) if a + 2 == answer[temp]: print('YES') else: print('NO')

Title: Panoramix's Prediction Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: A prime number is a number which has exactly two distinct divisors: one and itself. For example, numbers 2, 7, 3 are prime, and 1, 6, 4 are not. The next prime number after *x* is the smallest prime number greater than *x*. For example, the next prime number after 2 is 3, and the next prime number after 3 is 5. Note that there is exactly one next prime number after each number. So 5 is not the next prime number for 2. One cold April morning Panoramix predicted that soon Kakofonix will break free from his straitjacket, and this will be a black day for the residents of the Gallic countryside. Panoramix's prophecy tells that if some day Asterix and Obelix beat exactly *x* Roman soldiers, where *x* is a prime number, and next day they beat exactly *y* Roman soldiers, where *y* is the next prime number after *x*, then it's time to wait for Armageddon, for nothing can shut Kakofonix up while he sings his infernal song. Yesterday the Gauls beat *n* Roman soldiers and it turned out that the number *n* was prime! Today their victims were a troop of *m* Romans (*m*<=><=*n*). Determine whether the Gauls should wait for the black day after today's victory of Asterix and Obelix? Input Specification: The first and only input line contains two positive integers — *n* and *m* (2<=≤<=*n*<=<<=*m*<=≤<=50). It is guaranteed that *n* is prime. Pretests contain all the cases with restrictions 2<=≤<=*n*<=<<=*m*<=≤<=4. Output Specification: Print YES, if *m* is the next prime number after *n*, or NO otherwise. Demo Input: ['3 5\n', '7 11\n', '7 9\n'] Demo Output: ['YES', 'YES', 'NO'] Note: none

```python a, b = list(map(int, input().split())) answer = [2, 3, 5, 7] for i in range(10, 51): for j in range(2, i // 2): if i % j == 0: break else: answer.append(i) temp = answer.index(b) if a + 2 == answer[temp]: print('YES') else: print('NO') ```

0

25

A

IQ test

PROGRAMMING

1,300

[ "brute force" ]

A. IQ test

2

256

Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness.

The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness.

Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order.

[ "5\n2 4 7 8 10\n", "4\n1 2 1 1\n" ]

[ "3\n", "2\n" ]

none

0

[ { "input": "5\n2 4 7 8 10", "output": "3" }, { "input": "4\n1 2 1 1", "output": "2" }, { "input": "3\n1 2 2", "output": "1" }, { "input": "3\n100 99 100", "output": "2" }, { "input": "3\n5 3 2", "output": "3" }, { "input": "4\n43 28 1 91", "output": "2" }, { "input": "4\n75 13 94 77", "output": "3" }, { "input": "4\n97 8 27 3", "output": "2" }, { "input": "10\n95 51 12 91 85 3 1 31 25 7", "output": "3" }, { "input": "20\n88 96 66 51 14 88 2 92 18 72 18 88 20 30 4 82 90 100 24 46", "output": "4" }, { "input": "30\n20 94 56 50 10 98 52 32 14 22 24 60 4 8 98 46 34 68 82 82 98 90 50 20 78 49 52 94 64 36", "output": "26" }, { "input": "50\n79 27 77 57 37 45 27 49 65 33 57 21 71 19 75 85 65 61 23 97 85 9 23 1 9 3 99 77 77 21 79 69 15 37 15 7 93 81 13 89 91 31 45 93 15 97 55 80 85 83", "output": "48" }, { "input": "60\n46 11 73 65 3 69 3 53 43 53 97 47 55 93 31 75 35 3 9 73 23 31 3 81 91 79 61 21 15 11 11 11 81 7 83 75 39 87 83 59 89 55 93 27 49 67 67 29 1 93 11 17 9 19 35 21 63 31 31 25", "output": "1" }, { "input": "70\n28 42 42 92 64 54 22 38 38 78 62 38 4 38 14 66 4 92 66 58 94 26 4 44 41 88 48 82 44 26 74 44 48 4 16 92 34 38 26 64 94 4 30 78 50 54 12 90 8 16 80 98 28 100 74 50 36 42 92 18 76 98 8 22 2 50 58 50 64 46", "output": "25" }, { "input": "100\n43 35 79 53 13 91 91 45 65 83 57 9 42 39 85 45 71 51 61 59 31 13 63 39 25 21 79 39 91 67 21 61 97 75 93 83 29 79 59 97 11 37 63 51 39 55 91 23 21 17 47 23 35 75 49 5 69 99 5 7 41 17 25 89 15 79 21 63 53 81 43 91 59 91 69 99 85 15 91 51 49 37 65 7 89 81 21 93 61 63 97 93 45 17 13 69 57 25 75 73", "output": "13" }, { "input": "100\n50 24 68 60 70 30 52 22 18 74 68 98 20 82 4 46 26 68 100 78 84 58 74 98 38 88 68 86 64 80 82 100 20 22 98 98 52 6 94 10 48 68 2 18 38 22 22 82 44 20 66 72 36 58 64 6 36 60 4 96 76 64 12 90 10 58 64 60 74 28 90 26 24 60 40 58 2 16 76 48 58 36 82 60 24 44 4 78 28 38 8 12 40 16 38 6 66 24 31 76", "output": "99" }, { "input": "100\n47 48 94 48 14 18 94 36 96 22 12 30 94 20 48 98 40 58 2 94 8 36 98 18 98 68 2 60 76 38 18 100 8 72 100 68 2 86 92 72 58 16 48 14 6 58 72 76 6 88 80 66 20 28 74 62 86 68 90 86 2 56 34 38 56 90 4 8 76 44 32 86 12 98 38 34 54 92 70 94 10 24 82 66 90 58 62 2 32 58 100 22 58 72 2 22 68 72 42 14", "output": "1" }, { "input": "99\n38 20 68 60 84 16 28 88 60 48 80 28 4 92 70 60 46 46 20 34 12 100 76 2 40 10 8 86 6 80 50 66 12 34 14 28 26 70 46 64 34 96 10 90 98 96 56 88 50 74 70 94 2 94 24 66 68 46 22 30 6 10 64 32 88 14 98 100 64 58 50 18 50 50 8 38 8 16 54 2 60 54 62 84 92 98 4 72 66 26 14 88 99 16 10 6 88 56 22", "output": "93" }, { "input": "99\n50 83 43 89 53 47 69 1 5 37 63 87 95 15 55 95 75 89 33 53 89 75 93 75 11 85 49 29 11 97 49 67 87 11 25 37 97 73 67 49 87 43 53 97 43 29 53 33 45 91 37 73 39 49 59 5 21 43 87 35 5 63 89 57 63 47 29 99 19 85 13 13 3 13 43 19 5 9 61 51 51 57 15 89 13 97 41 13 99 79 13 27 97 95 73 33 99 27 23", "output": "1" }, { "input": "98\n61 56 44 30 58 14 20 24 88 28 46 56 96 52 58 42 94 50 46 30 46 80 72 88 68 16 6 60 26 90 10 98 76 20 56 40 30 16 96 20 88 32 62 30 74 58 36 76 60 4 24 36 42 54 24 92 28 14 2 74 86 90 14 52 34 82 40 76 8 64 2 56 10 8 78 16 70 86 70 42 70 74 22 18 76 98 88 28 62 70 36 72 20 68 34 48 80 98", "output": "1" }, { "input": "98\n66 26 46 42 78 32 76 42 26 82 8 12 4 10 24 26 64 44 100 46 94 64 30 18 88 28 8 66 30 82 82 28 74 52 62 80 80 60 94 86 64 32 44 88 92 20 12 74 94 28 34 58 4 22 16 10 94 76 82 58 40 66 22 6 30 32 92 54 16 76 74 98 18 48 48 30 92 2 16 42 84 74 30 60 64 52 50 26 16 86 58 96 79 60 20 62 82 94", "output": "93" }, { "input": "95\n9 31 27 93 17 77 75 9 9 53 89 39 51 99 5 1 11 39 27 49 91 17 27 79 81 71 37 75 35 13 93 4 99 55 85 11 23 57 5 43 5 61 15 35 23 91 3 81 99 85 43 37 39 27 5 67 7 33 75 59 13 71 51 27 15 93 51 63 91 53 43 99 25 47 17 71 81 15 53 31 59 83 41 23 73 25 91 91 13 17 25 13 55 57 29", "output": "32" }, { "input": "100\n91 89 81 45 53 1 41 3 77 93 55 97 55 97 87 27 69 95 73 41 93 21 75 35 53 56 5 51 87 59 91 67 33 3 99 45 83 17 97 47 75 97 7 89 17 99 23 23 81 25 55 97 27 35 69 5 77 35 93 19 55 59 37 21 31 37 49 41 91 53 73 69 7 37 37 39 17 71 7 97 55 17 47 23 15 73 31 39 57 37 9 5 61 41 65 57 77 79 35 47", "output": "26" }, { "input": "99\n38 56 58 98 80 54 26 90 14 16 78 92 52 74 40 30 84 14 44 80 16 90 98 68 26 24 78 72 42 16 84 40 14 44 2 52 50 2 12 96 58 66 8 80 44 52 34 34 72 98 74 4 66 74 56 21 8 38 76 40 10 22 48 32 98 34 12 62 80 68 64 82 22 78 58 74 20 22 48 56 12 38 32 72 6 16 74 24 94 84 26 38 18 24 76 78 98 94 72", "output": "56" }, { "input": "100\n44 40 6 40 56 90 98 8 36 64 76 86 98 76 36 92 6 30 98 70 24 98 96 60 24 82 88 68 86 96 34 42 58 10 40 26 56 10 88 58 70 32 24 28 14 82 52 12 62 36 70 60 52 34 74 30 78 76 10 16 42 94 66 90 70 38 52 12 58 22 98 96 14 68 24 70 4 30 84 98 8 50 14 52 66 34 100 10 28 100 56 48 38 12 38 14 91 80 70 86", "output": "97" }, { "input": "100\n96 62 64 20 90 46 56 90 68 36 30 56 70 28 16 64 94 34 6 32 34 50 94 22 90 32 40 2 72 10 88 38 28 92 20 26 56 80 4 100 100 90 16 74 74 84 8 2 30 20 80 32 16 46 92 56 42 12 96 64 64 42 64 58 50 42 74 28 2 4 36 32 70 50 54 92 70 16 45 76 28 16 18 50 48 2 62 94 4 12 52 52 4 100 70 60 82 62 98 42", "output": "79" }, { "input": "99\n14 26 34 68 90 58 50 36 8 16 18 6 2 74 54 20 36 84 32 50 52 2 26 24 3 64 20 10 54 26 66 44 28 72 4 96 78 90 96 86 68 28 94 4 12 46 100 32 22 36 84 32 44 94 76 94 4 52 12 30 74 4 34 64 58 72 44 16 70 56 54 8 14 74 8 6 58 62 98 54 14 40 80 20 36 72 28 98 20 58 40 52 90 64 22 48 54 70 52", "output": "25" }, { "input": "95\n82 86 30 78 6 46 80 66 74 72 16 24 18 52 52 38 60 36 86 26 62 28 22 46 96 26 94 84 20 46 66 88 76 32 12 86 74 18 34 88 4 48 94 6 58 6 100 82 4 24 88 32 54 98 34 48 6 76 42 88 42 28 100 4 22 2 10 66 82 54 98 20 60 66 38 98 32 47 86 58 6 100 12 46 2 42 8 84 78 28 24 70 34 28 86", "output": "78" }, { "input": "90\n40 50 8 42 76 24 58 42 26 68 20 48 54 12 34 84 14 36 32 88 6 50 96 56 20 92 48 16 40 34 96 46 20 84 30 50 20 98 8 44 96 42 8 76 70 38 84 30 40 88 84 72 2 22 52 58 16 62 100 66 80 40 50 32 14 62 88 72 22 99 76 50 84 82 8 82 98 46 26 40 2 98 18 78 30 72 70 18 34 68", "output": "70" }, { "input": "80\n81 43 87 1 55 43 53 61 27 19 43 13 89 9 33 83 75 55 97 71 91 37 95 5 21 69 81 93 95 69 31 83 55 7 97 7 79 57 8 61 27 85 49 1 15 97 63 79 29 73 41 85 5 41 31 93 67 11 63 59 15 99 91 77 43 69 23 23 81 73 19 1 67 51 1 75 99 67 3 81", "output": "39" }, { "input": "98\n13 83 61 27 35 1 85 95 97 73 95 65 73 45 5 43 27 83 91 19 11 3 85 59 9 39 69 23 45 7 51 85 5 71 5 95 1 51 75 3 43 57 3 11 33 71 21 99 47 41 87 39 71 87 31 85 91 49 83 5 49 85 47 91 55 99 33 23 31 23 23 73 29 77 55 31 25 5 81 49 91 15 15 39 87 5 9 40 69 47 29 33 11 21 49 79 51 83", "output": "88" }, { "input": "3\n100 100 1", "output": "3" } ]

1,558,261,252

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

#include<bits/stdc++.h> #include<string.h> #define ll long long int #define fio ios_base::sync_with_stdio(false); cin.tie(NULL); #define MAX_LIMIT 100000 #define r return 0 #define f(i,a,n) for(i=a;i<n;++i) using namespace std; int main() { fio ll n,i,arr[MAX_LIMIT],e,o,pos1,pos2; cin>>n; f(i,0,n){ cin>>arr[i]; } i=0; f(i,0,n){ if(arr[i]%2==0){ e++; pos1=i; } else{ o++; pos2=i; } } if(o==1){ cout<<pos2+1<<endl; } else{ cout<<pos1+1<<endl; } assert(0); }

Title: IQ test Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Bob is preparing to pass IQ test. The most frequent task in this test is to find out which one of the given *n* numbers differs from the others. Bob observed that one number usually differs from the others in evenness. Help Bob — to check his answers, he needs a program that among the given *n* numbers finds one that is different in evenness. Input Specification: The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of numbers in the task. The second line contains *n* space-separated natural numbers, not exceeding 100. It is guaranteed, that exactly one of these numbers differs from the others in evenness. Output Specification: Output index of number that differs from the others in evenness. Numbers are numbered from 1 in the input order. Demo Input: ['5\n2 4 7 8 10\n', '4\n1 2 1 1\n'] Demo Output: ['3\n', '2\n'] Note: none

```python #include<bits/stdc++.h> #include<string.h> #define ll long long int #define fio ios_base::sync_with_stdio(false); cin.tie(NULL); #define MAX_LIMIT 100000 #define r return 0 #define f(i,a,n) for(i=a;i<n;++i) using namespace std; int main() { fio ll n,i,arr[MAX_LIMIT],e,o,pos1,pos2; cin>>n; f(i,0,n){ cin>>arr[i]; } i=0; f(i,0,n){ if(arr[i]%2==0){ e++; pos1=i; } else{ o++; pos2=i; } } if(o==1){ cout<<pos2+1<<endl; } else{ cout<<pos1+1<<endl; } assert(0); } ```

-1

136

A

Presents

PROGRAMMING

800

[ "implementation" ]

null

Little Petya very much likes gifts. Recently he has received a new laptop as a New Year gift from his mother. He immediately decided to give it to somebody else as what can be more pleasant than giving somebody gifts. And on this occasion he organized a New Year party at his place and invited *n* his friends there. If there's one thing Petya likes more that receiving gifts, that's watching others giving gifts to somebody else. Thus, he safely hid the laptop until the next New Year and made up his mind to watch his friends exchanging gifts while he does not participate in the process. He numbered all his friends with integers from 1 to *n*. Petya remembered that a friend number *i* gave a gift to a friend number *p**i*. He also remembered that each of his friends received exactly one gift. Now Petya wants to know for each friend *i* the number of a friend who has given him a gift.

The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the quantity of friends Petya invited to the party. The second line contains *n* space-separated integers: the *i*-th number is *p**i* — the number of a friend who gave a gift to friend number *i*. It is guaranteed that each friend received exactly one gift. It is possible that some friends do not share Petya's ideas of giving gifts to somebody else. Those friends gave the gifts to themselves.

Print *n* space-separated integers: the *i*-th number should equal the number of the friend who gave a gift to friend number *i*.

[ "4\n2 3 4 1\n", "3\n1 3 2\n", "2\n1 2\n" ]

[ "4 1 2 3\n", "1 3 2\n", "1 2\n" ]

none

500

[ { "input": "4\n2 3 4 1", "output": "4 1 2 3" }, { "input": "3\n1 3 2", "output": "1 3 2" }, { "input": "2\n1 2", "output": "1 2" }, { "input": "1\n1", "output": "1" }, { "input": "10\n1 3 2 6 4 5 7 9 8 10", "output": "1 3 2 5 6 4 7 9 8 10" }, { "input": "5\n5 4 3 2 1", "output": "5 4 3 2 1" }, { "input": "20\n2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19", "output": "2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19" }, { "input": "21\n3 2 1 6 5 4 9 8 7 12 11 10 15 14 13 18 17 16 21 20 19", "output": "3 2 1 6 5 4 9 8 7 12 11 10 15 14 13 18 17 16 21 20 19" }, { "input": "10\n3 4 5 6 7 8 9 10 1 2", "output": "9 10 1 2 3 4 5 6 7 8" }, { "input": "8\n1 5 3 7 2 6 4 8", "output": "1 5 3 7 2 6 4 8" }, { "input": "50\n49 22 4 2 20 46 7 32 5 19 48 24 26 15 45 21 44 11 50 43 39 17 31 1 42 34 3 27 36 25 12 30 13 33 28 35 18 6 8 37 38 14 10 9 29 16 40 23 41 47", "output": "24 4 27 3 9 38 7 39 44 43 18 31 33 42 14 46 22 37 10 5 16 2 48 12 30 13 28 35 45 32 23 8 34 26 36 29 40 41 21 47 49 25 20 17 15 6 50 11 1 19" }, { "input": "34\n13 20 33 30 15 11 27 4 8 2 29 25 24 7 3 22 18 10 26 16 5 1 32 9 34 6 12 14 28 19 31 21 23 17", "output": "22 10 15 8 21 26 14 9 24 18 6 27 1 28 5 20 34 17 30 2 32 16 33 13 12 19 7 29 11 4 31 23 3 25" }, { "input": "92\n23 1 6 4 84 54 44 76 63 34 61 20 48 13 28 78 26 46 90 72 24 55 91 89 53 38 82 5 79 92 29 32 15 64 11 88 60 70 7 66 18 59 8 57 19 16 42 21 80 71 62 27 75 86 36 9 83 73 74 50 43 31 56 30 17 33 40 81 49 12 10 41 22 77 25 68 51 2 47 3 58 69 87 67 39 37 35 65 14 45 52 85", "output": "2 78 80 4 28 3 39 43 56 71 35 70 14 89 33 46 65 41 45 12 48 73 1 21 75 17 52 15 31 64 62 32 66 10 87 55 86 26 85 67 72 47 61 7 90 18 79 13 69 60 77 91 25 6 22 63 44 81 42 37 11 51 9 34 88 40 84 76 82 38 50 20 58 59 53 8 74 16 29 49 68 27 57 5 92 54 83 36 24 19 23 30" }, { "input": "49\n30 24 33 48 7 3 17 2 8 35 10 39 23 40 46 32 18 21 26 22 1 16 47 45 41 28 31 6 12 43 27 11 13 37 19 15 44 5 29 42 4 38 20 34 14 9 25 36 49", "output": "21 8 6 41 38 28 5 9 46 11 32 29 33 45 36 22 7 17 35 43 18 20 13 2 47 19 31 26 39 1 27 16 3 44 10 48 34 42 12 14 25 40 30 37 24 15 23 4 49" }, { "input": "12\n3 8 7 4 6 5 2 1 11 9 10 12", "output": "8 7 1 4 6 5 3 2 10 11 9 12" }, { "input": "78\n16 56 36 78 21 14 9 77 26 57 70 61 41 47 18 44 5 31 50 74 65 52 6 39 22 62 67 69 43 7 64 29 24 40 48 51 73 54 72 12 19 34 4 25 55 33 17 35 23 53 10 8 27 32 42 68 20 63 3 2 1 71 58 46 13 30 49 11 37 66 38 60 28 75 15 59 45 76", "output": "61 60 59 43 17 23 30 52 7 51 68 40 65 6 75 1 47 15 41 57 5 25 49 33 44 9 53 73 32 66 18 54 46 42 48 3 69 71 24 34 13 55 29 16 77 64 14 35 67 19 36 22 50 38 45 2 10 63 76 72 12 26 58 31 21 70 27 56 28 11 62 39 37 20 74 78 8 4" }, { "input": "64\n64 57 40 3 15 8 62 18 33 59 51 19 22 13 4 37 47 45 50 35 63 11 58 42 46 21 7 2 41 48 32 23 28 38 17 12 24 27 49 31 60 6 30 25 61 52 26 54 9 14 29 20 44 39 55 10 34 16 5 56 1 36 53 43", "output": "61 28 4 15 59 42 27 6 49 56 22 36 14 50 5 58 35 8 12 52 26 13 32 37 44 47 38 33 51 43 40 31 9 57 20 62 16 34 54 3 29 24 64 53 18 25 17 30 39 19 11 46 63 48 55 60 2 23 10 41 45 7 21 1" }, { "input": "49\n38 20 49 32 14 41 39 45 25 48 40 19 26 43 34 12 10 3 35 42 5 7 46 47 4 2 13 22 16 24 33 15 11 18 29 31 23 9 44 36 6 17 37 1 30 28 8 21 27", "output": "44 26 18 25 21 41 22 47 38 17 33 16 27 5 32 29 42 34 12 2 48 28 37 30 9 13 49 46 35 45 36 4 31 15 19 40 43 1 7 11 6 20 14 39 8 23 24 10 3" }, { "input": "78\n17 50 30 48 33 12 42 4 18 53 76 67 38 3 20 72 51 55 60 63 46 10 57 45 54 32 24 62 8 11 35 44 65 74 58 28 2 6 56 52 39 23 47 49 61 1 66 41 15 77 7 27 78 13 14 34 5 31 37 21 40 16 29 69 59 43 64 36 70 19 25 73 71 75 9 68 26 22", "output": "46 37 14 8 57 38 51 29 75 22 30 6 54 55 49 62 1 9 70 15 60 78 42 27 71 77 52 36 63 3 58 26 5 56 31 68 59 13 41 61 48 7 66 32 24 21 43 4 44 2 17 40 10 25 18 39 23 35 65 19 45 28 20 67 33 47 12 76 64 69 73 16 72 34 74 11 50 53" }, { "input": "29\n14 21 27 1 4 18 10 17 20 23 2 24 7 9 28 22 8 25 12 15 11 6 16 29 3 26 19 5 13", "output": "4 11 25 5 28 22 13 17 14 7 21 19 29 1 20 23 8 6 27 9 2 16 10 12 18 26 3 15 24" }, { "input": "82\n6 1 10 75 28 66 61 81 78 63 17 19 58 34 49 12 67 50 41 44 3 15 59 38 51 72 36 11 46 29 18 64 27 23 13 53 56 68 2 25 47 40 69 54 42 5 60 55 4 16 24 79 57 20 7 73 32 80 76 52 82 37 26 31 65 8 39 62 33 71 30 9 77 43 48 74 70 22 14 45 35 21", "output": "2 39 21 49 46 1 55 66 72 3 28 16 35 79 22 50 11 31 12 54 82 78 34 51 40 63 33 5 30 71 64 57 69 14 81 27 62 24 67 42 19 45 74 20 80 29 41 75 15 18 25 60 36 44 48 37 53 13 23 47 7 68 10 32 65 6 17 38 43 77 70 26 56 76 4 59 73 9 52 58 8 61" }, { "input": "82\n74 18 15 69 71 77 19 26 80 20 66 7 30 82 22 48 21 44 52 65 64 61 35 49 12 8 53 81 54 16 11 9 40 46 13 1 29 58 5 41 55 4 78 60 6 51 56 2 38 36 34 62 63 25 17 67 45 14 32 37 75 79 10 47 27 39 31 68 59 24 50 43 72 70 42 28 76 23 57 3 73 33", "output": "36 48 80 42 39 45 12 26 32 63 31 25 35 58 3 30 55 2 7 10 17 15 78 70 54 8 65 76 37 13 67 59 82 51 23 50 60 49 66 33 40 75 72 18 57 34 64 16 24 71 46 19 27 29 41 47 79 38 69 44 22 52 53 21 20 11 56 68 4 74 5 73 81 1 61 77 6 43 62 9 28 14" }, { "input": "45\n2 32 34 13 3 15 16 33 22 12 31 38 42 14 27 7 36 8 4 19 45 41 5 35 10 11 39 20 29 44 17 9 6 40 37 28 25 21 1 30 24 18 43 26 23", "output": "39 1 5 19 23 33 16 18 32 25 26 10 4 14 6 7 31 42 20 28 38 9 45 41 37 44 15 36 29 40 11 2 8 3 24 17 35 12 27 34 22 13 43 30 21" }, { "input": "45\n4 32 33 39 43 21 22 35 45 7 14 5 16 9 42 31 24 36 17 29 41 25 37 34 27 20 11 44 3 13 19 2 1 10 26 30 38 18 6 8 15 23 40 28 12", "output": "33 32 29 1 12 39 10 40 14 34 27 45 30 11 41 13 19 38 31 26 6 7 42 17 22 35 25 44 20 36 16 2 3 24 8 18 23 37 4 43 21 15 5 28 9" }, { "input": "74\n48 72 40 67 17 4 27 53 11 32 25 9 74 2 41 24 56 22 14 21 33 5 18 55 20 7 29 36 69 13 52 19 38 30 68 59 66 34 63 6 47 45 54 44 62 12 50 71 16 10 8 64 57 73 46 26 49 42 3 23 35 1 61 39 70 60 65 43 15 28 37 51 58 31", "output": "62 14 59 6 22 40 26 51 12 50 9 46 30 19 69 49 5 23 32 25 20 18 60 16 11 56 7 70 27 34 74 10 21 38 61 28 71 33 64 3 15 58 68 44 42 55 41 1 57 47 72 31 8 43 24 17 53 73 36 66 63 45 39 52 67 37 4 35 29 65 48 2 54 13" }, { "input": "47\n9 26 27 10 6 34 28 42 39 22 45 21 11 43 14 47 38 15 40 32 46 1 36 29 17 25 2 23 31 5 24 4 7 8 12 19 16 44 37 20 18 33 30 13 35 41 3", "output": "22 27 47 32 30 5 33 34 1 4 13 35 44 15 18 37 25 41 36 40 12 10 28 31 26 2 3 7 24 43 29 20 42 6 45 23 39 17 9 19 46 8 14 38 11 21 16" }, { "input": "49\n14 38 6 29 9 49 36 43 47 3 44 20 34 15 7 11 1 28 12 40 16 37 31 10 42 41 33 21 18 30 5 27 17 35 25 26 45 19 2 13 23 32 4 22 46 48 24 39 8", "output": "17 39 10 43 31 3 15 49 5 24 16 19 40 1 14 21 33 29 38 12 28 44 41 47 35 36 32 18 4 30 23 42 27 13 34 7 22 2 48 20 26 25 8 11 37 45 9 46 6" }, { "input": "100\n78 56 31 91 90 95 16 65 58 77 37 89 33 61 10 76 62 47 35 67 69 7 63 83 22 25 49 8 12 30 39 44 57 64 48 42 32 11 70 43 55 50 99 24 85 73 45 14 54 21 98 84 74 2 26 18 9 36 80 53 75 46 66 86 59 93 87 68 94 13 72 28 79 88 92 29 52 82 34 97 19 38 1 41 27 4 40 5 96 100 51 6 20 23 81 15 17 3 60 71", "output": "83 54 98 86 88 92 22 28 57 15 38 29 70 48 96 7 97 56 81 93 50 25 94 44 26 55 85 72 76 30 3 37 13 79 19 58 11 82 31 87 84 36 40 32 47 62 18 35 27 42 91 77 60 49 41 2 33 9 65 99 14 17 23 34 8 63 20 68 21 39 100 71 46 53 61 16 10 1 73 59 95 78 24 52 45 64 67 74 12 5 4 75 66 69 6 89 80 51 43 90" }, { "input": "22\n12 8 11 2 16 7 13 6 22 21 20 10 4 14 18 1 5 15 3 19 17 9", "output": "16 4 19 13 17 8 6 2 22 12 3 1 7 14 18 5 21 15 20 11 10 9" }, { "input": "72\n16 11 49 51 3 27 60 55 23 40 66 7 53 70 13 5 15 32 18 72 33 30 8 31 46 12 28 67 25 38 50 22 69 34 71 52 58 39 24 35 42 9 41 26 62 1 63 65 36 64 68 61 37 14 45 47 6 57 54 20 17 2 56 59 29 10 4 48 21 43 19 44", "output": "46 62 5 67 16 57 12 23 42 66 2 26 15 54 17 1 61 19 71 60 69 32 9 39 29 44 6 27 65 22 24 18 21 34 40 49 53 30 38 10 43 41 70 72 55 25 56 68 3 31 4 36 13 59 8 63 58 37 64 7 52 45 47 50 48 11 28 51 33 14 35 20" }, { "input": "63\n21 56 11 10 62 24 20 42 28 52 38 2 37 43 48 22 7 8 40 14 13 46 53 1 23 4 60 63 51 36 25 12 39 32 49 16 58 44 31 61 33 50 55 54 45 6 47 41 9 57 30 29 26 18 19 27 15 34 3 35 59 5 17", "output": "24 12 59 26 62 46 17 18 49 4 3 32 21 20 57 36 63 54 55 7 1 16 25 6 31 53 56 9 52 51 39 34 41 58 60 30 13 11 33 19 48 8 14 38 45 22 47 15 35 42 29 10 23 44 43 2 50 37 61 27 40 5 28" }, { "input": "18\n2 16 8 4 18 12 3 6 5 9 10 15 11 17 14 13 1 7", "output": "17 1 7 4 9 8 18 3 10 11 13 6 16 15 12 2 14 5" }, { "input": "47\n6 9 10 41 25 3 4 37 20 1 36 22 29 27 11 24 43 31 12 17 34 42 38 39 13 2 7 21 18 5 15 35 44 26 33 46 19 40 30 14 28 23 47 32 45 8 16", "output": "10 26 6 7 30 1 27 46 2 3 15 19 25 40 31 47 20 29 37 9 28 12 42 16 5 34 14 41 13 39 18 44 35 21 32 11 8 23 24 38 4 22 17 33 45 36 43" }, { "input": "96\n41 91 48 88 29 57 1 19 44 43 37 5 10 75 25 63 30 78 76 53 8 92 18 70 39 17 49 60 9 16 3 34 86 59 23 79 55 45 72 51 28 33 96 40 26 54 6 32 89 61 85 74 7 82 52 31 64 66 94 95 11 22 2 73 35 13 42 71 14 47 84 69 50 67 58 12 77 46 38 68 15 36 20 93 27 90 83 56 87 4 21 24 81 62 80 65", "output": "7 63 31 90 12 47 53 21 29 13 61 76 66 69 81 30 26 23 8 83 91 62 35 92 15 45 85 41 5 17 56 48 42 32 65 82 11 79 25 44 1 67 10 9 38 78 70 3 27 73 40 55 20 46 37 88 6 75 34 28 50 94 16 57 96 58 74 80 72 24 68 39 64 52 14 19 77 18 36 95 93 54 87 71 51 33 89 4 49 86 2 22 84 59 60 43" }, { "input": "73\n67 24 39 22 23 20 48 34 42 40 19 70 65 69 64 21 53 11 59 15 26 10 30 33 72 29 55 25 56 71 8 9 57 49 41 61 13 12 6 27 66 36 47 50 73 60 2 37 7 4 51 17 1 46 14 62 35 3 45 63 43 58 54 32 31 5 28 44 18 52 68 38 16", "output": "53 47 58 50 66 39 49 31 32 22 18 38 37 55 20 73 52 69 11 6 16 4 5 2 28 21 40 67 26 23 65 64 24 8 57 42 48 72 3 10 35 9 61 68 59 54 43 7 34 44 51 70 17 63 27 29 33 62 19 46 36 56 60 15 13 41 1 71 14 12 30 25 45" }, { "input": "81\n25 2 78 40 12 80 69 13 49 43 17 33 23 54 32 61 77 66 27 71 24 26 42 55 60 9 5 30 7 37 45 63 53 11 38 44 68 34 28 52 67 22 57 46 47 50 8 16 79 62 4 36 20 14 73 64 6 76 35 74 58 10 29 81 59 31 19 1 75 39 70 18 41 21 72 65 3 48 15 56 51", "output": "68 2 77 51 27 57 29 47 26 62 34 5 8 54 79 48 11 72 67 53 74 42 13 21 1 22 19 39 63 28 66 15 12 38 59 52 30 35 70 4 73 23 10 36 31 44 45 78 9 46 81 40 33 14 24 80 43 61 65 25 16 50 32 56 76 18 41 37 7 71 20 75 55 60 69 58 17 3 49 6 64" }, { "input": "12\n12 3 1 5 11 6 7 10 2 8 9 4", "output": "3 9 2 12 4 6 7 10 11 8 5 1" }, { "input": "47\n7 21 41 18 40 31 12 28 24 14 43 23 33 10 19 38 26 8 34 15 29 44 5 13 39 25 3 27 20 42 35 9 2 1 30 46 36 32 4 22 37 45 6 47 11 16 17", "output": "34 33 27 39 23 43 1 18 32 14 45 7 24 10 20 46 47 4 15 29 2 40 12 9 26 17 28 8 21 35 6 38 13 19 31 37 41 16 25 5 3 30 11 22 42 36 44" }, { "input": "8\n1 3 5 2 4 8 6 7", "output": "1 4 2 5 3 7 8 6" }, { "input": "38\n28 8 2 33 20 32 26 29 23 31 15 38 11 37 18 21 22 19 4 34 1 35 16 7 17 6 27 30 36 12 9 24 25 13 5 3 10 14", "output": "21 3 36 19 35 26 24 2 31 37 13 30 34 38 11 23 25 15 18 5 16 17 9 32 33 7 27 1 8 28 10 6 4 20 22 29 14 12" }, { "input": "10\n2 9 4 6 10 1 7 5 3 8", "output": "6 1 9 3 8 4 7 10 2 5" }, { "input": "23\n20 11 15 1 5 12 23 9 2 22 13 19 16 14 7 4 8 21 6 17 18 10 3", "output": "4 9 23 16 5 19 15 17 8 22 2 6 11 14 3 13 20 21 12 1 18 10 7" }, { "input": "10\n2 4 9 3 6 8 10 5 1 7", "output": "9 1 4 2 8 5 10 6 3 7" }, { "input": "55\n9 48 23 49 11 24 4 22 34 32 17 45 39 13 14 21 19 25 2 31 37 7 55 36 20 51 5 12 54 10 35 40 43 1 46 18 53 41 38 26 29 50 3 42 52 27 8 28 47 33 6 16 30 44 15", "output": "34 19 43 7 27 51 22 47 1 30 5 28 14 15 55 52 11 36 17 25 16 8 3 6 18 40 46 48 41 53 20 10 50 9 31 24 21 39 13 32 38 44 33 54 12 35 49 2 4 42 26 45 37 29 23" }, { "input": "58\n49 13 12 54 2 38 56 11 33 25 26 19 28 8 23 41 20 36 46 55 15 35 9 7 32 37 58 6 3 14 47 31 40 30 53 44 4 50 29 34 10 43 39 57 5 22 27 45 51 42 24 16 18 21 52 17 48 1", "output": "58 5 29 37 45 28 24 14 23 41 8 3 2 30 21 52 56 53 12 17 54 46 15 51 10 11 47 13 39 34 32 25 9 40 22 18 26 6 43 33 16 50 42 36 48 19 31 57 1 38 49 55 35 4 20 7 44 27" }, { "input": "34\n20 25 2 3 33 29 1 16 14 7 21 9 32 31 6 26 22 4 27 23 24 10 34 12 19 15 5 18 28 17 13 8 11 30", "output": "7 3 4 18 27 15 10 32 12 22 33 24 31 9 26 8 30 28 25 1 11 17 20 21 2 16 19 29 6 34 14 13 5 23" }, { "input": "53\n47 29 46 25 23 13 7 31 33 4 38 11 35 16 42 14 15 43 34 39 28 18 6 45 30 1 40 20 2 37 5 32 24 12 44 26 27 3 19 51 36 21 22 9 10 50 41 48 49 53 8 17 52", "output": "26 29 38 10 31 23 7 51 44 45 12 34 6 16 17 14 52 22 39 28 42 43 5 33 4 36 37 21 2 25 8 32 9 19 13 41 30 11 20 27 47 15 18 35 24 3 1 48 49 46 40 53 50" }, { "input": "99\n77 87 90 48 53 38 68 6 28 57 35 82 63 71 60 41 3 12 86 65 10 59 22 67 33 74 93 27 24 1 61 43 25 4 51 52 15 88 9 31 30 42 89 49 23 21 29 32 46 73 37 16 5 69 56 26 92 64 20 54 75 14 98 13 94 2 95 7 36 66 58 8 50 78 84 45 11 96 76 62 97 80 40 39 47 85 34 79 83 17 91 72 19 44 70 81 55 99 18", "output": "30 66 17 34 53 8 68 72 39 21 77 18 64 62 37 52 90 99 93 59 46 23 45 29 33 56 28 9 47 41 40 48 25 87 11 69 51 6 84 83 16 42 32 94 76 49 85 4 44 73 35 36 5 60 97 55 10 71 22 15 31 80 13 58 20 70 24 7 54 95 14 92 50 26 61 79 1 74 88 82 96 12 89 75 86 19 2 38 43 3 91 57 27 65 67 78 81 63 98" }, { "input": "32\n17 29 2 6 30 8 26 7 1 27 10 9 13 24 31 21 15 19 22 18 4 11 25 28 32 3 23 12 5 14 20 16", "output": "9 3 26 21 29 4 8 6 12 11 22 28 13 30 17 32 1 20 18 31 16 19 27 14 23 7 10 24 2 5 15 25" }, { "input": "65\n18 40 1 60 17 19 4 6 12 49 28 58 2 25 13 14 64 56 61 34 62 30 59 51 26 8 33 63 36 48 46 7 43 21 31 27 11 44 29 5 32 23 35 9 53 57 52 50 15 38 42 3 54 65 55 41 20 24 22 47 45 10 39 16 37", "output": "3 13 52 7 40 8 32 26 44 62 37 9 15 16 49 64 5 1 6 57 34 59 42 58 14 25 36 11 39 22 35 41 27 20 43 29 65 50 63 2 56 51 33 38 61 31 60 30 10 48 24 47 45 53 55 18 46 12 23 4 19 21 28 17 54" }, { "input": "71\n35 50 55 58 25 32 26 40 63 34 44 53 24 18 37 7 64 27 56 65 1 19 2 43 42 14 57 47 22 13 59 61 39 67 30 45 54 38 33 48 6 5 3 69 36 21 41 4 16 46 20 17 15 12 10 70 68 23 60 31 52 29 66 28 51 49 62 11 8 9 71", "output": "21 23 43 48 42 41 16 69 70 55 68 54 30 26 53 49 52 14 22 51 46 29 58 13 5 7 18 64 62 35 60 6 39 10 1 45 15 38 33 8 47 25 24 11 36 50 28 40 66 2 65 61 12 37 3 19 27 4 31 59 32 67 9 17 20 63 34 57 44 56 71" }, { "input": "74\n33 8 42 63 64 61 31 74 11 50 68 14 36 25 57 30 7 44 21 15 6 9 23 59 46 3 73 16 62 51 40 60 41 54 5 39 35 28 48 4 58 12 66 69 13 26 71 1 24 19 29 52 37 2 20 43 18 72 17 56 34 38 65 67 27 10 47 70 53 32 45 55 49 22", "output": "48 54 26 40 35 21 17 2 22 66 9 42 45 12 20 28 59 57 50 55 19 74 23 49 14 46 65 38 51 16 7 70 1 61 37 13 53 62 36 31 33 3 56 18 71 25 67 39 73 10 30 52 69 34 72 60 15 41 24 32 6 29 4 5 63 43 64 11 44 68 47 58 27 8" }, { "input": "96\n78 10 82 46 38 91 77 69 2 27 58 80 79 44 59 41 6 31 76 11 42 48 51 37 19 87 43 25 52 32 1 39 63 29 21 65 53 74 92 16 15 95 90 83 30 73 71 5 50 17 96 33 86 60 67 64 20 26 61 40 55 88 94 93 9 72 47 57 14 45 22 3 54 68 13 24 4 7 56 81 89 70 49 8 84 28 18 62 35 36 75 23 66 85 34 12", "output": "31 9 72 77 48 17 78 84 65 2 20 96 75 69 41 40 50 87 25 57 35 71 92 76 28 58 10 86 34 45 18 30 52 95 89 90 24 5 32 60 16 21 27 14 70 4 67 22 83 49 23 29 37 73 61 79 68 11 15 54 59 88 33 56 36 93 55 74 8 82 47 66 46 38 91 19 7 1 13 12 80 3 44 85 94 53 26 62 81 43 6 39 64 63 42 51" }, { "input": "7\n2 1 5 7 3 4 6", "output": "2 1 5 6 3 7 4" }, { "input": "51\n8 33 37 2 16 22 24 30 4 9 5 15 27 3 18 39 31 26 10 17 46 41 25 14 6 1 29 48 36 20 51 49 21 43 19 13 38 50 47 34 11 23 28 12 42 7 32 40 44 45 35", "output": "26 4 14 9 11 25 46 1 10 19 41 44 36 24 12 5 20 15 35 30 33 6 42 7 23 18 13 43 27 8 17 47 2 40 51 29 3 37 16 48 22 45 34 49 50 21 39 28 32 38 31" }, { "input": "27\n12 14 7 3 20 21 25 13 22 15 23 4 2 24 10 17 19 8 26 11 27 18 9 5 6 1 16", "output": "26 13 4 12 24 25 3 18 23 15 20 1 8 2 10 27 16 22 17 5 6 9 11 14 7 19 21" }, { "input": "71\n51 13 20 48 54 23 24 64 14 62 71 67 57 53 3 30 55 43 33 25 39 40 66 6 46 18 5 19 61 16 32 68 70 41 60 44 29 49 27 69 50 38 10 17 45 56 9 21 26 63 28 35 7 59 1 65 2 15 8 11 12 34 37 47 58 22 31 4 36 42 52", "output": "55 57 15 68 27 24 53 59 47 43 60 61 2 9 58 30 44 26 28 3 48 66 6 7 20 49 39 51 37 16 67 31 19 62 52 69 63 42 21 22 34 70 18 36 45 25 64 4 38 41 1 71 14 5 17 46 13 65 54 35 29 10 50 8 56 23 12 32 40 33 11" }, { "input": "9\n8 5 2 6 1 9 4 7 3", "output": "5 3 9 7 2 4 8 1 6" }, { "input": "29\n10 24 11 5 26 25 2 9 22 15 8 14 29 21 4 1 23 17 3 12 13 16 18 28 19 20 7 6 27", "output": "16 7 19 15 4 28 27 11 8 1 3 20 21 12 10 22 18 23 25 26 14 9 17 2 6 5 29 24 13" }, { "input": "60\n39 25 42 4 55 60 16 18 47 1 11 40 7 50 19 35 49 54 12 3 30 38 2 58 17 26 45 6 33 43 37 32 52 36 15 23 27 59 24 20 28 14 8 9 13 29 44 46 41 21 5 48 51 22 31 56 57 53 10 34", "output": "10 23 20 4 51 28 13 43 44 59 11 19 45 42 35 7 25 8 15 40 50 54 36 39 2 26 37 41 46 21 55 32 29 60 16 34 31 22 1 12 49 3 30 47 27 48 9 52 17 14 53 33 58 18 5 56 57 24 38 6" }, { "input": "50\n37 45 22 5 12 21 28 24 18 47 20 25 8 50 14 2 34 43 11 16 49 41 48 1 19 31 39 46 32 23 15 42 3 35 38 30 44 26 10 9 40 36 7 17 33 4 27 6 13 29", "output": "24 16 33 46 4 48 43 13 40 39 19 5 49 15 31 20 44 9 25 11 6 3 30 8 12 38 47 7 50 36 26 29 45 17 34 42 1 35 27 41 22 32 18 37 2 28 10 23 21 14" }, { "input": "30\n8 29 28 16 17 25 27 15 21 11 6 20 2 13 1 30 5 4 24 10 14 3 23 18 26 9 12 22 19 7", "output": "15 13 22 18 17 11 30 1 26 20 10 27 14 21 8 4 5 24 29 12 9 28 23 19 6 25 7 3 2 16" }, { "input": "46\n15 2 44 43 38 19 31 42 4 37 29 30 24 45 27 41 8 20 33 7 35 3 18 46 36 26 1 28 21 40 16 22 32 11 14 13 12 9 25 39 10 6 23 17 5 34", "output": "27 2 22 9 45 42 20 17 38 41 34 37 36 35 1 31 44 23 6 18 29 32 43 13 39 26 15 28 11 12 7 33 19 46 21 25 10 5 40 30 16 8 4 3 14 24" }, { "input": "9\n4 8 6 5 3 9 2 7 1", "output": "9 7 5 1 4 3 8 2 6" }, { "input": "46\n31 30 33 23 45 7 36 8 11 3 32 39 41 20 1 28 6 27 18 24 17 5 16 37 26 13 22 14 2 38 15 46 9 4 19 21 12 44 10 35 25 34 42 43 40 29", "output": "15 29 10 34 22 17 6 8 33 39 9 37 26 28 31 23 21 19 35 14 36 27 4 20 41 25 18 16 46 2 1 11 3 42 40 7 24 30 12 45 13 43 44 38 5 32" }, { "input": "66\n27 12 37 48 46 21 34 58 38 28 66 2 64 32 44 31 13 36 40 15 19 11 22 5 30 29 6 7 61 39 20 42 23 54 51 33 50 9 60 8 57 45 49 10 62 41 59 3 55 63 52 24 25 26 43 56 65 4 16 14 1 35 18 17 53 47", "output": "61 12 48 58 24 27 28 40 38 44 22 2 17 60 20 59 64 63 21 31 6 23 33 52 53 54 1 10 26 25 16 14 36 7 62 18 3 9 30 19 46 32 55 15 42 5 66 4 43 37 35 51 65 34 49 56 41 8 47 39 29 45 50 13 57 11" }, { "input": "13\n3 12 9 2 8 5 13 4 11 1 10 7 6", "output": "10 4 1 8 6 13 12 5 3 11 9 2 7" }, { "input": "80\n21 25 56 50 20 61 7 74 51 69 8 2 46 57 45 71 14 52 17 43 9 30 70 78 31 10 38 13 23 15 37 79 6 16 77 73 80 4 49 48 18 28 26 58 33 41 64 22 54 72 59 60 40 63 53 27 1 5 75 67 62 34 19 39 68 65 44 55 3 32 11 42 76 12 35 47 66 36 24 29", "output": "57 12 69 38 58 33 7 11 21 26 71 74 28 17 30 34 19 41 63 5 1 48 29 79 2 43 56 42 80 22 25 70 45 62 75 78 31 27 64 53 46 72 20 67 15 13 76 40 39 4 9 18 55 49 68 3 14 44 51 52 6 61 54 47 66 77 60 65 10 23 16 50 36 8 59 73 35 24 32 37" }, { "input": "63\n9 49 53 25 40 46 43 51 54 22 58 16 23 26 10 47 5 27 2 8 61 59 19 35 63 56 28 20 34 4 62 38 6 55 36 31 57 15 29 33 1 48 50 37 7 30 18 42 32 52 12 41 14 21 45 11 24 17 39 13 44 60 3", "output": "41 19 63 30 17 33 45 20 1 15 56 51 60 53 38 12 58 47 23 28 54 10 13 57 4 14 18 27 39 46 36 49 40 29 24 35 44 32 59 5 52 48 7 61 55 6 16 42 2 43 8 50 3 9 34 26 37 11 22 62 21 31 25" }, { "input": "26\n11 4 19 13 17 9 2 24 6 5 22 23 14 15 3 25 16 8 18 10 21 1 12 26 7 20", "output": "22 7 15 2 10 9 25 18 6 20 1 23 4 13 14 17 5 19 3 26 21 11 12 8 16 24" }, { "input": "69\n40 22 11 66 4 27 31 29 64 53 37 55 51 2 7 36 18 52 6 1 30 21 17 20 14 9 59 62 49 68 3 50 65 57 44 5 67 46 33 13 34 15 24 48 63 58 38 25 41 35 16 54 32 10 60 61 39 12 69 8 23 45 26 47 56 43 28 19 42", "output": "20 14 31 5 36 19 15 60 26 54 3 58 40 25 42 51 23 17 68 24 22 2 61 43 48 63 6 67 8 21 7 53 39 41 50 16 11 47 57 1 49 69 66 35 62 38 64 44 29 32 13 18 10 52 12 65 34 46 27 55 56 28 45 9 33 4 37 30 59" }, { "input": "6\n4 3 6 5 1 2", "output": "5 6 2 1 4 3" }, { "input": "9\n7 8 5 3 1 4 2 9 6", "output": "5 7 4 6 3 9 1 2 8" }, { "input": "41\n27 24 16 30 25 8 32 2 26 20 39 33 41 22 40 14 36 9 28 4 34 11 31 23 19 18 17 35 3 10 6 13 5 15 29 38 7 21 1 12 37", "output": "39 8 29 20 33 31 37 6 18 30 22 40 32 16 34 3 27 26 25 10 38 14 24 2 5 9 1 19 35 4 23 7 12 21 28 17 41 36 11 15 13" }, { "input": "1\n1", "output": "1" }, { "input": "20\n2 6 4 18 7 10 17 13 16 8 14 9 20 5 19 12 1 3 15 11", "output": "17 1 18 3 14 2 5 10 12 6 20 16 8 11 19 9 7 4 15 13" }, { "input": "2\n2 1", "output": "2 1" }, { "input": "60\n2 4 31 51 11 7 34 20 3 14 18 23 48 54 15 36 38 60 49 40 5 33 41 26 55 58 10 8 13 9 27 30 37 1 21 59 44 57 35 19 46 43 42 45 12 22 39 32 24 16 6 56 53 52 25 17 47 29 50 28", "output": "34 1 9 2 21 51 6 28 30 27 5 45 29 10 15 50 56 11 40 8 35 46 12 49 55 24 31 60 58 32 3 48 22 7 39 16 33 17 47 20 23 43 42 37 44 41 57 13 19 59 4 54 53 14 25 52 38 26 36 18" }, { "input": "14\n14 6 3 12 11 2 7 1 10 9 8 5 4 13", "output": "8 6 3 13 12 2 7 11 10 9 5 4 14 1" }, { "input": "81\n13 43 79 8 7 21 73 46 63 4 62 78 56 11 70 68 61 53 60 49 16 27 59 47 69 5 22 44 77 57 52 48 1 9 72 81 28 55 58 33 51 18 31 17 41 20 42 3 32 54 19 2 75 34 64 10 65 50 30 29 67 12 71 66 74 15 26 23 6 38 25 35 37 24 80 76 40 45 39 36 14", "output": "33 52 48 10 26 69 5 4 34 56 14 62 1 81 66 21 44 42 51 46 6 27 68 74 71 67 22 37 60 59 43 49 40 54 72 80 73 70 79 77 45 47 2 28 78 8 24 32 20 58 41 31 18 50 38 13 30 39 23 19 17 11 9 55 57 64 61 16 25 15 63 35 7 65 53 76 29 12 3 75 36" }, { "input": "42\n41 11 10 8 21 37 32 19 31 25 1 15 36 5 6 27 4 3 13 7 16 17 2 23 34 24 38 28 12 20 30 42 18 26 39 35 33 40 9 14 22 29", "output": "11 23 18 17 14 15 20 4 39 3 2 29 19 40 12 21 22 33 8 30 5 41 24 26 10 34 16 28 42 31 9 7 37 25 36 13 6 27 35 38 1 32" }, { "input": "97\n20 6 76 42 4 18 35 59 39 63 27 7 66 47 61 52 15 36 88 93 19 33 10 92 1 34 46 86 78 57 51 94 77 29 26 73 41 2 58 97 43 65 17 74 21 49 25 3 91 82 95 12 96 13 84 90 69 24 72 37 16 55 54 71 64 62 48 89 11 70 80 67 30 40 44 85 53 83 79 9 56 45 75 87 22 14 81 68 8 38 60 50 28 23 31 32 5", "output": "25 38 48 5 97 2 12 89 80 23 69 52 54 86 17 61 43 6 21 1 45 85 94 58 47 35 11 93 34 73 95 96 22 26 7 18 60 90 9 74 37 4 41 75 82 27 14 67 46 92 31 16 77 63 62 81 30 39 8 91 15 66 10 65 42 13 72 88 57 70 64 59 36 44 83 3 33 29 79 71 87 50 78 55 76 28 84 19 68 56 49 24 20 32 51 53 40" }, { "input": "62\n15 27 46 6 8 51 14 56 23 48 42 49 52 22 20 31 29 12 47 3 62 34 37 35 32 57 19 25 5 60 61 38 18 10 11 55 45 53 17 30 9 36 4 50 41 16 44 28 40 59 24 1 13 39 26 7 33 58 2 43 21 54", "output": "52 59 20 43 29 4 56 5 41 34 35 18 53 7 1 46 39 33 27 15 61 14 9 51 28 55 2 48 17 40 16 25 57 22 24 42 23 32 54 49 45 11 60 47 37 3 19 10 12 44 6 13 38 62 36 8 26 58 50 30 31 21" }, { "input": "61\n35 27 4 61 52 32 41 46 14 37 17 54 55 31 11 26 44 49 15 30 9 50 45 39 7 38 53 3 58 40 13 56 18 19 28 6 43 5 21 42 20 34 2 25 36 12 33 57 16 60 1 8 59 10 22 23 24 48 51 47 29", "output": "51 43 28 3 38 36 25 52 21 54 15 46 31 9 19 49 11 33 34 41 39 55 56 57 44 16 2 35 61 20 14 6 47 42 1 45 10 26 24 30 7 40 37 17 23 8 60 58 18 22 59 5 27 12 13 32 48 29 53 50 4" }, { "input": "59\n31 26 36 15 17 19 10 53 11 34 13 46 55 9 44 7 8 37 32 52 47 25 51 22 35 39 41 4 43 24 5 27 20 57 6 38 3 28 21 40 50 18 14 56 33 45 12 2 49 59 54 29 16 48 42 58 1 30 23", "output": "57 48 37 28 31 35 16 17 14 7 9 47 11 43 4 53 5 42 6 33 39 24 59 30 22 2 32 38 52 58 1 19 45 10 25 3 18 36 26 40 27 55 29 15 46 12 21 54 49 41 23 20 8 51 13 44 34 56 50" }, { "input": "10\n2 10 7 4 1 5 8 6 3 9", "output": "5 1 9 4 6 8 3 7 10 2" }, { "input": "14\n14 2 1 8 6 12 11 10 9 7 3 4 5 13", "output": "3 2 11 12 13 5 10 4 9 8 7 6 14 1" }, { "input": "43\n28 38 15 14 31 42 27 30 19 33 43 26 22 29 18 32 3 13 1 8 35 34 4 12 11 17 41 21 5 25 39 37 20 23 7 24 16 10 40 9 6 36 2", "output": "19 43 17 23 29 41 35 20 40 38 25 24 18 4 3 37 26 15 9 33 28 13 34 36 30 12 7 1 14 8 5 16 10 22 21 42 32 2 31 39 27 6 11" }, { "input": "86\n39 11 20 31 28 76 29 64 35 21 41 71 12 82 5 37 80 73 38 26 79 75 23 15 59 45 47 6 3 62 50 49 51 22 2 65 86 60 70 42 74 17 1 30 55 44 8 66 81 27 57 77 43 13 54 32 72 46 48 56 14 34 78 52 36 85 24 19 69 83 25 61 7 4 84 33 63 58 18 40 68 10 67 9 16 53", "output": "43 35 29 74 15 28 73 47 84 82 2 13 54 61 24 85 42 79 68 3 10 34 23 67 71 20 50 5 7 44 4 56 76 62 9 65 16 19 1 80 11 40 53 46 26 58 27 59 32 31 33 64 86 55 45 60 51 78 25 38 72 30 77 8 36 48 83 81 69 39 12 57 18 41 22 6 52 63 21 17 49 14 70 75 66 37" }, { "input": "99\n65 78 56 98 33 24 61 40 29 93 1 64 57 22 25 52 67 95 50 3 31 15 90 68 71 83 38 36 6 46 89 26 4 87 14 88 72 37 23 43 63 12 80 96 5 34 73 86 9 48 92 62 99 10 16 20 66 27 28 2 82 70 30 94 49 8 84 69 18 60 58 59 44 39 21 7 91 76 54 19 75 85 74 47 55 32 97 77 51 13 35 79 45 42 11 41 17 81 53", "output": "11 60 20 33 45 29 76 66 49 54 95 42 90 35 22 55 97 69 80 56 75 14 39 6 15 32 58 59 9 63 21 86 5 46 91 28 38 27 74 8 96 94 40 73 93 30 84 50 65 19 89 16 99 79 85 3 13 71 72 70 7 52 41 12 1 57 17 24 68 62 25 37 47 83 81 78 88 2 92 43 98 61 26 67 82 48 34 36 31 23 77 51 10 64 18 44 87 4 53" }, { "input": "100\n42 23 48 88 36 6 18 70 96 1 34 40 46 22 39 55 85 93 45 67 71 75 59 9 21 3 86 63 65 68 20 38 73 31 84 90 50 51 56 95 72 33 49 19 83 76 54 74 100 30 17 98 15 94 4 97 5 99 81 27 92 32 89 12 13 91 87 29 60 11 52 43 35 58 10 25 16 80 28 2 44 61 8 82 66 69 41 24 57 62 78 37 79 77 53 7 14 47 26 64", "output": "10 80 26 55 57 6 96 83 24 75 70 64 65 97 53 77 51 7 44 31 25 14 2 88 76 99 60 79 68 50 34 62 42 11 73 5 92 32 15 12 87 1 72 81 19 13 98 3 43 37 38 71 95 47 16 39 89 74 23 69 82 90 28 100 29 85 20 30 86 8 21 41 33 48 22 46 94 91 93 78 59 84 45 35 17 27 67 4 63 36 66 61 18 54 40 9 56 52 58 49" }, { "input": "99\n8 68 94 75 71 60 57 58 6 11 5 48 65 41 49 12 46 72 95 59 13 70 74 7 84 62 17 36 55 76 38 79 2 85 23 10 32 99 87 50 83 28 54 91 53 51 1 3 97 81 21 89 93 78 61 26 82 96 4 98 25 40 31 44 24 47 30 52 14 16 39 27 9 29 45 18 67 63 37 43 90 66 19 69 88 22 92 77 34 42 73 80 56 64 20 35 15 33 86", "output": "47 33 48 59 11 9 24 1 73 36 10 16 21 69 97 70 27 76 83 95 51 86 35 65 61 56 72 42 74 67 63 37 98 89 96 28 79 31 71 62 14 90 80 64 75 17 66 12 15 40 46 68 45 43 29 93 7 8 20 6 55 26 78 94 13 82 77 2 84 22 5 18 91 23 4 30 88 54 32 92 50 57 41 25 34 99 39 85 52 81 44 87 53 3 19 58 49 60 38" }, { "input": "99\n12 99 88 13 7 19 74 47 23 90 16 29 26 11 58 60 64 98 37 18 82 67 72 46 51 85 17 92 87 20 77 36 78 71 57 35 80 54 73 15 14 62 97 45 31 79 94 56 76 96 28 63 8 44 38 86 49 2 52 66 61 59 10 43 55 50 22 34 83 53 95 40 81 21 30 42 27 3 5 41 1 70 69 25 93 48 65 6 24 89 91 33 39 68 9 4 32 84 75", "output": "81 58 78 96 79 88 5 53 95 63 14 1 4 41 40 11 27 20 6 30 74 67 9 89 84 13 77 51 12 75 45 97 92 68 36 32 19 55 93 72 80 76 64 54 44 24 8 86 57 66 25 59 70 38 65 48 35 15 62 16 61 42 52 17 87 60 22 94 83 82 34 23 39 7 99 49 31 33 46 37 73 21 69 98 26 56 29 3 90 10 91 28 85 47 71 50 43 18 2" }, { "input": "99\n20 79 26 75 99 69 98 47 93 62 18 42 43 38 90 66 67 8 13 84 76 58 81 60 64 46 56 23 78 17 86 36 19 52 85 39 48 27 96 49 37 95 5 31 10 24 12 1 80 35 92 33 16 68 57 54 32 29 45 88 72 77 4 87 97 89 59 3 21 22 61 94 83 15 44 34 70 91 55 9 51 50 73 11 14 6 40 7 63 25 2 82 41 65 28 74 71 30 53", "output": "48 91 68 63 43 86 88 18 80 45 84 47 19 85 74 53 30 11 33 1 69 70 28 46 90 3 38 95 58 98 44 57 52 76 50 32 41 14 36 87 93 12 13 75 59 26 8 37 40 82 81 34 99 56 79 27 55 22 67 24 71 10 89 25 94 16 17 54 6 77 97 61 83 96 4 21 62 29 2 49 23 92 73 20 35 31 64 60 66 15 78 51 9 72 42 39 65 7 5" }, { "input": "99\n74 20 9 1 60 85 65 13 4 25 40 99 5 53 64 3 36 31 73 44 55 50 45 63 98 51 68 6 47 37 71 82 88 34 84 18 19 12 93 58 86 7 11 46 90 17 33 27 81 69 42 59 56 32 95 52 76 61 96 62 78 43 66 21 49 97 75 14 41 72 89 16 30 79 22 23 15 83 91 38 48 2 87 26 28 80 94 70 54 92 57 10 8 35 67 77 29 24 39", "output": "4 82 16 9 13 28 42 93 3 92 43 38 8 68 77 72 46 36 37 2 64 75 76 98 10 84 48 85 97 73 18 54 47 34 94 17 30 80 99 11 69 51 62 20 23 44 29 81 65 22 26 56 14 89 21 53 91 40 52 5 58 60 24 15 7 63 95 27 50 88 31 70 19 1 67 57 96 61 74 86 49 32 78 35 6 41 83 33 71 45 79 90 39 87 55 59 66 25 12" }, { "input": "99\n50 94 2 18 69 90 59 83 75 68 77 97 39 78 25 7 16 9 49 4 42 89 44 48 17 96 61 70 3 10 5 81 56 57 88 6 98 1 46 67 92 37 11 30 85 41 8 36 51 29 20 71 19 79 74 93 43 34 55 40 38 21 64 63 32 24 72 14 12 86 82 15 65 23 66 22 28 53 13 26 95 99 91 52 76 27 60 45 47 33 73 84 31 35 54 80 58 62 87", "output": "38 3 29 20 31 36 16 47 18 30 43 69 79 68 72 17 25 4 53 51 62 76 74 66 15 80 86 77 50 44 93 65 90 58 94 48 42 61 13 60 46 21 57 23 88 39 89 24 19 1 49 84 78 95 59 33 34 97 7 87 27 98 64 63 73 75 40 10 5 28 52 67 91 55 9 85 11 14 54 96 32 71 8 92 45 70 99 35 22 6 83 41 56 2 81 26 12 37 82" }, { "input": "99\n19 93 14 34 39 37 33 15 52 88 7 43 69 27 9 77 94 31 48 22 63 70 79 17 50 6 81 8 76 58 23 74 86 11 57 62 41 87 75 51 12 18 68 56 95 3 80 83 84 29 24 61 71 78 59 96 20 85 90 28 45 36 38 97 1 49 40 98 44 67 13 73 72 91 47 10 30 54 35 42 4 2 92 26 64 60 53 21 5 82 46 32 55 66 16 89 99 65 25", "output": "65 82 46 81 89 26 11 28 15 76 34 41 71 3 8 95 24 42 1 57 88 20 31 51 99 84 14 60 50 77 18 92 7 4 79 62 6 63 5 67 37 80 12 69 61 91 75 19 66 25 40 9 87 78 93 44 35 30 55 86 52 36 21 85 98 94 70 43 13 22 53 73 72 32 39 29 16 54 23 47 27 90 48 49 58 33 38 10 96 59 74 83 2 17 45 56 64 68 97" }, { "input": "99\n86 25 50 51 62 39 41 67 44 20 45 14 80 88 66 7 36 59 13 84 78 58 96 75 2 43 48 47 69 12 19 98 22 38 28 55 11 76 68 46 53 70 85 34 16 33 91 30 8 40 74 60 94 82 87 32 37 4 5 10 89 73 90 29 35 26 23 57 27 65 24 3 9 83 77 72 6 31 15 92 93 79 64 18 63 42 56 1 52 97 17 81 71 21 49 99 54 95 61", "output": "88 25 72 58 59 77 16 49 73 60 37 30 19 12 79 45 91 84 31 10 94 33 67 71 2 66 69 35 64 48 78 56 46 44 65 17 57 34 6 50 7 86 26 9 11 40 28 27 95 3 4 89 41 97 36 87 68 22 18 52 99 5 85 83 70 15 8 39 29 42 93 76 62 51 24 38 75 21 82 13 92 54 74 20 43 1 55 14 61 63 47 80 81 53 98 23 90 32 96" }, { "input": "100\n66 44 99 15 43 79 28 33 88 90 49 68 82 38 9 74 4 58 29 81 31 94 10 42 89 21 63 40 62 61 18 6 84 72 48 25 67 69 71 85 98 34 83 70 65 78 91 77 93 41 23 24 87 11 55 12 59 73 36 97 7 14 26 39 30 27 45 20 50 17 53 2 57 47 95 56 75 19 37 96 16 35 8 3 76 60 13 86 5 32 64 80 46 51 54 100 1 22 52 92", "output": "97 72 84 17 89 32 61 83 15 23 54 56 87 62 4 81 70 31 78 68 26 98 51 52 36 63 66 7 19 65 21 90 8 42 82 59 79 14 64 28 50 24 5 2 67 93 74 35 11 69 94 99 71 95 55 76 73 18 57 86 30 29 27 91 45 1 37 12 38 44 39 34 58 16 77 85 48 46 6 92 20 13 43 33 40 88 53 9 25 10 47 100 49 22 75 80 60 41 3 96" }, { "input": "99\n3 73 32 37 25 15 93 63 85 8 91 78 80 5 39 48 46 7 83 70 23 96 9 29 77 53 30 20 56 50 13 45 21 76 87 99 65 31 16 18 14 72 51 28 43 2 81 34 38 40 66 54 74 26 71 4 61 17 58 24 22 33 49 36 42 11 12 55 60 27 62 90 79 92 94 68 1 52 84 41 86 35 69 75 47 10 64 88 97 98 67 19 89 95 59 82 57 44 6", "output": "77 46 1 56 14 99 18 10 23 86 66 67 31 41 6 39 58 40 92 28 33 61 21 60 5 54 70 44 24 27 38 3 62 48 82 64 4 49 15 50 80 65 45 98 32 17 85 16 63 30 43 78 26 52 68 29 97 59 95 69 57 71 8 87 37 51 91 76 83 20 55 42 2 53 84 34 25 12 73 13 47 96 19 79 9 81 35 88 93 72 11 74 7 75 94 22 89 90 36" }, { "input": "100\n100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1", "output": "100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1" } ]

1,695,301,080

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

30

0

n = int(input()) s = list(map(int, input().split())) m = s.index(1) g = '' for i in range(m, n): g += str(s[i])+' ' for i in range(m): g += str(s[i])+' ' print(g)

Title: Presents Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Petya very much likes gifts. Recently he has received a new laptop as a New Year gift from his mother. He immediately decided to give it to somebody else as what can be more pleasant than giving somebody gifts. And on this occasion he organized a New Year party at his place and invited *n* his friends there. If there's one thing Petya likes more that receiving gifts, that's watching others giving gifts to somebody else. Thus, he safely hid the laptop until the next New Year and made up his mind to watch his friends exchanging gifts while he does not participate in the process. He numbered all his friends with integers from 1 to *n*. Petya remembered that a friend number *i* gave a gift to a friend number *p**i*. He also remembered that each of his friends received exactly one gift. Now Petya wants to know for each friend *i* the number of a friend who has given him a gift. Input Specification: The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the quantity of friends Petya invited to the party. The second line contains *n* space-separated integers: the *i*-th number is *p**i* — the number of a friend who gave a gift to friend number *i*. It is guaranteed that each friend received exactly one gift. It is possible that some friends do not share Petya's ideas of giving gifts to somebody else. Those friends gave the gifts to themselves. Output Specification: Print *n* space-separated integers: the *i*-th number should equal the number of the friend who gave a gift to friend number *i*. Demo Input: ['4\n2 3 4 1\n', '3\n1 3 2\n', '2\n1 2\n'] Demo Output: ['4 1 2 3\n', '1 3 2\n', '1 2\n'] Note: none

```python n = int(input()) s = list(map(int, input().split())) m = s.index(1) g = '' for i in range(m, n): g += str(s[i])+' ' for i in range(m): g += str(s[i])+' ' print(g) ```

0

224

B

Array

PROGRAMMING

1,500

[ "bitmasks", "implementation", "two pointers" ]

null

You've got an array *a*, consisting of *n* integers: *a*1,<=*a*2,<=...,<=*a**n*. Your task is to find a minimal by inclusion segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*) such, that among numbers *a**l*,<= *a**l*<=+<=1,<= ...,<= *a**r* there are exactly *k* distinct numbers. Segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*; *l*,<=*r* are integers) of length *m*<==<=*r*<=-<=*l*<=+<=1, satisfying the given property, is called minimal by inclusion, if there is no segment [*x*,<=*y*] satisfying the property and less then *m* in length, such that 1<=≤<=*l*<=≤<=*x*<=≤<=*y*<=≤<=*r*<=≤<=*n*. Note that the segment [*l*,<=*r*] doesn't have to be minimal in length among all segments, satisfying the given property.

The first line contains two space-separated integers: *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=105). The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* — elements of the array *a* (1<=≤<=*a**i*<=≤<=105).

Print a space-separated pair of integers *l* and *r* (1<=≤<=*l*<=≤<=*r*<=≤<=*n*) such, that the segment [*l*,<=*r*] is the answer to the problem. If the sought segment does not exist, print "-1 -1" without the quotes. If there are multiple correct answers, print any of them.

[ "4 2\n1 2 2 3\n", "8 3\n1 1 2 2 3 3 4 5\n", "7 4\n4 7 7 4 7 4 7\n" ]

[ "1 2\n", "2 5\n", "-1 -1\n" ]

In the first sample among numbers *a*1 and *a*2 there are exactly two distinct numbers. In the second sample segment [2, 5] is a minimal by inclusion segment with three distinct numbers, but it is not minimal in length among such segments. In the third sample there is no segment with four distinct numbers.

1,000

[ { "input": "4 2\n1 2 2 3", "output": "1 2" }, { "input": "8 3\n1 1 2 2 3 3 4 5", "output": "2 5" }, { "input": "7 4\n4 7 7 4 7 4 7", "output": "-1 -1" }, { "input": "5 1\n1 7 2 3 2", "output": "1 1" }, { "input": "1 2\n666", "output": "-1 -1" }, { "input": "1 1\n5", "output": "1 1" }, { "input": "10 4\n1 1 2 2 3 3 4 4 4 4", "output": "2 7" }, { "input": "4 2\n3 3 4 3", "output": "2 3" }, { "input": "4 3\n4 4 4 2", "output": "-1 -1" }, { "input": "10 5\n15 17 2 13 3 16 4 5 9 12", "output": "1 5" }, { "input": "17 13\n34 15 156 11 183 147 192 112 145 30 88 37 1 98 3 162 148", "output": "1 13" }, { "input": "17 14\n271 158 573 88 792 767 392 646 392 392 271 549 402 767 573 925 796", "output": "-1 -1" }, { "input": "8 5\n1 2 1 1 2 3 4 5", "output": "4 8" }, { "input": "7 3\n2 1 2 2 1 2 3", "output": "5 7" }, { "input": "6 3\n1 3 1 1 4 5", "output": "2 5" }, { "input": "5 3\n1 2 1 1 3", "output": "2 5" }, { "input": "9 3\n1 2 1 2 1 2 2 3 1", "output": "5 8" }, { "input": "4 3\n1 2 1 3", "output": "2 4" }, { "input": "5 3\n1 3 1 3 4", "output": "3 5" }, { "input": "6 3\n1 3 3 1 4 4", "output": "3 5" }, { "input": "5 3\n1 2 1 2 3", "output": "3 5" }, { "input": "8 4\n1 2 3 2 1 2 3 4", "output": "5 8" }, { "input": "10 4\n1 2 3 1 2 3 4 3 2 1", "output": "4 7" }, { "input": "10 3\n1 1 1 2 1 2 3 3 3 4", "output": "5 7" }, { "input": "10 3\n1 1 2 1 2 2 3 4 5 6", "output": "4 7" } ]

1,588,510,074

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

11

2,000

1,843,200

n,k=map(int, input().split()) a=list(map(int, input().split()))[:n] b=[] c=[] r=1 l=1 if(len(set(a))<k): print(-1,-1) else: for i in range (0,n): b.append(a[i]) if(len(set(b))==k): l=i+1 break for i in range (l-1,-1,-1): c.append(b[i]) if(len(set(c))==k): r=i+1 break print (r,l)

Title: Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: You've got an array *a*, consisting of *n* integers: *a*1,<=*a*2,<=...,<=*a**n*. Your task is to find a minimal by inclusion segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*) such, that among numbers *a**l*,<= *a**l*<=+<=1,<= ...,<= *a**r* there are exactly *k* distinct numbers. Segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*; *l*,<=*r* are integers) of length *m*<==<=*r*<=-<=*l*<=+<=1, satisfying the given property, is called minimal by inclusion, if there is no segment [*x*,<=*y*] satisfying the property and less then *m* in length, such that 1<=≤<=*l*<=≤<=*x*<=≤<=*y*<=≤<=*r*<=≤<=*n*. Note that the segment [*l*,<=*r*] doesn't have to be minimal in length among all segments, satisfying the given property. Input Specification: The first line contains two space-separated integers: *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=105). The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* — elements of the array *a* (1<=≤<=*a**i*<=≤<=105). Output Specification: Print a space-separated pair of integers *l* and *r* (1<=≤<=*l*<=≤<=*r*<=≤<=*n*) such, that the segment [*l*,<=*r*] is the answer to the problem. If the sought segment does not exist, print "-1 -1" without the quotes. If there are multiple correct answers, print any of them. Demo Input: ['4 2\n1 2 2 3\n', '8 3\n1 1 2 2 3 3 4 5\n', '7 4\n4 7 7 4 7 4 7\n'] Demo Output: ['1 2\n', '2 5\n', '-1 -1\n'] Note: In the first sample among numbers *a*1 and *a*2 there are exactly two distinct numbers. In the second sample segment [2, 5] is a minimal by inclusion segment with three distinct numbers, but it is not minimal in length among such segments. In the third sample there is no segment with four distinct numbers.

```python n,k=map(int, input().split()) a=list(map(int, input().split()))[:n] b=[] c=[] r=1 l=1 if(len(set(a))<k): print(-1,-1) else: for i in range (0,n): b.append(a[i]) if(len(set(b))==k): l=i+1 break for i in range (l-1,-1,-1): c.append(b[i]) if(len(set(c))==k): r=i+1 break print (r,l) ```

0

446

A

DZY Loves Sequences

PROGRAMMING

1,600

[ "dp", "implementation", "two pointers" ]

null

DZY has a sequence *a*, consisting of *n* integers. We'll call a sequence *a**i*,<=*a**i*<=+<=1,<=...,<=*a**j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) a subsegment of the sequence *a*. The value (*j*<=-<=*i*<=+<=1) denotes the length of the subsegment. Your task is to find the longest subsegment of *a*, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing. You only need to output the length of the subsegment you find.

The first line contains integer *n* (1<=≤<=*n*<=≤<=105). The next line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109).

In a single line print the answer to the problem — the maximum length of the required subsegment.

[ "6\n7 2 3 1 5 6\n" ]

[ "5\n" ]

You can choose subsegment *a*2, *a*3, *a*4, *a*5, *a*6 and change its 3rd element (that is *a*4) to 4.

500

[ { "input": "6\n7 2 3 1 5 6", "output": "5" }, { "input": "10\n424238336 649760493 681692778 714636916 719885387 804289384 846930887 957747794 596516650 189641422", "output": "9" }, { "input": "50\n804289384 846930887 681692778 714636916 957747794 424238336 719885387 649760493 596516650 189641422 25202363 350490028 783368691 102520060 44897764 967513927 365180541 540383427 304089173 303455737 35005212 521595369 294702568 726956430 336465783 861021531 59961394 89018457 101513930 125898168 131176230 145174068 233665124 278722863 315634023 369133070 468703136 628175012 635723059 653377374 656478043 801979803 859484422 914544920 608413785 756898538 734575199 973594325 149798316 38664371", "output": "19" }, { "input": "1\n1", "output": "1" }, { "input": "2\n1000000000 1000000000", "output": "2" }, { "input": "5\n1 2 3 4 1", "output": "5" }, { "input": "10\n1 2 3 4 5 5 6 7 8 9", "output": "6" }, { "input": "5\n1 1 1 1 1", "output": "2" }, { "input": "5\n1 1 2 3 4", "output": "5" }, { "input": "5\n1 2 3 1 6", "output": "5" }, { "input": "1\n42", "output": "1" }, { "input": "5\n1 2 42 3 4", "output": "4" }, { "input": "5\n1 5 9 6 10", "output": "4" }, { "input": "5\n5 2 3 4 5", "output": "5" }, { "input": "3\n2 1 3", "output": "3" }, { "input": "5\n1 2 3 3 4", "output": "4" }, { "input": "8\n1 2 3 4 1 5 6 7", "output": "5" }, { "input": "1\n3", "output": "1" }, { "input": "3\n5 1 2", "output": "3" }, { "input": "4\n1 4 3 4", "output": "4" }, { "input": "6\n7 2 12 4 5 6", "output": "5" }, { "input": "6\n7 2 3 1 4 5", "output": "4" }, { "input": "6\n2 3 5 5 6 7", "output": "6" }, { "input": "5\n2 4 7 6 8", "output": "5" }, { "input": "3\n3 1 2", "output": "3" }, { "input": "3\n1 1 2", "output": "3" }, { "input": "2\n1 2", "output": "2" }, { "input": "5\n4 1 2 3 4", "output": "5" }, { "input": "20\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 3 4 5 6", "output": "7" }, { "input": "4\n1 2 1 3", "output": "3" }, { "input": "4\n4 3 1 2", "output": "3" }, { "input": "6\n1 2 2 3 4 5", "output": "5" }, { "input": "4\n1 1 1 2", "output": "3" }, { "input": "4\n5 1 2 3", "output": "4" }, { "input": "5\n9 1 2 3 4", "output": "5" }, { "input": "2\n1 1", "output": "2" }, { "input": "5\n1 3 2 4 5", "output": "4" }, { "input": "6\n1 2 1 2 4 5", "output": "5" }, { "input": "10\n1 1 5 3 2 9 9 7 7 6", "output": "3" }, { "input": "6\n1 2 3 100000 100 101", "output": "6" }, { "input": "4\n3 3 3 4", "output": "3" }, { "input": "3\n4 3 5", "output": "3" }, { "input": "5\n1 3 2 3 4", "output": "4" }, { "input": "10\n1 2 3 4 5 10 10 11 12 13", "output": "10" }, { "input": "7\n11 2 1 2 13 4 14", "output": "5" }, { "input": "3\n5 1 3", "output": "3" }, { "input": "4\n1 5 3 4", "output": "4" }, { "input": "10\n1 2 3 4 100 6 7 8 9 10", "output": "10" }, { "input": "3\n5 3 5", "output": "3" }, { "input": "5\n100 100 7 8 9", "output": "4" }, { "input": "5\n1 2 3 4 5", "output": "5" }, { "input": "5\n1 2 4 4 5", "output": "5" }, { "input": "6\n7 4 5 6 7 8", "output": "6" }, { "input": "9\n3 4 1 6 3 4 5 6 7", "output": "7" }, { "input": "3\n1000 1 2", "output": "3" }, { "input": "3\n20 1 9", "output": "3" }, { "input": "6\n7 2 3 1 4 6", "output": "4" }, { "input": "3\n100 5 10", "output": "3" }, { "input": "4\n2 2 2 3", "output": "3" }, { "input": "6\n4 2 8 1 2 5", "output": "4" }, { "input": "3\n25 1 6", "output": "3" }, { "input": "10\n17 99 23 72 78 36 5 43 95 9", "output": "5" }, { "input": "7\n21 16 22 21 11 13 19", "output": "4" }, { "input": "5\n1 2 5 3 4", "output": "4" }, { "input": "6\n2 2 2 3 4 5", "output": "5" }, { "input": "5\n1 3 1 2 3", "output": "4" }, { "input": "3\n81 33 64", "output": "3" }, { "input": "7\n14 3 3 19 13 19 15", "output": "4" }, { "input": "9\n1 2 3 4 5 42 7 8 9", "output": "9" }, { "input": "5\n2 3 7 5 6", "output": "5" }, { "input": "5\n1 3 3 4 5", "output": "5" }, { "input": "6\n1 5 4 3 4 5", "output": "4" } ]

1,413,292,776

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

31

0

n = int(input()) a = list(map(int, input().split())) ar = [0] * len(a) for i in range(len(a)): m = -1000000 for j in range(i): if a[j] != a[i] - 1 and a[j] != a[i] + 1: if m < ar[j]: m = ar[j] if m < -10000: ar[i] = a[i] else: ar[i] = m + a[i] print(max(ar))

Title: DZY Loves Sequences Time Limit: None seconds Memory Limit: None megabytes Problem Description: DZY has a sequence *a*, consisting of *n* integers. We'll call a sequence *a**i*,<=*a**i*<=+<=1,<=...,<=*a**j* (1<=≤<=*i*<=≤<=*j*<=≤<=*n*) a subsegment of the sequence *a*. The value (*j*<=-<=*i*<=+<=1) denotes the length of the subsegment. Your task is to find the longest subsegment of *a*, such that it is possible to change at most one number (change one number to any integer you want) from the subsegment to make the subsegment strictly increasing. You only need to output the length of the subsegment you find. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=105). The next line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109). Output Specification: In a single line print the answer to the problem — the maximum length of the required subsegment. Demo Input: ['6\n7 2 3 1 5 6\n'] Demo Output: ['5\n'] Note: You can choose subsegment *a*2, *a*3, *a*4, *a*5, *a*6 and change its 3rd element (that is *a*4) to 4.

```python n = int(input()) a = list(map(int, input().split())) ar = [0] * len(a) for i in range(len(a)): m = -1000000 for j in range(i): if a[j] != a[i] - 1 and a[j] != a[i] + 1: if m < ar[j]: m = ar[j] if m < -10000: ar[i] = a[i] else: ar[i] = m + a[i] print(max(ar)) ```

0

855

A

Tom Riddle's Diary

PROGRAMMING

800

[ "brute force", "implementation", "strings" ]

null

Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they are not under its influence. He has names of *n* people who possessed the diary in order. You need to tell, for each person, if he/she possessed the diary at some point before or not. Formally, for a name *s**i* in the *i*-th line, output "YES" (without quotes) if there exists an index *j* such that *s**i*<==<=*s**j* and *j*<=<<=*i*, otherwise, output "NO" (without quotes).

First line of input contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of names in the list. Next *n* lines each contain a string *s**i*, consisting of lowercase English letters. The length of each string is between 1 and 100.

Output *n* lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not. You can print each letter in any case (upper or lower).

[ "6\ntom\nlucius\nginny\nharry\nginny\nharry\n", "3\na\na\na\n" ]

[ "NO\nNO\nNO\nNO\nYES\nYES\n", "NO\nYES\nYES\n" ]

In test case 1, for *i* = 5 there exists *j* = 3 such that *s**i* = *s**j* and *j* < *i*, which means that answer for *i* = 5 is "YES".

500

[ { "input": "6\ntom\nlucius\nginny\nharry\nginny\nharry", "output": "NO\nNO\nNO\nNO\nYES\nYES" }, { "input": "3\na\na\na", "output": "NO\nYES\nYES" }, { "input": "1\nzn", "output": "NO" }, { "input": "9\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nhrtm\nssjqvixduertmotgagizamvfucfwtxqnhuowbqbzctgznivehelpcyigwrbbdsxnewfqvcf\nhyrtxvozpbveexfkgalmguozzakitjiwsduqxonb\nwcyxteiwtcyuztaguilqpbiwcwjaiq\nwcyxteiwtcyuztaguilqpbiwcwjaiq\nbdbivqzvhggth", "output": "NO\nYES\nYES\nNO\nNO\nNO\nNO\nYES\nNO" }, { "input": "10\nkkiubdktydpdcbbttwpfdplhhjhrpqmpg\nkkiubdktydpdcbbttwpfdplhhjhrpqmpg\nmvutw\nqooeqoxzxwetlpecqiwgdbogiqqulttysyohwhzxzphvsfmnplizxoebzcvvfyppqbhxjksuzepuezqqzxlfmdanoeaoqmor\nmvutw\nvchawxjoreboqzuklifv\nvchawxjoreboqzuklifv\nnivijte\nrflybruq\nvchawxjoreboqzuklifv", "output": "NO\nYES\nNO\nNO\nYES\nNO\nYES\nNO\nNO\nYES" }, { "input": "1\nz", "output": "NO" }, { "input": "9\nl\ny\nm\nj\nn\nr\nj\nk\nf", "output": "NO\nNO\nNO\nNO\nNO\nNO\nYES\nNO\nNO" }, { "input": "14\nw\na\nh\np\nk\nw\ny\nv\ns\nf\nx\nd\nk\nr", "output": "NO\nNO\nNO\nNO\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nNO" }, { "input": "25\np\nk\nu\nl\nf\nt\nc\ns\nq\nd\nb\nq\no\ni\ni\nd\ni\nw\nn\ng\nw\nt\na\ne\ni", "output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nNO\nNO\nYES\nYES\nYES\nNO\nNO\nNO\nYES\nYES\nNO\nNO\nYES" }, { "input": "20\nd\nh\ng\no\np\ne\nt\nj\nv\ni\nt\nh\ns\ni\nw\nf\nx\na\nl\ni", "output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nYES\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nYES" }, { "input": "3\nbbbbbbb\nbbbbbbbbb\nbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "NO\nNO\nNO" }, { "input": "2\nab\nba", "output": "NO\nNO" }, { "input": "6\ntom\nlucius\nginnys\nharpy\nginny\nharry", "output": "NO\nNO\nNO\nNO\nNO\nNO" }, { "input": "2\nabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde\nabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde", "output": "NO\nYES" }, { "input": "42\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na", "output": "NO\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES" } ]

1,606,730,484

2,147,483,647

Python 3

OK

TESTS

55

109

0

numberOfpeople=int(input()) names=[] for i in range(numberOfpeople): letters=input() names.append(letters) for i in range(numberOfpeople): if all(names[j]!=names[i] for j in range(i-1,-1,-1)): print("NO") else: print("YES")

Title: Tom Riddle's Diary Time Limit: None seconds Memory Limit: None megabytes Problem Description: Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they are not under its influence. He has names of *n* people who possessed the diary in order. You need to tell, for each person, if he/she possessed the diary at some point before or not. Formally, for a name *s**i* in the *i*-th line, output "YES" (without quotes) if there exists an index *j* such that *s**i*<==<=*s**j* and *j*<=<<=*i*, otherwise, output "NO" (without quotes). Input Specification: First line of input contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of names in the list. Next *n* lines each contain a string *s**i*, consisting of lowercase English letters. The length of each string is between 1 and 100. Output Specification: Output *n* lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not. You can print each letter in any case (upper or lower). Demo Input: ['6\ntom\nlucius\nginny\nharry\nginny\nharry\n', '3\na\na\na\n'] Demo Output: ['NO\nNO\nNO\nNO\nYES\nYES\n', 'NO\nYES\nYES\n'] Note: In test case 1, for *i* = 5 there exists *j* = 3 such that *s**i* = *s**j* and *j* < *i*, which means that answer for *i* = 5 is "YES".

```python numberOfpeople=int(input()) names=[] for i in range(numberOfpeople): letters=input() names.append(letters) for i in range(numberOfpeople): if all(names[j]!=names[i] for j in range(i-1,-1,-1)): print("NO") else: print("YES") ```

3

149

A

Business trip

PROGRAMMING

900

[ "greedy", "implementation", "sortings" ]

null

What joy! Petya's parents went on a business trip for the whole year and the playful kid is left all by himself. Petya got absolutely happy. He jumped on the bed and threw pillows all day long, until... Today Petya opened the cupboard and found a scary note there. His parents had left him with duties: he should water their favourite flower all year, each day, in the morning, in the afternoon and in the evening. "Wait a second!" — thought Petya. He know for a fact that if he fulfills the parents' task in the *i*-th (1<=≤<=*i*<=≤<=12) month of the year, then the flower will grow by *a**i* centimeters, and if he doesn't water the flower in the *i*-th month, then the flower won't grow this month. Petya also knows that try as he might, his parents won't believe that he has been watering the flower if it grows strictly less than by *k* centimeters. Help Petya choose the minimum number of months when he will water the flower, given that the flower should grow no less than by *k* centimeters.

The first line contains exactly one integer *k* (0<=≤<=*k*<=≤<=100). The next line contains twelve space-separated integers: the *i*-th (1<=≤<=*i*<=≤<=12) number in the line represents *a**i* (0<=≤<=*a**i*<=≤<=100).

Print the only integer — the minimum number of months when Petya has to water the flower so that the flower grows no less than by *k* centimeters. If the flower can't grow by *k* centimeters in a year, print -1.

[ "5\n1 1 1 1 2 2 3 2 2 1 1 1\n", "0\n0 0 0 0 0 0 0 1 1 2 3 0\n", "11\n1 1 4 1 1 5 1 1 4 1 1 1\n" ]

[ "2\n", "0\n", "3\n" ]

Let's consider the first sample test. There it is enough to water the flower during the seventh and the ninth month. Then the flower grows by exactly five centimeters. In the second sample Petya's parents will believe him even if the flower doesn't grow at all (*k* = 0). So, it is possible for Petya not to water the flower at all.

500

[ { "input": "5\n1 1 1 1 2 2 3 2 2 1 1 1", "output": "2" }, { "input": "0\n0 0 0 0 0 0 0 1 1 2 3 0", "output": "0" }, { "input": "11\n1 1 4 1 1 5 1 1 4 1 1 1", "output": "3" }, { "input": "15\n20 1 1 1 1 2 2 1 2 2 1 1", "output": "1" }, { "input": "7\n8 9 100 12 14 17 21 10 11 100 23 10", "output": "1" }, { "input": "52\n1 12 3 11 4 5 10 6 9 7 8 2", "output": "6" }, { "input": "50\n2 2 3 4 5 4 4 5 7 3 2 7", "output": "-1" }, { "input": "0\n55 81 28 48 99 20 67 95 6 19 10 93", "output": "0" }, { "input": "93\n85 40 93 66 92 43 61 3 64 51 90 21", "output": "1" }, { "input": "99\n36 34 22 0 0 0 52 12 0 0 33 47", "output": "2" }, { "input": "99\n28 32 31 0 10 35 11 18 0 0 32 28", "output": "3" }, { "input": "99\n19 17 0 1 18 11 29 9 29 22 0 8", "output": "4" }, { "input": "76\n2 16 11 10 12 0 20 4 4 14 11 14", "output": "5" }, { "input": "41\n2 1 7 7 4 2 4 4 9 3 10 0", "output": "6" }, { "input": "47\n8 2 2 4 3 1 9 4 2 7 7 8", "output": "7" }, { "input": "58\n6 11 7 0 5 6 3 9 4 9 5 1", "output": "8" }, { "input": "32\n5 2 4 1 5 0 5 1 4 3 0 3", "output": "9" }, { "input": "31\n6 1 0 4 4 5 1 0 5 3 2 0", "output": "9" }, { "input": "35\n2 3 0 0 6 3 3 4 3 5 0 6", "output": "9" }, { "input": "41\n3 1 3 4 3 6 6 1 4 4 0 6", "output": "11" }, { "input": "97\n0 5 3 12 10 16 22 8 21 17 21 10", "output": "5" }, { "input": "100\n21 21 0 0 4 13 0 26 0 0 0 15", "output": "6" }, { "input": "100\n0 0 16 5 22 0 5 0 25 0 14 13", "output": "7" }, { "input": "97\n17 0 10 0 0 0 18 0 14 23 15 0", "output": "6" }, { "input": "100\n0 9 0 18 7 0 0 14 33 3 0 16", "output": "7" }, { "input": "95\n5 2 13 0 15 18 17 0 6 11 0 8", "output": "9" }, { "input": "94\n11 13 0 9 15 8 8 16 3 7 1 3", "output": "11" }, { "input": "96\n8 4 12 15 8 0 4 10 6 6 12 11", "output": "11" }, { "input": "100\n5 5 3 8 6 5 0 3 3 8 1 3", "output": "-1" }, { "input": "100\n1 0 0 1 1 0 1 1 1 1 2 1", "output": "-1" }, { "input": "100\n6 3 2 0 4 1 2 2 2 2 1 1", "output": "-1" }, { "input": "0\n0 0 0 0 0 0 0 0 0 0 0 0", "output": "0" }, { "input": "100\n0 0 0 0 0 0 0 0 0 0 0 0", "output": "-1" }, { "input": "0\n100 100 100 100 100 100 100 100 100 100 100 100", "output": "0" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100", "output": "1" }, { "input": "12\n1 1 1 1 1 1 1 1 1 1 1 1", "output": "12" }, { "input": "13\n1 1 1 1 1 1 1 1 1 1 1 2", "output": "12" }, { "input": "15\n10 1 1 1 1 1 1 1 1 1 1 1", "output": "6" }, { "input": "1\n0 0 0 0 0 0 0 0 0 0 0 0", "output": "-1" } ]

1,647,872,765

2,147,483,647

Python 3

OK

TESTS

39

92

0

a=int(input()) b=list(map(int,input().split())) b.sort(reverse=True) x=0 y=0 for i in range(12): if x>=a: break x+=b[i] y+=1 if x<a: print(-1) else: print(y)

Title: Business trip Time Limit: None seconds Memory Limit: None megabytes Problem Description: What joy! Petya's parents went on a business trip for the whole year and the playful kid is left all by himself. Petya got absolutely happy. He jumped on the bed and threw pillows all day long, until... Today Petya opened the cupboard and found a scary note there. His parents had left him with duties: he should water their favourite flower all year, each day, in the morning, in the afternoon and in the evening. "Wait a second!" — thought Petya. He know for a fact that if he fulfills the parents' task in the *i*-th (1<=≤<=*i*<=≤<=12) month of the year, then the flower will grow by *a**i* centimeters, and if he doesn't water the flower in the *i*-th month, then the flower won't grow this month. Petya also knows that try as he might, his parents won't believe that he has been watering the flower if it grows strictly less than by *k* centimeters. Help Petya choose the minimum number of months when he will water the flower, given that the flower should grow no less than by *k* centimeters. Input Specification: The first line contains exactly one integer *k* (0<=≤<=*k*<=≤<=100). The next line contains twelve space-separated integers: the *i*-th (1<=≤<=*i*<=≤<=12) number in the line represents *a**i* (0<=≤<=*a**i*<=≤<=100). Output Specification: Print the only integer — the minimum number of months when Petya has to water the flower so that the flower grows no less than by *k* centimeters. If the flower can't grow by *k* centimeters in a year, print -1. Demo Input: ['5\n1 1 1 1 2 2 3 2 2 1 1 1\n', '0\n0 0 0 0 0 0 0 1 1 2 3 0\n', '11\n1 1 4 1 1 5 1 1 4 1 1 1\n'] Demo Output: ['2\n', '0\n', '3\n'] Note: Let's consider the first sample test. There it is enough to water the flower during the seventh and the ninth month. Then the flower grows by exactly five centimeters. In the second sample Petya's parents will believe him even if the flower doesn't grow at all (*k* = 0). So, it is possible for Petya not to water the flower at all.

```python a=int(input()) b=list(map(int,input().split())) b.sort(reverse=True) x=0 y=0 for i in range(12): if x>=a: break x+=b[i] y+=1 if x<a: print(-1) else: print(y) ```

3

169

A

Chores

PROGRAMMING

800

[ "sortings" ]

null

Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of the *i*-th chore equals *h**i*. As Petya is older, he wants to take the chores with complexity larger than some value *x* (*h**i*<=><=*x*) to leave to Vasya the chores with complexity less than or equal to *x* (*h**i*<=≤<=*x*). The brothers have already decided that Petya will do exactly *a* chores and Vasya will do exactly *b* chores (*a*<=+<=*b*<==<=*n*). In how many ways can they choose an integer *x* so that Petya got exactly *a* chores and Vasya got exactly *b* chores?

The first input line contains three integers *n*,<=*a* and *b* (2<=≤<=*n*<=≤<=2000; *a*,<=*b*<=≥<=1; *a*<=+<=*b*<==<=*n*) — the total number of chores, the number of Petya's chores and the number of Vasya's chores. The next line contains a sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109), *h**i* is the complexity of the *i*-th chore. The numbers in the given sequence are not necessarily different. All numbers on the lines are separated by single spaces.

Print the required number of ways to choose an integer value of *x*. If there are no such ways, print 0.

[ "5 2 3\n6 2 3 100 1\n", "7 3 4\n1 1 9 1 1 1 1\n" ]

[ "3\n", "0\n" ]

In the first sample the possible values of *x* are 3, 4 or 5. In the second sample it is impossible to find such *x*, that Petya got 3 chores and Vasya got 4.

500

[ { "input": "5 2 3\n6 2 3 100 1", "output": "3" }, { "input": "7 3 4\n1 1 9 1 1 1 1", "output": "0" }, { "input": "2 1 1\n10 2", "output": "8" }, { "input": "2 1 1\n7 7", "output": "0" }, { "input": "2 1 1\n1 1000000000", "output": "999999999" }, { "input": "3 1 2\n6 5 5", "output": "1" }, { "input": "3 2 1\n10 10 8", "output": "2" }, { "input": "8 3 5\n42 55 61 72 83 10 22 33", "output": "6" }, { "input": "10 5 5\n1 2 3 4 5 999999999 999999998 999999997 999999996 999999995", "output": "999999990" }, { "input": "4 1 3\n10 8 7 3", "output": "2" }, { "input": "4 2 2\n402 10 10 402", "output": "392" }, { "input": "4 1 3\n10 402 402 10", "output": "0" }, { "input": "4 3 1\n100 100 200 200", "output": "0" }, { "input": "150 10 140\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "0" }, { "input": "102 101 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "0" } ]

1,662,426,322

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

2

31

0

n, a, b = (int(i) for i in input().split()) h = sorted(int(i) for i in input().split()) res = h[a + 1] - h[a] print(res)

Title: Chores Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of the *i*-th chore equals *h**i*. As Petya is older, he wants to take the chores with complexity larger than some value *x* (*h**i*<=><=*x*) to leave to Vasya the chores with complexity less than or equal to *x* (*h**i*<=≤<=*x*). The brothers have already decided that Petya will do exactly *a* chores and Vasya will do exactly *b* chores (*a*<=+<=*b*<==<=*n*). In how many ways can they choose an integer *x* so that Petya got exactly *a* chores and Vasya got exactly *b* chores? Input Specification: The first input line contains three integers *n*,<=*a* and *b* (2<=≤<=*n*<=≤<=2000; *a*,<=*b*<=≥<=1; *a*<=+<=*b*<==<=*n*) — the total number of chores, the number of Petya's chores and the number of Vasya's chores. The next line contains a sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109), *h**i* is the complexity of the *i*-th chore. The numbers in the given sequence are not necessarily different. All numbers on the lines are separated by single spaces. Output Specification: Print the required number of ways to choose an integer value of *x*. If there are no such ways, print 0. Demo Input: ['5 2 3\n6 2 3 100 1\n', '7 3 4\n1 1 9 1 1 1 1\n'] Demo Output: ['3\n', '0\n'] Note: In the first sample the possible values of *x* are 3, 4 or 5. In the second sample it is impossible to find such *x*, that Petya got 3 chores and Vasya got 4.

```python n, a, b = (int(i) for i in input().split()) h = sorted(int(i) for i in input().split()) res = h[a + 1] - h[a] print(res) ```

-1

337

A

Puzzles

PROGRAMMING

900

[ "greedy" ]

null

The end of the school year is near and Ms. Manana, the teacher, will soon have to say goodbye to a yet another class. She decided to prepare a goodbye present for her *n* students and give each of them a jigsaw puzzle (which, as wikipedia states, is a tiling puzzle that requires the assembly of numerous small, often oddly shaped, interlocking and tessellating pieces). The shop assistant told the teacher that there are *m* puzzles in the shop, but they might differ in difficulty and size. Specifically, the first jigsaw puzzle consists of *f*1 pieces, the second one consists of *f*2 pieces and so on. Ms. Manana doesn't want to upset the children, so she decided that the difference between the numbers of pieces in her presents must be as small as possible. Let *A* be the number of pieces in the largest puzzle that the teacher buys and *B* be the number of pieces in the smallest such puzzle. She wants to choose such *n* puzzles that *A*<=-<=*B* is minimum possible. Help the teacher and find the least possible value of *A*<=-<=*B*.

The first line contains space-separated integers *n* and *m* (2<=≤<=*n*<=≤<=*m*<=≤<=50). The second line contains *m* space-separated integers *f*1,<=*f*2,<=...,<=*f**m* (4<=≤<=*f**i*<=≤<=1000) — the quantities of pieces in the puzzles sold in the shop.

Print a single integer — the least possible difference the teacher can obtain.

[ "4 6\n10 12 10 7 5 22\n" ]

[ "5\n" ]

Sample 1. The class has 4 students. The shop sells 6 puzzles. If Ms. Manana buys the first four puzzles consisting of 10, 12, 10 and 7 pieces correspondingly, then the difference between the sizes of the largest and the smallest puzzle will be equal to 5. It is impossible to obtain a smaller difference. Note that the teacher can also buy puzzles 1, 3, 4 and 5 to obtain the difference 5.

500

[ { "input": "4 6\n10 12 10 7 5 22", "output": "5" }, { "input": "2 2\n4 4", "output": "0" }, { "input": "2 10\n4 5 6 7 8 9 10 11 12 12", "output": "0" }, { "input": "4 5\n818 136 713 59 946", "output": "759" }, { "input": "3 20\n446 852 783 313 549 965 40 88 86 617 479 118 768 34 47 826 366 957 463 903", "output": "13" }, { "input": "2 25\n782 633 152 416 432 825 115 97 386 357 836 310 530 413 354 373 847 882 913 682 729 582 671 674 94", "output": "3" }, { "input": "4 25\n226 790 628 528 114 64 239 279 619 39 894 763 763 847 525 93 882 697 999 643 650 244 159 884 190", "output": "31" }, { "input": "2 50\n971 889 628 39 253 157 925 694 129 516 660 272 738 319 611 816 142 717 514 392 41 105 132 676 958 118 306 768 600 685 103 857 704 346 857 309 23 718 618 161 176 379 846 834 640 468 952 878 164 997", "output": "0" }, { "input": "25 50\n582 146 750 905 313 509 402 21 488 512 32 898 282 64 579 869 37 996 377 929 975 697 666 837 311 205 116 992 533 298 648 268 54 479 792 595 152 69 267 417 184 433 894 603 988 712 24 414 301 176", "output": "412" }, { "input": "49 50\n58 820 826 960 271 294 473 102 925 318 729 672 244 914 796 646 868 6 893 882 726 203 528 498 271 195 355 459 721 680 547 147 631 116 169 804 145 996 133 559 110 257 771 476 576 251 607 314 427 886", "output": "938" }, { "input": "50 50\n374 573 323 744 190 806 485 247 628 336 491 606 702 321 991 678 337 579 86 240 993 208 668 686 855 205 363 177 719 249 896 919 782 434 59 647 787 996 286 216 636 212 546 903 958 559 544 126 608 993", "output": "937" }, { "input": "6 50\n6 8 7 8 5 4 4 5 7 8 6 5 7 4 7 7 7 8 6 4 6 6 8 8 7 7 8 7 5 8 5 4 4 7 8 4 4 6 6 6 8 7 4 7 6 6 5 8 4 7", "output": "0" }, { "input": "37 50\n14 5 11 17 8 20 19 16 20 11 17 20 16 9 14 14 13 18 11 20 8 8 8 5 19 17 6 18 10 20 9 7 12 6 14 17 4 4 10 13 7 4 11 6 20 19 12 12 15 19", "output": "12" }, { "input": "40 50\n4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4", "output": "0" }, { "input": "40 50\n17 20 43 26 41 37 14 8 30 35 30 24 43 8 42 9 41 50 41 35 27 32 35 43 28 36 31 16 5 7 23 16 14 29 8 39 12 16 36 18 49 39 33 37 38 6 6 27 23 17", "output": "31" }, { "input": "2 2\n1000 4", "output": "996" }, { "input": "2 3\n4 502 1000", "output": "498" }, { "input": "3 3\n4 1000 4", "output": "996" } ]

1,684,792,511

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

60

0

line1 = input().split(" ") line2 = input().split(" ") take = int(line1[0]) of = int(line1[1]) puzzleCount = [] for c in line2: puzzleCount.append(int(c)) puzzleCount = sorted(puzzleCount) min = 1000 curr = 1000 for c in range(0,of-take-1): curr = puzzleCount[c+take-1] - puzzleCount[c] if(curr < min): min = curr print(min)

Title: Puzzles Time Limit: None seconds Memory Limit: None megabytes Problem Description: The end of the school year is near and Ms. Manana, the teacher, will soon have to say goodbye to a yet another class. She decided to prepare a goodbye present for her *n* students and give each of them a jigsaw puzzle (which, as wikipedia states, is a tiling puzzle that requires the assembly of numerous small, often oddly shaped, interlocking and tessellating pieces). The shop assistant told the teacher that there are *m* puzzles in the shop, but they might differ in difficulty and size. Specifically, the first jigsaw puzzle consists of *f*1 pieces, the second one consists of *f*2 pieces and so on. Ms. Manana doesn't want to upset the children, so she decided that the difference between the numbers of pieces in her presents must be as small as possible. Let *A* be the number of pieces in the largest puzzle that the teacher buys and *B* be the number of pieces in the smallest such puzzle. She wants to choose such *n* puzzles that *A*<=-<=*B* is minimum possible. Help the teacher and find the least possible value of *A*<=-<=*B*. Input Specification: The first line contains space-separated integers *n* and *m* (2<=≤<=*n*<=≤<=*m*<=≤<=50). The second line contains *m* space-separated integers *f*1,<=*f*2,<=...,<=*f**m* (4<=≤<=*f**i*<=≤<=1000) — the quantities of pieces in the puzzles sold in the shop. Output Specification: Print a single integer — the least possible difference the teacher can obtain. Demo Input: ['4 6\n10 12 10 7 5 22\n'] Demo Output: ['5\n'] Note: Sample 1. The class has 4 students. The shop sells 6 puzzles. If Ms. Manana buys the first four puzzles consisting of 10, 12, 10 and 7 pieces correspondingly, then the difference between the sizes of the largest and the smallest puzzle will be equal to 5. It is impossible to obtain a smaller difference. Note that the teacher can also buy puzzles 1, 3, 4 and 5 to obtain the difference 5.

```python line1 = input().split(" ") line2 = input().split(" ") take = int(line1[0]) of = int(line1[1]) puzzleCount = [] for c in line2: puzzleCount.append(int(c)) puzzleCount = sorted(puzzleCount) min = 1000 curr = 1000 for c in range(0,of-take-1): curr = puzzleCount[c+take-1] - puzzleCount[c] if(curr < min): min = curr print(min) ```

0

none

0

[ "none" ]

null

An infinitely long railway has a train consisting of *n* cars, numbered from 1 to *n* (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?

The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of cars in the train. The second line contains *n* integers *p**i* (1<=≤<=*p**i*<=≤<=*n*, *p**i*<=≠<=*p**j* if *i*<=≠<=*j*) — the sequence of the numbers of the cars in the train.

Print a single integer — the minimum number of actions needed to sort the railway cars.

[ "5\n4 1 2 5 3\n", "4\n4 1 3 2\n" ]

[ "2\n", "2\n" ]

In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.

0

[ { "input": "5\n4 1 2 5 3", "output": "2" }, { "input": "4\n4 1 3 2", "output": "2" }, { "input": "1\n1", "output": "0" }, { "input": "2\n1 2", "output": "0" }, { "input": "2\n2 1", "output": "1" }, { "input": "6\n5 3 6 1 4 2", "output": "4" }, { "input": "7\n1 2 3 6 7 4 5", "output": "2" }, { "input": "8\n6 2 1 8 5 7 3 4", "output": "5" }, { "input": "3\n1 2 3", "output": "0" }, { "input": "3\n1 3 2", "output": "1" }, { "input": "3\n2 1 3", "output": "1" }, { "input": "3\n2 3 1", "output": "1" }, { "input": "3\n3 1 2", "output": "1" }, { "input": "3\n3 2 1", "output": "2" }, { "input": "7\n1 3 5 7 2 4 6", "output": "5" }, { "input": "7\n1 5 2 6 3 7 4", "output": "3" }, { "input": "5\n1 4 2 3 5", "output": "2" }, { "input": "9\n1 6 4 5 9 8 7 3 2", "output": "7" }, { "input": "10\n5 1 6 2 8 3 4 10 9 7", "output": "6" }, { "input": "50\n39 8 41 9 45 1 5 18 38 31 28 7 12 49 33 19 26 6 42 13 37 27 2 21 20 22 14 16 48 47 32 50 25 17 35 24 36 4 29 15 43 10 11 30 40 46 3 23 44 34", "output": "46" }, { "input": "50\n43 15 10 33 32 31 13 7 5 22 36 1 25 14 38 19 8 6 24 42 28 21 44 35 4 3 49 30 27 46 2 9 17 37 45 41 18 39 12 11 16 20 50 26 29 34 40 47 48 23", "output": "47" }, { "input": "50\n10 40 34 43 50 17 15 13 9 2 32 18 11 46 27 24 36 16 29 45 42 4 47 19 48 37 41 5 21 26 22 25 44 31 35 49 20 8 12 23 6 38 14 1 7 28 3 33 39 30", "output": "46" }, { "input": "50\n10 37 3 46 45 29 36 13 21 25 35 5 18 33 12 19 50 16 30 47 20 42 39 28 2 6 38 8 7 31 22 27 26 9 15 14 34 48 4 32 40 43 44 24 11 1 23 17 49 41", "output": "46" }, { "input": "50\n1 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 42 37 38 39 40 41 36 43 44 45 46 47 48 49 50", "output": "14" }, { "input": "50\n1 2 3 4 5 6 7 8 43 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 50 33 34 35 36 37 38 39 40 41 42 9 44 45 46 47 48 49 32", "output": "27" }, { "input": "50\n1 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 49 40 41 47 43 44 45 46 42 50 39 48", "output": "11" }, { "input": "50\n1 2 3 4 27 6 7 8 9 10 30 12 13 14 15 16 17 18 19 20 21 22 23 24 28 26 5 25 29 11 31 32 33 34 38 36 37 35 39 40 41 42 43 44 45 46 47 48 49 50", "output": "36" }, { "input": "50\n1 2 3 4 5 6 7 49 9 10 17 12 13 14 15 16 11 18 19 20 21 22 23 24 25 26 27 38 29 36 30 32 33 34 35 31 37 28 39 40 41 42 43 44 45 46 47 48 8 50", "output": "38" }, { "input": "50\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 31 18 19 20 21 23 22 24 25 26 27 28 29 49 17 32 33 34 39 36 37 38 47 44 41 42 43 40 45 46 35 48 30 50", "output": "33" }, { "input": "50\n1 2 15 4 5 6 7 8 9 10 11 12 13 14 3 16 17 18 19 32 21 22 36 28 23 26 27 24 29 30 31 20 33 34 37 25 35 38 40 39 41 42 43 44 45 46 47 48 49 50", "output": "39" }, { "input": "5\n4 3 1 2 5", "output": "3" }, { "input": "6\n1 3 5 6 4 2", "output": "4" }, { "input": "10\n2 1 4 3 6 5 8 7 10 9", "output": "8" }, { "input": "5\n1 2 4 5 3", "output": "2" }, { "input": "7\n1 4 2 3 7 6 5", "output": "4" }, { "input": "4\n3 1 2 4", "output": "2" }, { "input": "6\n2 5 4 3 6 1", "output": "4" }, { "input": "5\n1 3 4 5 2", "output": "2" }, { "input": "6\n2 4 6 5 1 3", "output": "4" }, { "input": "6\n1 2 4 5 6 3", "output": "3" }, { "input": "9\n9 8 7 4 5 6 3 2 1", "output": "6" }, { "input": "7\n4 1 2 3 6 5 7", "output": "4" } ]

1,484,686,753

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

9

2,000

11,980,800

def get_order(c, t): order = 0 i = 0 while i < len(c): if c[i] == t: order += 1 t += 1 i+=1 return order #c = [4,1,2,5,3] #n = len(c) n = int(input()) c = [int(i) for i in input().split(' ')] best = 0 i = 0 while i < n: order = get_order(c,i+1) if order > best: best = order i += order print(n - best)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: An infinitely long railway has a train consisting of *n* cars, numbered from 1 to *n* (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train? Input Specification: The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of cars in the train. The second line contains *n* integers *p**i* (1<=≤<=*p**i*<=≤<=*n*, *p**i*<=≠<=*p**j* if *i*<=≠<=*j*) — the sequence of the numbers of the cars in the train. Output Specification: Print a single integer — the minimum number of actions needed to sort the railway cars. Demo Input: ['5\n4 1 2 5 3\n', '4\n4 1 3 2\n'] Demo Output: ['2\n', '2\n'] Note: In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.

```python def get_order(c, t): order = 0 i = 0 while i < len(c): if c[i] == t: order += 1 t += 1 i+=1 return order #c = [4,1,2,5,3] #n = len(c) n = int(input()) c = [int(i) for i in input().split(' ')] best = 0 i = 0 while i < n: order = get_order(c,i+1) if order > best: best = order i += order print(n - best) ```

0

134

A

Average Numbers

PROGRAMMING

1,200

[ "brute force", "implementation" ]

null

You are given a sequence of positive integers *a*1,<=*a*2,<=...,<=*a**n*. Find all such indices *i*, that the *i*-th element equals the arithmetic mean of all other elements (that is all elements except for this one).

The first line contains the integer *n* (2<=≤<=*n*<=≤<=2·105). The second line contains elements of the sequence *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000). All the elements are positive integers.

Print on the first line the number of the sought indices. Print on the second line the sought indices in the increasing order. All indices are integers from 1 to *n*. If the sought elements do not exist, then the first output line should contain number 0. In this case you may either not print the second line or print an empty line.

[ "5\n1 2 3 4 5\n", "4\n50 50 50 50\n" ]

[ "1\n3 ", "4\n1 2 3 4 " ]

none

500

[ { "input": "5\n1 2 3 4 5", "output": "1\n3 " }, { "input": "4\n50 50 50 50", "output": "4\n1 2 3 4 " }, { "input": "3\n2 3 1", "output": "1\n1 " }, { "input": "2\n4 2", "output": "0" }, { "input": "2\n1 1", "output": "2\n1 2 " }, { "input": "10\n3 3 3 3 3 4 3 3 3 2", "output": "8\n1 2 3 4 5 7 8 9 " }, { "input": "10\n15 7 10 7 7 7 4 4 7 2", "output": "5\n2 4 5 6 9 " }, { "input": "6\n2 2 2 2 2 2", "output": "6\n1 2 3 4 5 6 " }, { "input": "6\n3 3 3 3 3 3", "output": "6\n1 2 3 4 5 6 " }, { "input": "4\n6 6 6 7", "output": "0" }, { "input": "2\n1 2", "output": "0" }, { "input": "3\n3 3 4", "output": "0" }, { "input": "5\n7 6 6 6 6", "output": "0" }, { "input": "4\n3 5 5 9", "output": "0" }, { "input": "3\n99 100 99", "output": "0" }, { "input": "4\n5 6 5 5", "output": "0" }, { "input": "6\n1 1 2 1 1 1", "output": "0" }, { "input": "2\n4 5", "output": "0" }, { "input": "4\n1 1 1 2", "output": "0" }, { "input": "3\n1 2 4", "output": "0" }, { "input": "6\n1 1 2 3 3 3", "output": "0" }, { "input": "4\n4 5 5 4", "output": "0" }, { "input": "3\n2 3 5", "output": "0" }, { "input": "3\n2 1 1", "output": "0" }, { "input": "3\n1 1 2", "output": "0" }, { "input": "4\n1 2 3 4", "output": "0" }, { "input": "5\n1 2 3 4 6", "output": "0" }, { "input": "3\n2 2 3", "output": "0" }, { "input": "4\n3 4 5 1", "output": "0" }, { "input": "3\n2 3 2", "output": "0" }, { "input": "3\n3 4 4", "output": "0" }, { "input": "3\n10 5 7", "output": "0" }, { "input": "3\n5 6 5", "output": "0" }, { "input": "4\n1 2 3 7", "output": "0" }, { "input": "5\n2 2 3 3 3", "output": "0" }, { "input": "3\n4 3 6", "output": "0" }, { "input": "3\n1 1 3", "output": "0" }, { "input": "15\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "15\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 " } ]

1,618,318,791

291

Python 3

OK

TESTS

58

405

13,926,400

n = int(input()) a = [int(c) for c in input().split()] k = sum(a) / len(a) b = [] for i in range(len(a)): if a[i] == k: b.append(i+1) print(len(b)) print(*b)

Title: Average Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a sequence of positive integers *a*1,<=*a*2,<=...,<=*a**n*. Find all such indices *i*, that the *i*-th element equals the arithmetic mean of all other elements (that is all elements except for this one). Input Specification: The first line contains the integer *n* (2<=≤<=*n*<=≤<=2·105). The second line contains elements of the sequence *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000). All the elements are positive integers. Output Specification: Print on the first line the number of the sought indices. Print on the second line the sought indices in the increasing order. All indices are integers from 1 to *n*. If the sought elements do not exist, then the first output line should contain number 0. In this case you may either not print the second line or print an empty line. Demo Input: ['5\n1 2 3 4 5\n', '4\n50 50 50 50\n'] Demo Output: ['1\n3 ', '4\n1 2 3 4 '] Note: none

```python n = int(input()) a = [int(c) for c in input().split()] k = sum(a) / len(a) b = [] for i in range(len(a)): if a[i] == k: b.append(i+1) print(len(b)) print(*b) ```

3

339

A

Helpful Maths

PROGRAMMING

800

[ "greedy", "implementation", "sortings", "strings" ]

null

Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation. The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3. You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum.

The first line contains a non-empty string *s* — the sum Xenia needs to count. String *s* contains no spaces. It only contains digits and characters "+". Besides, string *s* is a correct sum of numbers 1, 2 and 3. String *s* is at most 100 characters long.

Print the new sum that Xenia can count.

[ "3+2+1\n", "1+1+3+1+3\n", "2\n" ]

[ "1+2+3\n", "1+1+1+3+3\n", "2\n" ]

none

500

[ { "input": "3+2+1", "output": "1+2+3" }, { "input": "1+1+3+1+3", "output": "1+1+1+3+3" }, { "input": "2", "output": "2" }, { "input": "2+2+1+1+3", "output": "1+1+2+2+3" }, { "input": "2+1+2+2+2+3+1+3+1+2", "output": "1+1+1+2+2+2+2+2+3+3" }, { "input": "1+2+1+2+2+2+2+1+3+3", "output": "1+1+1+2+2+2+2+2+3+3" }, { "input": "2+3+3+1+2+2+2+1+1+2+1+3+2+2+3+3+2+2+3+3+3+1+1+1+3+3+3+2+1+3+2+3+2+1+1+3+3+3+1+2+2+1+2+2+1+2+1+3+1+1", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "1", "output": "1" }, { "input": "2+1+2+2+1+3+2+3+1+1+2+1+2+2+3+1+1+3+3+3+2+2+3+2+2+2+1+2+1+2+3+2+2+2+1+3+1+3+3+3+1+2+1+2+2+2+2+3+1+1", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "2+2+1+1+1+3+1+1+3+3+2+3+1+3+1+1+3+1+1+2+2+2+2+1+2+1+2+1+1+1+3+1+3+2+3+2+3+3+1+1+1+2+3+2+1+3+1+3+2+2", "output": "1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "3+2+3+3+2+2+1+2+1+2+3+1+2+3+2+3+2+1+2+2+1+1+2+2+3+2+1+3+1+1+3+2+2+2+2+3+3+2+2+3+3+1+1+2+3+3+2+3+3+3", "output": "1+1+1+1+1+1+1+1+1+1+1+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3" }, { "input": "3", "output": "3" }, { "input": "1+1", "output": "1+1" }, { "input": "1+2", "output": "1+2" }, { "input": "1+3", "output": "1+3" }, { "input": "2+1", "output": "1+2" }, { "input": "2+2", "output": "2+2" }, { "input": "2+3", "output": "2+3" }, { "input": "3+1", "output": "1+3" }, { "input": "3+2", "output": "2+3" }, { "input": "3+3", "output": "3+3" } ]

1,698,673,911

2,147,483,647

PyPy 3-64

OK

TESTS

21

124

0

x=input() l=list(map(str,x)) q=[] for i in range(len(l)): if l[i]!="+": q.append(int(l[i])) q.sort() print(*q,sep="+")

Title: Helpful Maths Time Limit: None seconds Memory Limit: None megabytes Problem Description: Xenia the beginner mathematician is a third year student at elementary school. She is now learning the addition operation. The teacher has written down the sum of multiple numbers. Pupils should calculate the sum. To make the calculation easier, the sum only contains numbers 1, 2 and 3. Still, that isn't enough for Xenia. She is only beginning to count, so she can calculate a sum only if the summands follow in non-decreasing order. For example, she can't calculate sum 1+3+2+1 but she can calculate sums 1+1+2 and 3+3. You've got the sum that was written on the board. Rearrange the summans and print the sum in such a way that Xenia can calculate the sum. Input Specification: The first line contains a non-empty string *s* — the sum Xenia needs to count. String *s* contains no spaces. It only contains digits and characters "+". Besides, string *s* is a correct sum of numbers 1, 2 and 3. String *s* is at most 100 characters long. Output Specification: Print the new sum that Xenia can count. Demo Input: ['3+2+1\n', '1+1+3+1+3\n', '2\n'] Demo Output: ['1+2+3\n', '1+1+1+3+3\n', '2\n'] Note: none

```python x=input() l=list(map(str,x)) q=[] for i in range(len(l)): if l[i]!="+": q.append(int(l[i])) q.sort() print(*q,sep="+") ```

3

71

A

Way Too Long Words

PROGRAMMING

800

[ "strings" ]

A. Way Too Long Words

1

256

Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.

Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.

[ "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n" ]

[ "word\nl10n\ni18n\np43s\n" ]

none

500

[ { "input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis", "output": "word\nl10n\ni18n\np43s" }, { "input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm", "output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m" }, { "input": "3\nnjfngnrurunrgunrunvurn\njfvnjfdnvjdbfvsbdubruvbubvkdb\nksdnvidnviudbvibd", "output": "n20n\nj27b\nk15d" }, { "input": "1\ntcyctkktcctrcyvbyiuhihhhgyvyvyvyvjvytchjckt", "output": "t41t" }, { "input": "24\nyou\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nunofficially\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings", "output": "you\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nu10y\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings" }, { "input": "1\na", "output": "a" }, { "input": "26\na\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz", "output": "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz" }, { "input": "1\nabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij", "output": "a98j" }, { "input": "10\ngyartjdxxlcl\nfzsck\nuidwu\nxbymclornemdmtj\nilppyoapitawgje\ncibzc\ndrgbeu\nhezplmsdekhhbo\nfeuzlrimbqbytdu\nkgdco", "output": "g10l\nfzsck\nuidwu\nx13j\ni13e\ncibzc\ndrgbeu\nh12o\nf13u\nkgdco" }, { "input": "20\nlkpmx\nkovxmxorlgwaomlswjxlpnbvltfv\nhykasjxqyjrmybejnmeumzha\ntuevlumpqbbhbww\nqgqsphvrmupxxc\ntrissbaf\nqfgrlinkzvzqdryckaizutd\nzzqtoaxkvwoscyx\noswytrlnhpjvvnwookx\nlpuzqgec\ngyzqfwxggtvpjhzmzmdw\nrlxjgmvdftvrmvbdwudra\nvsntnjpepnvdaxiporggmglhagv\nxlvcqkqgcrbgtgglj\nlyxwxbiszyhlsrgzeedzprbmcpduvq\nyrmqqvrkqskqukzqrwukpsifgtdc\nxpuohcsjhhuhvr\nvvlfrlxpvqejngwrbfbpmqeirxlw\nsvmasocxdvadmaxtrpakysmeaympy\nyuflqboqfdt", "output": "lkpmx\nk26v\nh22a\nt13w\nq12c\ntrissbaf\nq21d\nz13x\no17x\nlpuzqgec\ng18w\nr19a\nv25v\nx15j\nl28q\ny26c\nx12r\nv26w\ns27y\ny9t" }, { "input": "100\nm\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr", "output": "m\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr" } ]

1,680,967,674

2,147,483,647

Python 3

OK

TESTS

20

46

0

n = int(input()) for i in range(n): string = input() len_string = len(string) if len_string > 10: new_string = f"{string[0]}{len_string - 2}{string[-1]}" print(new_string) else: print(string)

Title: Way Too Long Words Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters. Output Specification: Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data. Demo Input: ['4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n'] Demo Output: ['word\nl10n\ni18n\np43s\n'] Note: none

```python n = int(input()) for i in range(n): string = input() len_string = len(string) if len_string > 10: new_string = f"{string[0]}{len_string - 2}{string[-1]}" print(new_string) else: print(string) ```

3.977

295

D

Greg and Caves

PROGRAMMING

2,400

[ "combinatorics", "dp" ]

null

Greg has a pad. The pad's screen is an *n*<=×<=*m* rectangle, each cell can be either black or white. We'll consider the pad rows to be numbered with integers from 1 to *n* from top to bottom. Similarly, the pad's columns are numbered with integers from 1 to *m* from left to right. Greg thinks that the pad's screen displays a cave if the following conditions hold: - There is a segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*), such that each of the rows *l*,<=*l*<=+<=1,<=...,<=*r* has exactly two black cells and all other rows have only white cells. - There is a row number *t* (*l*<=≤<=*t*<=≤<=*r*), such that for all pairs of rows with numbers *i* and *j* (*l*<=≤<=*i*<=≤<=*j*<=≤<=*t*) the set of columns between the black cells in row *i* (with the columns where is these black cells) is the subset of the set of columns between the black cells in row *j* (with the columns where is these black cells). Similarly, for all pairs of rows with numbers *i* and *j* (*t*<=≤<=*i*<=≤<=*j*<=≤<=*r*) the set of columns between the black cells in row *j* (with the columns where is these black cells) is the subset of the set of columns between the black cells in row *i* (with the columns where is these black cells). Greg wondered, how many ways there are to paint a cave on his pad. Two ways can be considered distinct if there is a cell that has distinct colors on the two pictures. Help Greg.

The first line contains two integers *n*, *m* — the pad's screen size (1<=≤<=*n*,<=*m*<=≤<=2000).

In the single line print the remainder after dividing the answer to the problem by 1000000007 (109<=+<=7).

[ "1 1\n", "4 4\n", "3 5\n" ]

[ "0\n", "485\n", "451\n" ]

none

2,000

[ { "input": "1 1", "output": "0" }, { "input": "4 4", "output": "485" }, { "input": "3 5", "output": "451" }, { "input": "5 3", "output": "185" }, { "input": "5 5", "output": "6751" }, { "input": "7 8", "output": "5898445" }, { "input": "9 8", "output": "72459477" }, { "input": "10 10", "output": "33937168" }, { "input": "100 100", "output": "631601096" }, { "input": "100 110", "output": "257801865" }, { "input": "100 200", "output": "852627600" }, { "input": "1 1000", "output": "499500" }, { "input": "1000 1", "output": "0" }, { "input": "1000 3", "output": "1333331" }, { "input": "3 1000", "output": "977762109" }, { "input": "10 1000", "output": "298998986" }, { "input": "10 500", "output": "659024105" }, { "input": "250 250", "output": "331145635" }, { "input": "500 1000", "output": "169229174" }, { "input": "1000 500", "output": "900561408" }, { "input": "1000 1000", "output": "950299696" }, { "input": "1 2", "output": "1" }, { "input": "2000 2000", "output": "627008355" }, { "input": "1500 2000", "output": "294292096" }, { "input": "2000 1777", "output": "20685302" }, { "input": "1999 1994", "output": "785234759" }, { "input": "1994 1995", "output": "854486105" }, { "input": "1 2000", "output": "1999000" }, { "input": "2000 1", "output": "0" }, { "input": "2 2000", "output": "668322662" }, { "input": "2000 2", "output": "2001000" }, { "input": "3 1999", "output": "583178527" }, { "input": "1998 4", "output": "542192517" } ]

1,695,138,388

2,147,483,647

PyPy 3-64

OK

TESTS

33

1,184

74,240,000

M=10**9+7 n,m=[int(e) for e in input().split()] if m<2: print(0) else: F=[[0]*(m+1) for i in range(n+1)] Fsum=[[0]*(m+1) for i in range(n+1)] for j in range(2,m+1): F[1][j]=1 Fsum[1][j]=Fsum[1][j-1]+F[1][j] for i in range(2,n+1): s=1 for j in range(2,m+1): s+=Fsum[i-1][j] s%=M F[i][j]=s Fsum[i][j]=Fsum[i][j-1]+F[i][j] Fsum[i][j]%=M s=0 for i in range(1,n+1): for j in range(2,m+1): s+=(m-j+1)*(F[i][j]*(F[n-i+1][j]-F[n-i][j])) s%=M print(s)

Title: Greg and Caves Time Limit: None seconds Memory Limit: None megabytes Problem Description: Greg has a pad. The pad's screen is an *n*<=×<=*m* rectangle, each cell can be either black or white. We'll consider the pad rows to be numbered with integers from 1 to *n* from top to bottom. Similarly, the pad's columns are numbered with integers from 1 to *m* from left to right. Greg thinks that the pad's screen displays a cave if the following conditions hold: - There is a segment [*l*,<=*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=*n*), such that each of the rows *l*,<=*l*<=+<=1,<=...,<=*r* has exactly two black cells and all other rows have only white cells. - There is a row number *t* (*l*<=≤<=*t*<=≤<=*r*), such that for all pairs of rows with numbers *i* and *j* (*l*<=≤<=*i*<=≤<=*j*<=≤<=*t*) the set of columns between the black cells in row *i* (with the columns where is these black cells) is the subset of the set of columns between the black cells in row *j* (with the columns where is these black cells). Similarly, for all pairs of rows with numbers *i* and *j* (*t*<=≤<=*i*<=≤<=*j*<=≤<=*r*) the set of columns between the black cells in row *j* (with the columns where is these black cells) is the subset of the set of columns between the black cells in row *i* (with the columns where is these black cells). Greg wondered, how many ways there are to paint a cave on his pad. Two ways can be considered distinct if there is a cell that has distinct colors on the two pictures. Help Greg. Input Specification: The first line contains two integers *n*, *m* — the pad's screen size (1<=≤<=*n*,<=*m*<=≤<=2000). Output Specification: In the single line print the remainder after dividing the answer to the problem by 1000000007 (109<=+<=7). Demo Input: ['1 1\n', '4 4\n', '3 5\n'] Demo Output: ['0\n', '485\n', '451\n'] Note: none

```python M=10**9+7 n,m=[int(e) for e in input().split()] if m<2: print(0) else: F=[[0]*(m+1) for i in range(n+1)] Fsum=[[0]*(m+1) for i in range(n+1)] for j in range(2,m+1): F[1][j]=1 Fsum[1][j]=Fsum[1][j-1]+F[1][j] for i in range(2,n+1): s=1 for j in range(2,m+1): s+=Fsum[i-1][j] s%=M F[i][j]=s Fsum[i][j]=Fsum[i][j-1]+F[i][j] Fsum[i][j]%=M s=0 for i in range(1,n+1): for j in range(2,m+1): s+=(m-j+1)*(F[i][j]*(F[n-i+1][j]-F[n-i][j])) s%=M print(s) ```

3

538

A

Cutting Banner

PROGRAMMING

1,400

[ "brute force", "implementation" ]

null

A large banner with word CODEFORCES was ordered for the 1000-th onsite round of Codeforcesω that takes place on the Miami beach. Unfortunately, the company that made the banner mixed up two orders and delivered somebody else's banner that contains someone else's word. The word on the banner consists only of upper-case English letters. There is very little time to correct the mistake. All that we can manage to do is to cut out some substring from the banner, i.e. several consecutive letters. After that all the resulting parts of the banner will be glued into a single piece (if the beginning or the end of the original banner was cut out, only one part remains); it is not allowed change the relative order of parts of the banner (i.e. after a substring is cut, several first and last letters are left, it is allowed only to glue the last letters to the right of the first letters). Thus, for example, for example, you can cut a substring out from string 'TEMPLATE' and get string 'TEMPLE' (if you cut out string AT), 'PLATE' (if you cut out TEM), 'T' (if you cut out EMPLATE), etc. Help the organizers of the round determine whether it is possible to cut out of the banner some substring in such a way that the remaining parts formed word CODEFORCES.

The single line of the input contains the word written on the banner. The word only consists of upper-case English letters. The word is non-empty and its length doesn't exceed 100 characters. It is guaranteed that the word isn't word CODEFORCES.

Print 'YES', if there exists a way to cut out the substring, and 'NO' otherwise (without the quotes).

[ "CODEWAITFORITFORCES\n", "BOTTOMCODER\n", "DECODEFORCES\n", "DOGEFORCES\n" ]

[ "YES\n", "NO\n", "YES\n", "NO\n" ]

none

500

[ { "input": "CODEWAITFORITFORCES", "output": "YES" }, { "input": "BOTTOMCODER", "output": "NO" }, { "input": "DECODEFORCES", "output": "YES" }, { "input": "DOGEFORCES", "output": "NO" }, { "input": "ABACABA", "output": "NO" }, { "input": "CODEFORCE", "output": "NO" }, { "input": "C", "output": "NO" }, { "input": "NQTSMZEBLY", "output": "NO" }, { "input": "CODEFZORCES", "output": "YES" }, { "input": "EDYKHVZCNTLJUUOQGHPTIOETQNFLLWEKZOHIUAXELGECABVSBIBGQODQXVYFKBYJWTGBYHVSSNTINKWSINWSMALUSIWNJMTCOOVF", "output": "NO" }, { "input": "OCECFDSRDE", "output": "NO" }, { "input": "MDBUWCZFFZKFMJTTJFXRHTGRPREORKDVUXOEMFYSOMSQGHUKGYCRCVJTNDLFDEWFS", "output": "NO" }, { "input": "CODEFYTORCHES", "output": "NO" }, { "input": "BCODEFORCES", "output": "YES" }, { "input": "CVODEFORCES", "output": "YES" }, { "input": "COAKDEFORCES", "output": "YES" }, { "input": "CODFMWEFORCES", "output": "YES" }, { "input": "CODEVCSYRFORCES", "output": "YES" }, { "input": "CODEFXHHPWCVQORCES", "output": "YES" }, { "input": "CODEFORQWUFJLOFFXTXRCES", "output": "YES" }, { "input": "CODEFORBWFURYIDURNRKRDLHCLXZCES", "output": "YES" }, { "input": "CODEFORCQSYSLYKCDFFUPSAZCJIAENCKZUFJZEINQIES", "output": "YES" }, { "input": "CODEFORCEVENMDBQLSVPQIIBGSHBVOPYZXNWVSTVWDRONUREYJJIJIPMEBPQDCPFS", "output": "YES" }, { "input": "CODEFORCESCFNNPAHNHDIPPBAUSPKJYAQDBVZNLSTSDCREZACVLMRFGVKGVHHZLXOHCTJDBQKIDWBUXDUJARLWGFGFCTTXUCAZB", "output": "YES" }, { "input": "CODJRDPDEFOROES", "output": "NO" }, { "input": "CODEFOGSIUZMZCMWAVQHNYFEKIEZQMAZOVEMDRMOEDBHAXPLBLDYYXCVTOOSJZVSQAKFXTBTZFWAYRZEMDEMVDJTDRXXAQBURCES", "output": "YES" }, { "input": "CODEMKUYHAZSGJBQLXTHUCZZRJJJXUSEBOCNZASOKDZHMSGWZSDFBGHXFLABVPDQBJYXSHHAZAKHSTRGOKJYHRVSSUGDCMFOGCES", "output": "NO" }, { "input": "CODEFORCESCODEFORCESCODEFORCESCODEFORCESCODEFORCESCODEFORCESCODEFORCESCODEFORCESCODEFORCES", "output": "YES" }, { "input": "CCODEFORCESODECODEFORCCODEFORCESODCODEFORCESEFCODEFORCESORCODEFORCESCESCESFORCODEFORCESCES", "output": "NO" }, { "input": "CCODEFORCESC", "output": "NO" }, { "input": "CODEAFORBCES", "output": "NO" }, { "input": "CODERRRRRFORCRRRRES", "output": "NO" }, { "input": "CODELFORCELS", "output": "NO" }, { "input": "CPOPDPEPFPOPRPCPEPS", "output": "NO" }, { "input": "COXDEXFORXCEXS", "output": "NO" }, { "input": "CODAAAAAFORCES", "output": "NO" }, { "input": "CAOADEFORCES", "output": "NO" }, { "input": "FORCESXCODE", "output": "NO" }, { "input": "FORCESACODE", "output": "NO" }, { "input": "ACAOADAEFORCES", "output": "NO" }, { "input": "CCODEFORCESS", "output": "NO" }, { "input": "ZCODEFORCEZ", "output": "NO" }, { "input": "CODXEFORXCES", "output": "NO" }, { "input": "CODEFORCEZ", "output": "NO" }, { "input": "CODEFORCEST", "output": "YES" }, { "input": "AXODEFORCES", "output": "NO" }, { "input": "RCODEFORCESR", "output": "NO" }, { "input": "CODECODEFORCESFORCES", "output": "YES" }, { "input": "TTTWWWCODEFORCES", "output": "YES" }, { "input": "CODEFORRCEST", "output": "NO" }, { "input": "UJYTYUCODEFORCES", "output": "YES" }, { "input": "CODEXXXXXXXXXXXXXXXXXXCODEFORCESXXXXXXXXXXXXXXXXXXXXXFORCES", "output": "YES" }, { "input": "COXEDYFORCES", "output": "NO" }, { "input": "UJYTYCODEFORCES", "output": "YES" }, { "input": "UJYTCODEFORCES", "output": "YES" } ]

1,479,145,060

2,147,483,647

Python 3

OK

TESTS

55

62

0

word = input() need,result = "CODEFORCES","NO" for i in range(len(need)+1): if word.startswith(need[:i]) and word.endswith(need[i:]): result = "YES" break print(result)

Title: Cutting Banner Time Limit: None seconds Memory Limit: None megabytes Problem Description: A large banner with word CODEFORCES was ordered for the 1000-th onsite round of Codeforcesω that takes place on the Miami beach. Unfortunately, the company that made the banner mixed up two orders and delivered somebody else's banner that contains someone else's word. The word on the banner consists only of upper-case English letters. There is very little time to correct the mistake. All that we can manage to do is to cut out some substring from the banner, i.e. several consecutive letters. After that all the resulting parts of the banner will be glued into a single piece (if the beginning or the end of the original banner was cut out, only one part remains); it is not allowed change the relative order of parts of the banner (i.e. after a substring is cut, several first and last letters are left, it is allowed only to glue the last letters to the right of the first letters). Thus, for example, for example, you can cut a substring out from string 'TEMPLATE' and get string 'TEMPLE' (if you cut out string AT), 'PLATE' (if you cut out TEM), 'T' (if you cut out EMPLATE), etc. Help the organizers of the round determine whether it is possible to cut out of the banner some substring in such a way that the remaining parts formed word CODEFORCES. Input Specification: The single line of the input contains the word written on the banner. The word only consists of upper-case English letters. The word is non-empty and its length doesn't exceed 100 characters. It is guaranteed that the word isn't word CODEFORCES. Output Specification: Print 'YES', if there exists a way to cut out the substring, and 'NO' otherwise (without the quotes). Demo Input: ['CODEWAITFORITFORCES\n', 'BOTTOMCODER\n', 'DECODEFORCES\n', 'DOGEFORCES\n'] Demo Output: ['YES\n', 'NO\n', 'YES\n', 'NO\n'] Note: none

```python word = input() need,result = "CODEFORCES","NO" for i in range(len(need)+1): if word.startswith(need[:i]) and word.endswith(need[i:]): result = "YES" break print(result) ```

3

327

B

Hungry Sequence

PROGRAMMING

1,200

[ "math" ]

null

Iahub and Iahubina went to a date at a luxury restaurant. Everything went fine until paying for the food. Instead of money, the waiter wants Iahub to write a Hungry sequence consisting of *n* integers. A sequence *a*1, *a*2, ..., *a**n*, consisting of *n* integers, is Hungry if and only if: - Its elements are in increasing order. That is an inequality *a**i*<=<<=*a**j* holds for any two indices *i*,<=*j* (*i*<=<<=*j*). - For any two indices *i* and *j* (*i*<=<<=*j*), *a**j* must not be divisible by *a**i*. Iahub is in trouble, so he asks you for help. Find a Hungry sequence with *n* elements.

The input contains a single integer: *n* (1<=≤<=*n*<=≤<=105).

Output a line that contains *n* space-separated integers *a*1 *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=107), representing a possible Hungry sequence. Note, that each *a**i* must not be greater than 10000000 (107) and less than 1. If there are multiple solutions you can output any one.

[ "3\n", "5\n" ]

[ "2 9 15\n", "11 14 20 27 31\n" ]

none

500

[ { "input": "3", "output": "2 9 15" }, { "input": "5", "output": "11 14 20 27 31" }, { "input": "1", "output": "3" }, { "input": "1000", "output": "3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3..." }, { "input": "100000", "output": "300000 300001 300002 300003 300004 300005 300006 300007 300008 300009 300010 300011 300012 300013 300014 300015 300016 300017 300018 300019 300020 300021 300022 300023 300024 300025 300026 300027 300028 300029 300030 300031 300032 300033 300034 300035 300036 300037 300038 300039 300040 300041 300042 300043 300044 300045 300046 300047 300048 300049 300050 300051 300052 300053 300054 300055 300056 300057 300058 300059 300060 300061 300062 300063 300064 300065 300066 300067 300068 300069 300070 300071 300072 ..." }, { "input": "46550", "output": "139650 139651 139652 139653 139654 139655 139656 139657 139658 139659 139660 139661 139662 139663 139664 139665 139666 139667 139668 139669 139670 139671 139672 139673 139674 139675 139676 139677 139678 139679 139680 139681 139682 139683 139684 139685 139686 139687 139688 139689 139690 139691 139692 139693 139694 139695 139696 139697 139698 139699 139700 139701 139702 139703 139704 139705 139706 139707 139708 139709 139710 139711 139712 139713 139714 139715 139716 139717 139718 139719 139720 139721 139722 ..." }, { "input": "61324", "output": "183972 183973 183974 183975 183976 183977 183978 183979 183980 183981 183982 183983 183984 183985 183986 183987 183988 183989 183990 183991 183992 183993 183994 183995 183996 183997 183998 183999 184000 184001 184002 184003 184004 184005 184006 184007 184008 184009 184010 184011 184012 184013 184014 184015 184016 184017 184018 184019 184020 184021 184022 184023 184024 184025 184026 184027 184028 184029 184030 184031 184032 184033 184034 184035 184036 184037 184038 184039 184040 184041 184042 184043 184044 ..." }, { "input": "13176", "output": "39528 39529 39530 39531 39532 39533 39534 39535 39536 39537 39538 39539 39540 39541 39542 39543 39544 39545 39546 39547 39548 39549 39550 39551 39552 39553 39554 39555 39556 39557 39558 39559 39560 39561 39562 39563 39564 39565 39566 39567 39568 39569 39570 39571 39572 39573 39574 39575 39576 39577 39578 39579 39580 39581 39582 39583 39584 39585 39586 39587 39588 39589 39590 39591 39592 39593 39594 39595 39596 39597 39598 39599 39600 39601 39602 39603 39604 39605 39606 39607 39608 39609 39610 39611 39612 3..." }, { "input": "73274", "output": "219822 219823 219824 219825 219826 219827 219828 219829 219830 219831 219832 219833 219834 219835 219836 219837 219838 219839 219840 219841 219842 219843 219844 219845 219846 219847 219848 219849 219850 219851 219852 219853 219854 219855 219856 219857 219858 219859 219860 219861 219862 219863 219864 219865 219866 219867 219868 219869 219870 219871 219872 219873 219874 219875 219876 219877 219878 219879 219880 219881 219882 219883 219884 219885 219886 219887 219888 219889 219890 219891 219892 219893 219894 ..." }, { "input": "86947", "output": "260841 260842 260843 260844 260845 260846 260847 260848 260849 260850 260851 260852 260853 260854 260855 260856 260857 260858 260859 260860 260861 260862 260863 260864 260865 260866 260867 260868 260869 260870 260871 260872 260873 260874 260875 260876 260877 260878 260879 260880 260881 260882 260883 260884 260885 260886 260887 260888 260889 260890 260891 260892 260893 260894 260895 260896 260897 260898 260899 260900 260901 260902 260903 260904 260905 260906 260907 260908 260909 260910 260911 260912 260913 ..." }, { "input": "26342", "output": "79026 79027 79028 79029 79030 79031 79032 79033 79034 79035 79036 79037 79038 79039 79040 79041 79042 79043 79044 79045 79046 79047 79048 79049 79050 79051 79052 79053 79054 79055 79056 79057 79058 79059 79060 79061 79062 79063 79064 79065 79066 79067 79068 79069 79070 79071 79072 79073 79074 79075 79076 79077 79078 79079 79080 79081 79082 79083 79084 79085 79086 79087 79088 79089 79090 79091 79092 79093 79094 79095 79096 79097 79098 79099 79100 79101 79102 79103 79104 79105 79106 79107 79108 79109 79110 7..." }, { "input": "22345", "output": "67035 67036 67037 67038 67039 67040 67041 67042 67043 67044 67045 67046 67047 67048 67049 67050 67051 67052 67053 67054 67055 67056 67057 67058 67059 67060 67061 67062 67063 67064 67065 67066 67067 67068 67069 67070 67071 67072 67073 67074 67075 67076 67077 67078 67079 67080 67081 67082 67083 67084 67085 67086 67087 67088 67089 67090 67091 67092 67093 67094 67095 67096 67097 67098 67099 67100 67101 67102 67103 67104 67105 67106 67107 67108 67109 67110 67111 67112 67113 67114 67115 67116 67117 67118 67119 6..." }, { "input": "19639", "output": "58917 58918 58919 58920 58921 58922 58923 58924 58925 58926 58927 58928 58929 58930 58931 58932 58933 58934 58935 58936 58937 58938 58939 58940 58941 58942 58943 58944 58945 58946 58947 58948 58949 58950 58951 58952 58953 58954 58955 58956 58957 58958 58959 58960 58961 58962 58963 58964 58965 58966 58967 58968 58969 58970 58971 58972 58973 58974 58975 58976 58977 58978 58979 58980 58981 58982 58983 58984 58985 58986 58987 58988 58989 58990 58991 58992 58993 58994 58995 58996 58997 58998 58999 59000 59001 5..." }, { "input": "12337", "output": "37011 37012 37013 37014 37015 37016 37017 37018 37019 37020 37021 37022 37023 37024 37025 37026 37027 37028 37029 37030 37031 37032 37033 37034 37035 37036 37037 37038 37039 37040 37041 37042 37043 37044 37045 37046 37047 37048 37049 37050 37051 37052 37053 37054 37055 37056 37057 37058 37059 37060 37061 37062 37063 37064 37065 37066 37067 37068 37069 37070 37071 37072 37073 37074 37075 37076 37077 37078 37079 37080 37081 37082 37083 37084 37085 37086 37087 37088 37089 37090 37091 37092 37093 37094 37095 3..." }, { "input": "67989", "output": "203967 203968 203969 203970 203971 203972 203973 203974 203975 203976 203977 203978 203979 203980 203981 203982 203983 203984 203985 203986 203987 203988 203989 203990 203991 203992 203993 203994 203995 203996 203997 203998 203999 204000 204001 204002 204003 204004 204005 204006 204007 204008 204009 204010 204011 204012 204013 204014 204015 204016 204017 204018 204019 204020 204021 204022 204023 204024 204025 204026 204027 204028 204029 204030 204031 204032 204033 204034 204035 204036 204037 204038 204039 ..." }, { "input": "57610", "output": "172830 172831 172832 172833 172834 172835 172836 172837 172838 172839 172840 172841 172842 172843 172844 172845 172846 172847 172848 172849 172850 172851 172852 172853 172854 172855 172856 172857 172858 172859 172860 172861 172862 172863 172864 172865 172866 172867 172868 172869 172870 172871 172872 172873 172874 172875 172876 172877 172878 172879 172880 172881 172882 172883 172884 172885 172886 172887 172888 172889 172890 172891 172892 172893 172894 172895 172896 172897 172898 172899 172900 172901 172902 ..." }, { "input": "63287", "output": "189861 189862 189863 189864 189865 189866 189867 189868 189869 189870 189871 189872 189873 189874 189875 189876 189877 189878 189879 189880 189881 189882 189883 189884 189885 189886 189887 189888 189889 189890 189891 189892 189893 189894 189895 189896 189897 189898 189899 189900 189901 189902 189903 189904 189905 189906 189907 189908 189909 189910 189911 189912 189913 189914 189915 189916 189917 189918 189919 189920 189921 189922 189923 189924 189925 189926 189927 189928 189929 189930 189931 189932 189933 ..." }, { "input": "952", "output": "2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2..." }, { "input": "77840", "output": "233520 233521 233522 233523 233524 233525 233526 233527 233528 233529 233530 233531 233532 233533 233534 233535 233536 233537 233538 233539 233540 233541 233542 233543 233544 233545 233546 233547 233548 233549 233550 233551 233552 233553 233554 233555 233556 233557 233558 233559 233560 233561 233562 233563 233564 233565 233566 233567 233568 233569 233570 233571 233572 233573 233574 233575 233576 233577 233578 233579 233580 233581 233582 233583 233584 233585 233586 233587 233588 233589 233590 233591 233592 ..." }, { "input": "42157", "output": "126471 126472 126473 126474 126475 126476 126477 126478 126479 126480 126481 126482 126483 126484 126485 126486 126487 126488 126489 126490 126491 126492 126493 126494 126495 126496 126497 126498 126499 126500 126501 126502 126503 126504 126505 126506 126507 126508 126509 126510 126511 126512 126513 126514 126515 126516 126517 126518 126519 126520 126521 126522 126523 126524 126525 126526 126527 126528 126529 126530 126531 126532 126533 126534 126535 126536 126537 126538 126539 126540 126541 126542 126543 ..." }, { "input": "46375", "output": "139125 139126 139127 139128 139129 139130 139131 139132 139133 139134 139135 139136 139137 139138 139139 139140 139141 139142 139143 139144 139145 139146 139147 139148 139149 139150 139151 139152 139153 139154 139155 139156 139157 139158 139159 139160 139161 139162 139163 139164 139165 139166 139167 139168 139169 139170 139171 139172 139173 139174 139175 139176 139177 139178 139179 139180 139181 139182 139183 139184 139185 139186 139187 139188 139189 139190 139191 139192 139193 139194 139195 139196 139197 ..." }, { "input": "55142", "output": "165426 165427 165428 165429 165430 165431 165432 165433 165434 165435 165436 165437 165438 165439 165440 165441 165442 165443 165444 165445 165446 165447 165448 165449 165450 165451 165452 165453 165454 165455 165456 165457 165458 165459 165460 165461 165462 165463 165464 165465 165466 165467 165468 165469 165470 165471 165472 165473 165474 165475 165476 165477 165478 165479 165480 165481 165482 165483 165484 165485 165486 165487 165488 165489 165490 165491 165492 165493 165494 165495 165496 165497 165498 ..." }, { "input": "60299", "output": "180897 180898 180899 180900 180901 180902 180903 180904 180905 180906 180907 180908 180909 180910 180911 180912 180913 180914 180915 180916 180917 180918 180919 180920 180921 180922 180923 180924 180925 180926 180927 180928 180929 180930 180931 180932 180933 180934 180935 180936 180937 180938 180939 180940 180941 180942 180943 180944 180945 180946 180947 180948 180949 180950 180951 180952 180953 180954 180955 180956 180957 180958 180959 180960 180961 180962 180963 180964 180965 180966 180967 180968 180969 ..." }, { "input": "28862", "output": "86586 86587 86588 86589 86590 86591 86592 86593 86594 86595 86596 86597 86598 86599 86600 86601 86602 86603 86604 86605 86606 86607 86608 86609 86610 86611 86612 86613 86614 86615 86616 86617 86618 86619 86620 86621 86622 86623 86624 86625 86626 86627 86628 86629 86630 86631 86632 86633 86634 86635 86636 86637 86638 86639 86640 86641 86642 86643 86644 86645 86646 86647 86648 86649 86650 86651 86652 86653 86654 86655 86656 86657 86658 86659 86660 86661 86662 86663 86664 86665 86666 86667 86668 86669 86670 8..." }, { "input": "48251", "output": "144753 144754 144755 144756 144757 144758 144759 144760 144761 144762 144763 144764 144765 144766 144767 144768 144769 144770 144771 144772 144773 144774 144775 144776 144777 144778 144779 144780 144781 144782 144783 144784 144785 144786 144787 144788 144789 144790 144791 144792 144793 144794 144795 144796 144797 144798 144799 144800 144801 144802 144803 144804 144805 144806 144807 144808 144809 144810 144811 144812 144813 144814 144815 144816 144817 144818 144819 144820 144821 144822 144823 144824 144825 ..." }, { "input": "2", "output": "6 7" }, { "input": "4", "output": "12 13 14 15" } ]

1,652,514,447

2,147,483,647

PyPy 3-64

OK

TESTS

27

374

9,318,400

import sys input = sys.stdin.readline n = int(input()) for i in range(10 ** 7 - n + 1, 10 ** 7 + 1): print(i, end = ' ')

Title: Hungry Sequence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Iahub and Iahubina went to a date at a luxury restaurant. Everything went fine until paying for the food. Instead of money, the waiter wants Iahub to write a Hungry sequence consisting of *n* integers. A sequence *a*1, *a*2, ..., *a**n*, consisting of *n* integers, is Hungry if and only if: - Its elements are in increasing order. That is an inequality *a**i*<=<<=*a**j* holds for any two indices *i*,<=*j* (*i*<=<<=*j*). - For any two indices *i* and *j* (*i*<=<<=*j*), *a**j* must not be divisible by *a**i*. Iahub is in trouble, so he asks you for help. Find a Hungry sequence with *n* elements. Input Specification: The input contains a single integer: *n* (1<=≤<=*n*<=≤<=105). Output Specification: Output a line that contains *n* space-separated integers *a*1 *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=107), representing a possible Hungry sequence. Note, that each *a**i* must not be greater than 10000000 (107) and less than 1. If there are multiple solutions you can output any one. Demo Input: ['3\n', '5\n'] Demo Output: ['2 9 15\n', '11 14 20 27 31\n'] Note: none

```python import sys input = sys.stdin.readline n = int(input()) for i in range(10 ** 7 - n + 1, 10 ** 7 + 1): print(i, end = ' ') ```

3

570

A

Elections

PROGRAMMING

1,100

[ "implementation" ]

null

The country of Byalechinsk is running elections involving *n* candidates. The country consists of *m* cities. We know how many people in each city voted for each candidate. The electoral system in the country is pretty unusual. At the first stage of elections the votes are counted for each city: it is assumed that in each city won the candidate who got the highest number of votes in this city, and if several candidates got the maximum number of votes, then the winner is the one with a smaller index. At the second stage of elections the winner is determined by the same principle over the cities: the winner of the elections is the candidate who won in the maximum number of cities, and among those who got the maximum number of cities the winner is the one with a smaller index. Determine who will win the elections.

The first line of the input contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of candidates and of cities, respectively. Each of the next *m* lines contains *n* non-negative integers, the *j*-th number in the *i*-th line *a**ij* (1<=≤<=*j*<=≤<=*n*, 1<=≤<=*i*<=≤<=*m*, 0<=≤<=*a**ij*<=≤<=109) denotes the number of votes for candidate *j* in city *i*. It is guaranteed that the total number of people in all the cities does not exceed 109.

Print a single number — the index of the candidate who won the elections. The candidates are indexed starting from one.

[ "3 3\n1 2 3\n2 3 1\n1 2 1\n", "3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7\n" ]

[ "2", "1" ]

Note to the first sample test. At the first stage city 1 chosen candidate 3, city 2 chosen candidate 2, city 3 chosen candidate 2. The winner is candidate 2, he gained 2 votes. Note to the second sample test. At the first stage in city 1 candidates 1 and 2 got the same maximum number of votes, but candidate 1 has a smaller index, so the city chose candidate 1. City 2 chosen candidate 3. City 3 chosen candidate 1, due to the fact that everyone has the same number of votes, and 1 has the smallest index. City 4 chosen the candidate 3. On the second stage the same number of cities chose candidates 1 and 3. The winner is candidate 1, the one with the smaller index.

500

[ { "input": "3 3\n1 2 3\n2 3 1\n1 2 1", "output": "2" }, { "input": "3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7", "output": "1" }, { "input": "1 3\n5\n3\n2", "output": "1" }, { "input": "3 1\n1 2 3", "output": "3" }, { "input": "3 1\n100 100 100", "output": "1" }, { "input": "2 2\n1 2\n2 1", "output": "1" }, { "input": "2 2\n2 1\n2 1", "output": "1" }, { "input": "2 2\n1 2\n1 2", "output": "2" }, { "input": "3 3\n0 0 0\n1 1 1\n2 2 2", "output": "1" }, { "input": "1 1\n1000000000", "output": "1" }, { "input": "5 5\n1 2 3 4 5\n2 3 4 5 6\n3 4 5 6 7\n4 5 6 7 8\n5 6 7 8 9", "output": "5" }, { "input": "4 4\n1 3 1 3\n3 1 3 1\n2 0 0 2\n0 1 1 0", "output": "1" }, { "input": "4 4\n1 4 1 3\n3 1 2 1\n1 0 0 2\n0 1 10 0", "output": "1" }, { "input": "4 4\n1 4 1 300\n3 1 2 1\n5 0 0 2\n0 1 10 100", "output": "1" }, { "input": "5 5\n15 45 15 300 10\n53 15 25 51 10\n5 50 50 2 10\n1000 1 10 100 10\n10 10 10 10 10", "output": "1" }, { "input": "1 100\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1", "output": "1" }, { "input": "100 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "1" }, { "input": "1 100\n859\n441\n272\n47\n355\n345\n612\n569\n545\n599\n410\n31\n720\n303\n58\n537\n561\n730\n288\n275\n446\n955\n195\n282\n153\n455\n996\n121\n267\n702\n769\n560\n353\n89\n990\n282\n801\n335\n573\n258\n722\n768\n324\n41\n249\n125\n557\n303\n664\n945\n156\n884\n985\n816\n433\n65\n976\n963\n85\n647\n46\n877\n665\n523\n714\n182\n377\n549\n994\n385\n184\n724\n447\n99\n766\n353\n494\n747\n324\n436\n915\n472\n879\n582\n928\n84\n627\n156\n972\n651\n159\n372\n70\n903\n590\n480\n184\n540\n270\n892", "output": "1" }, { "input": "100 1\n439 158 619 538 187 153 973 781 610 475 94 947 449 531 220 51 788 118 189 501 54 434 465 902 280 635 688 214 737 327 682 690 683 519 261 923 254 388 529 659 662 276 376 735 976 664 521 285 42 147 187 259 407 977 879 465 522 17 550 701 114 921 577 265 668 812 232 267 135 371 586 201 608 373 771 358 101 412 195 582 199 758 507 882 16 484 11 712 916 699 783 618 405 124 904 257 606 610 230 718", "output": "54" }, { "input": "1 99\n511\n642\n251\n30\n494\n128\n189\n324\n884\n656\n120\n616\n959\n328\n411\n933\n895\n350\n1\n838\n996\n761\n619\n131\n824\n751\n707\n688\n915\n115\n244\n476\n293\n986\n29\n787\n607\n259\n756\n864\n394\n465\n303\n387\n521\n582\n485\n355\n299\n997\n683\n472\n424\n948\n339\n383\n285\n957\n591\n203\n866\n79\n835\n980\n344\n493\n361\n159\n160\n947\n46\n362\n63\n553\n793\n754\n429\n494\n523\n227\n805\n313\n409\n243\n927\n350\n479\n971\n825\n460\n544\n235\n660\n327\n216\n729\n147\n671\n738", "output": "1" }, { "input": "99 1\n50 287 266 159 551 198 689 418 809 43 691 367 160 664 86 805 461 55 127 950 576 351 721 493 972 560 934 885 492 92 321 759 767 989 883 7 127 413 404 604 80 645 666 874 371 718 893 158 722 198 563 293 134 255 742 913 252 378 859 721 502 251 839 284 133 209 962 514 773 124 205 903 785 859 911 93 861 786 747 213 690 69 942 697 211 203 284 961 351 137 962 952 408 249 238 850 944 40 346", "output": "34" }, { "input": "100 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2", "output": "100" }, { "input": "1 1\n0", "output": "1" }, { "input": "2 1\n0 0", "output": "1" }, { "input": "2 2\n0 0\n0 0", "output": "1" }, { "input": "2 2\n1 2\n0 0", "output": "1" }, { "input": "3 3\n0 0 0\n0 0 0\n0 0 0", "output": "1" }, { "input": "2 3\n0 0\n0 0\n0 1", "output": "1" }, { "input": "3 2\n1 1 3\n0 0 0", "output": "1" }, { "input": "3 4\n1 10 3\n0 0 0\n0 0 0\n0 0 0", "output": "1" }, { "input": "2 4\n2 1\n1 2\n0 0\n1 2", "output": "1" }, { "input": "2 2\n0 1\n0 1", "output": "2" }, { "input": "2 3\n1 2\n0 0\n2 1", "output": "1" }, { "input": "2 2\n0 0\n4 5", "output": "1" }, { "input": "3 2\n10 15 20\n0 0 0", "output": "1" }, { "input": "3 4\n0 0 0\n0 0 0\n0 0 0\n1 2 3", "output": "1" }, { "input": "3 3\n0 0 0\n0 0 0\n0 0 1", "output": "1" }, { "input": "3 3\n0 0 0\n1 2 3\n1 3 2", "output": "1" }, { "input": "3 1\n0 0 0", "output": "1" }, { "input": "3 3\n0 0 1\n0 0 0\n0 0 0", "output": "1" } ]

1,555,998,666

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

109

409,600

from collections import Counter c = Counter() n, m =map(int,input().split()) for _ in range(m): a = list(map(int,input().split())) max_value = a.index(max(a)) c[max_value+1]=c[max_value+1]+1 print(c.most_common(1)[0][0])

Title: Elections Time Limit: None seconds Memory Limit: None megabytes Problem Description: The country of Byalechinsk is running elections involving *n* candidates. The country consists of *m* cities. We know how many people in each city voted for each candidate. The electoral system in the country is pretty unusual. At the first stage of elections the votes are counted for each city: it is assumed that in each city won the candidate who got the highest number of votes in this city, and if several candidates got the maximum number of votes, then the winner is the one with a smaller index. At the second stage of elections the winner is determined by the same principle over the cities: the winner of the elections is the candidate who won in the maximum number of cities, and among those who got the maximum number of cities the winner is the one with a smaller index. Determine who will win the elections. Input Specification: The first line of the input contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of candidates and of cities, respectively. Each of the next *m* lines contains *n* non-negative integers, the *j*-th number in the *i*-th line *a**ij* (1<=≤<=*j*<=≤<=*n*, 1<=≤<=*i*<=≤<=*m*, 0<=≤<=*a**ij*<=≤<=109) denotes the number of votes for candidate *j* in city *i*. It is guaranteed that the total number of people in all the cities does not exceed 109. Output Specification: Print a single number — the index of the candidate who won the elections. The candidates are indexed starting from one. Demo Input: ['3 3\n1 2 3\n2 3 1\n1 2 1\n', '3 4\n10 10 3\n5 1 6\n2 2 2\n1 5 7\n'] Demo Output: ['2', '1'] Note: Note to the first sample test. At the first stage city 1 chosen candidate 3, city 2 chosen candidate 2, city 3 chosen candidate 2. The winner is candidate 2, he gained 2 votes. Note to the second sample test. At the first stage in city 1 candidates 1 and 2 got the same maximum number of votes, but candidate 1 has a smaller index, so the city chose candidate 1. City 2 chosen candidate 3. City 3 chosen candidate 1, due to the fact that everyone has the same number of votes, and 1 has the smallest index. City 4 chosen the candidate 3. On the second stage the same number of cities chose candidates 1 and 3. The winner is candidate 1, the one with the smaller index.

```python from collections import Counter c = Counter() n, m =map(int,input().split()) for _ in range(m): a = list(map(int,input().split())) max_value = a.index(max(a)) c[max_value+1]=c[max_value+1]+1 print(c.most_common(1)[0][0]) ```

0

675

A

Infinite Sequence

PROGRAMMING

1,100

[ "math" ]

null

Vasya likes everything infinite. Now he is studying the properties of a sequence *s*, such that its first element is equal to *a* (*s*1<==<=*a*), and the difference between any two neighbouring elements is equal to *c* (*s**i*<=-<=*s**i*<=-<=1<==<=*c*). In particular, Vasya wonders if his favourite integer *b* appears in this sequence, that is, there exists a positive integer *i*, such that *s**i*<==<=*b*. Of course, you are the person he asks for a help.

The first line of the input contain three integers *a*, *b* and *c* (<=-<=109<=≤<=*a*,<=*b*,<=*c*<=≤<=109) — the first element of the sequence, Vasya's favorite number and the difference between any two neighbouring elements of the sequence, respectively.

If *b* appears in the sequence *s* print "YES" (without quotes), otherwise print "NO" (without quotes).

[ "1 7 3\n", "10 10 0\n", "1 -4 5\n", "0 60 50\n" ]

[ "YES\n", "YES\n", "NO\n", "NO\n" ]

In the first sample, the sequence starts from integers 1, 4, 7, so 7 is its element. In the second sample, the favorite integer of Vasya is equal to the first element of the sequence. In the third sample all elements of the sequence are greater than Vasya's favorite integer. In the fourth sample, the sequence starts from 0, 50, 100, and all the following elements are greater than Vasya's favorite integer.

500

[ { "input": "1 7 3", "output": "YES" }, { "input": "10 10 0", "output": "YES" }, { "input": "1 -4 5", "output": "NO" }, { "input": "0 60 50", "output": "NO" }, { "input": "1 -4 -5", "output": "YES" }, { "input": "0 1 0", "output": "NO" }, { "input": "10 10 42", "output": "YES" }, { "input": "-1000000000 1000000000 -1", "output": "NO" }, { "input": "10 16 4", "output": "NO" }, { "input": "-1000000000 1000000000 5", "output": "YES" }, { "input": "1000000000 -1000000000 5", "output": "NO" }, { "input": "1000000000 -1000000000 0", "output": "NO" }, { "input": "1000000000 1000000000 0", "output": "YES" }, { "input": "115078364 -899474523 -1", "output": "YES" }, { "input": "-245436499 416383245 992", "output": "YES" }, { "input": "-719636354 536952440 2", "output": "YES" }, { "input": "-198350539 963391024 68337739", "output": "YES" }, { "input": "-652811055 875986516 1091", "output": "YES" }, { "input": "119057893 -516914539 -39748277", "output": "YES" }, { "input": "989140430 731276607 -36837689", "output": "YES" }, { "input": "677168390 494583489 -985071853", "output": "NO" }, { "input": "58090193 777423708 395693923", "output": "NO" }, { "input": "479823846 -403424770 -653472589", "output": "NO" }, { "input": "-52536829 -132023273 -736287999", "output": "NO" }, { "input": "-198893776 740026818 -547885271", "output": "NO" }, { "input": "-2 -2 -2", "output": "YES" }, { "input": "-2 -2 -1", "output": "YES" }, { "input": "-2 -2 0", "output": "YES" }, { "input": "-2 -2 1", "output": "YES" }, { "input": "-2 -2 2", "output": "YES" }, { "input": "-2 -1 -2", "output": "NO" }, { "input": "-2 -1 -1", "output": "NO" }, { "input": "-2 -1 0", "output": "NO" }, { "input": "-2 -1 1", "output": "YES" }, { "input": "-2 -1 2", "output": "NO" }, { "input": "-2 0 -2", "output": "NO" }, { "input": "-2 0 -1", "output": "NO" }, { "input": "-2 0 0", "output": "NO" }, { "input": "-2 0 1", "output": "YES" }, { "input": "-2 0 2", "output": "YES" }, { "input": "-2 1 -2", "output": "NO" }, { "input": "-2 1 -1", "output": "NO" }, { "input": "-2 1 0", "output": "NO" }, { "input": "-2 1 1", "output": "YES" }, { "input": "-2 1 2", "output": "NO" }, { "input": "-2 2 -2", "output": "NO" }, { "input": "-2 2 -1", "output": "NO" }, { "input": "-2 2 0", "output": "NO" }, { "input": "-2 2 1", "output": "YES" }, { "input": "-2 2 2", "output": "YES" }, { "input": "-1 -2 -2", "output": "NO" }, { "input": "-1 -2 -1", "output": "YES" }, { "input": "-1 -2 0", "output": "NO" }, { "input": "-1 -2 1", "output": "NO" }, { "input": "-1 -2 2", "output": "NO" }, { "input": "-1 -1 -2", "output": "YES" }, { "input": "-1 -1 -1", "output": "YES" }, { "input": "-1 -1 0", "output": "YES" }, { "input": "-1 -1 1", "output": "YES" }, { "input": "-1 -1 2", "output": "YES" }, { "input": "-1 0 -2", "output": "NO" }, { "input": "-1 0 -1", "output": "NO" }, { "input": "-1 0 0", "output": "NO" }, { "input": "-1 0 1", "output": "YES" }, { "input": "-1 0 2", "output": "NO" }, { "input": "-1 1 -2", "output": "NO" }, { "input": "-1 1 -1", "output": "NO" }, { "input": "-1 1 0", "output": "NO" }, { "input": "-1 1 1", "output": "YES" }, { "input": "-1 1 2", "output": "YES" }, { "input": "-1 2 -2", "output": "NO" }, { "input": "-1 2 -1", "output": "NO" }, { "input": "-1 2 0", "output": "NO" }, { "input": "-1 2 1", "output": "YES" }, { "input": "-1 2 2", "output": "NO" }, { "input": "0 -2 -2", "output": "YES" }, { "input": "0 -2 -1", "output": "YES" }, { "input": "0 -2 0", "output": "NO" }, { "input": "0 -2 1", "output": "NO" }, { "input": "0 -2 2", "output": "NO" }, { "input": "0 -1 -2", "output": "NO" }, { "input": "0 -1 -1", "output": "YES" }, { "input": "0 -1 0", "output": "NO" }, { "input": "0 -1 1", "output": "NO" }, { "input": "0 -1 2", "output": "NO" }, { "input": "0 0 -2", "output": "YES" }, { "input": "0 0 -1", "output": "YES" }, { "input": "0 0 0", "output": "YES" }, { "input": "0 0 1", "output": "YES" }, { "input": "0 0 2", "output": "YES" }, { "input": "0 1 -2", "output": "NO" }, { "input": "0 1 -1", "output": "NO" }, { "input": "0 1 0", "output": "NO" }, { "input": "0 1 1", "output": "YES" }, { "input": "0 1 2", "output": "NO" }, { "input": "0 2 -2", "output": "NO" }, { "input": "0 2 -1", "output": "NO" }, { "input": "0 2 0", "output": "NO" }, { "input": "0 2 1", "output": "YES" }, { "input": "0 2 2", "output": "YES" }, { "input": "1 -2 -2", "output": "NO" }, { "input": "1 -2 -1", "output": "YES" }, { "input": "1 -2 0", "output": "NO" }, { "input": "1 -2 1", "output": "NO" }, { "input": "1 -2 2", "output": "NO" }, { "input": "1 -1 -2", "output": "YES" }, { "input": "1 -1 -1", "output": "YES" }, { "input": "1 -1 0", "output": "NO" }, { "input": "1 -1 1", "output": "NO" }, { "input": "1 -1 2", "output": "NO" }, { "input": "1 0 -2", "output": "NO" }, { "input": "1 0 -1", "output": "YES" }, { "input": "1 0 0", "output": "NO" }, { "input": "1 0 1", "output": "NO" }, { "input": "1 0 2", "output": "NO" }, { "input": "1 1 -2", "output": "YES" }, { "input": "1 1 -1", "output": "YES" }, { "input": "1 1 0", "output": "YES" }, { "input": "1 1 1", "output": "YES" }, { "input": "1 1 2", "output": "YES" }, { "input": "1 2 -2", "output": "NO" }, { "input": "1 2 -1", "output": "NO" }, { "input": "1 2 0", "output": "NO" }, { "input": "1 2 1", "output": "YES" }, { "input": "1 2 2", "output": "NO" }, { "input": "2 -2 -2", "output": "YES" }, { "input": "2 -2 -1", "output": "YES" }, { "input": "2 -2 0", "output": "NO" }, { "input": "2 -2 1", "output": "NO" }, { "input": "2 -2 2", "output": "NO" }, { "input": "2 -1 -2", "output": "NO" }, { "input": "2 -1 -1", "output": "YES" }, { "input": "2 -1 0", "output": "NO" }, { "input": "2 -1 1", "output": "NO" }, { "input": "2 -1 2", "output": "NO" }, { "input": "2 0 -2", "output": "YES" }, { "input": "2 0 -1", "output": "YES" }, { "input": "2 0 0", "output": "NO" }, { "input": "2 0 1", "output": "NO" }, { "input": "2 0 2", "output": "NO" }, { "input": "2 1 -2", "output": "NO" }, { "input": "2 1 -1", "output": "YES" }, { "input": "2 1 0", "output": "NO" }, { "input": "2 1 1", "output": "NO" }, { "input": "2 1 2", "output": "NO" }, { "input": "2 2 -2", "output": "YES" }, { "input": "2 2 -1", "output": "YES" }, { "input": "2 2 0", "output": "YES" }, { "input": "2 2 1", "output": "YES" }, { "input": "2 2 2", "output": "YES" }, { "input": "-1000000000 1000000000 1", "output": "YES" }, { "input": "-1000000000 1000000000 2", "output": "YES" }, { "input": "1000000000 -1000000000 -1", "output": "YES" }, { "input": "5 2 3", "output": "NO" }, { "input": "2 1 -1", "output": "YES" }, { "input": "3 2 1", "output": "NO" }, { "input": "0 -5 -3", "output": "NO" }, { "input": "2 5 5", "output": "NO" }, { "input": "0 10 1", "output": "YES" }, { "input": "15 5 -5", "output": "YES" }, { "input": "2 1 1", "output": "NO" }, { "input": "20 10 0", "output": "NO" }, { "input": "20 15 5", "output": "NO" }, { "input": "1 6 1", "output": "YES" }, { "input": "1000000000 0 -1000000000", "output": "YES" }, { "input": "1 1 -5", "output": "YES" }, { "input": "4 6 1", "output": "YES" }, { "input": "-5 -10 -5", "output": "YES" }, { "input": "2 0 0", "output": "NO" }, { "input": "10 9 -1", "output": "YES" }, { "input": "-2 -1 -1", "output": "NO" }, { "input": "1 13 3", "output": "YES" }, { "input": "2 3 0", "output": "NO" }, { "input": "1 1 -1", "output": "YES" }, { "input": "5 -10 -5", "output": "YES" }, { "input": "5 3 1", "output": "NO" }, { "input": "1 1000000000 1", "output": "YES" }, { "input": "-1000000000 1000000000 1000000000", "output": "YES" } ]

1,463,934,182

2,147,483,647

PyPy 3

OK

TESTS

178

140

23,244,800

a, b, c = map(int,input().split()) if (a == b) or (c != 0 and ((b >= a and c > 0) or (b <= a and c < 0)) and (b - a) % c == 0): print("YES") else: print("NO")

Title: Infinite Sequence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya likes everything infinite. Now he is studying the properties of a sequence *s*, such that its first element is equal to *a* (*s*1<==<=*a*), and the difference between any two neighbouring elements is equal to *c* (*s**i*<=-<=*s**i*<=-<=1<==<=*c*). In particular, Vasya wonders if his favourite integer *b* appears in this sequence, that is, there exists a positive integer *i*, such that *s**i*<==<=*b*. Of course, you are the person he asks for a help. Input Specification: The first line of the input contain three integers *a*, *b* and *c* (<=-<=109<=≤<=*a*,<=*b*,<=*c*<=≤<=109) — the first element of the sequence, Vasya's favorite number and the difference between any two neighbouring elements of the sequence, respectively. Output Specification: If *b* appears in the sequence *s* print "YES" (without quotes), otherwise print "NO" (without quotes). Demo Input: ['1 7 3\n', '10 10 0\n', '1 -4 5\n', '0 60 50\n'] Demo Output: ['YES\n', 'YES\n', 'NO\n', 'NO\n'] Note: In the first sample, the sequence starts from integers 1, 4, 7, so 7 is its element. In the second sample, the favorite integer of Vasya is equal to the first element of the sequence. In the third sample all elements of the sequence are greater than Vasya's favorite integer. In the fourth sample, the sequence starts from 0, 50, 100, and all the following elements are greater than Vasya's favorite integer.

```python a, b, c = map(int,input().split()) if (a == b) or (c != 0 and ((b >= a and c > 0) or (b <= a and c < 0)) and (b - a) % c == 0): print("YES") else: print("NO") ```

3

997

B

Roman Digits

PROGRAMMING

2,000

[ "brute force", "combinatorics", "dp", "greedy", "math" ]

null

Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers $1$, $5$, $10$ and $50$ respectively. The use of other roman digits is not allowed. Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it. For example, the number XXXV evaluates to $35$ and the number IXI — to $12$. Pay attention to the difference to the traditional roman system — in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means $11$, not $9$. One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly $n$ roman digits I, V, X, L.

The only line of the input file contains a single integer $n$ ($1 \le n \le 10^9$) — the number of roman digits to use.

Output a single integer — the number of distinct integers which can be represented using $n$ roman digits exactly.

[ "1\n", "2\n", "10\n" ]

[ "4\n", "10\n", "244\n" ]

In the first sample there are exactly $4$ integers which can be represented — I, V, X and L. In the second sample it is possible to represent integers $2$ (II), $6$ (VI), $10$ (VV), $11$ (XI), $15$ (XV), $20$ (XX), $51$ (IL), $55$ (VL), $60$ (XL) and $100$ (LL).

1,250

[ { "input": "1", "output": "4" }, { "input": "2", "output": "10" }, { "input": "10", "output": "244" }, { "input": "1000", "output": "48753" }, { "input": "2000", "output": "97753" }, { "input": "5000", "output": "244753" }, { "input": "10000", "output": "489753" }, { "input": "111199", "output": "5448504" }, { "input": "101232812", "output": "4960407541" }, { "input": "1000000000", "output": "48999999753" }, { "input": "3", "output": "20" }, { "input": "4", "output": "35" }, { "input": "5", "output": "56" }, { "input": "6", "output": "83" }, { "input": "7", "output": "116" }, { "input": "8", "output": "155" }, { "input": "9", "output": "198" }, { "input": "11", "output": "292" }, { "input": "12", "output": "341" }, { "input": "13", "output": "390" }, { "input": "55", "output": "2448" }, { "input": "100", "output": "4653" }, { "input": "150", "output": "7103" }, { "input": "1200", "output": "58553" }, { "input": "9999999", "output": "489999704" }, { "input": "100000000", "output": "4899999753" }, { "input": "500000000", "output": "24499999753" }, { "input": "600000000", "output": "29399999753" }, { "input": "709000900", "output": "34741043853" }, { "input": "999999999", "output": "48999999704" }, { "input": "12", "output": "341" }, { "input": "10", "output": "244" }, { "input": "20", "output": "733" }, { "input": "35", "output": "1468" }, { "input": "56", "output": "2497" }, { "input": "83", "output": "3820" }, { "input": "116", "output": "5437" }, { "input": "155", "output": "7348" }, { "input": "198", "output": "9455" }, { "input": "244", "output": "11709" }, { "input": "292", "output": "14061" }, { "input": "14", "output": "439" } ]

1,530,617,255

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

93

0

x=[0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292] n=nu() print(x[n] if n<=11 else 292+(n-11)*49)

Title: Roman Digits Time Limit: None seconds Memory Limit: None megabytes Problem Description: Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers $1$, $5$, $10$ and $50$ respectively. The use of other roman digits is not allowed. Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it. For example, the number XXXV evaluates to $35$ and the number IXI — to $12$. Pay attention to the difference to the traditional roman system — in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means $11$, not $9$. One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly $n$ roman digits I, V, X, L. Input Specification: The only line of the input file contains a single integer $n$ ($1 \le n \le 10^9$) — the number of roman digits to use. Output Specification: Output a single integer — the number of distinct integers which can be represented using $n$ roman digits exactly. Demo Input: ['1\n', '2\n', '10\n'] Demo Output: ['4\n', '10\n', '244\n'] Note: In the first sample there are exactly $4$ integers which can be represented — I, V, X and L. In the second sample it is possible to represent integers $2$ (II), $6$ (VI), $10$ (VV), $11$ (XI), $15$ (XV), $20$ (XX), $51$ (IL), $55$ (VL), $60$ (XL) and $100$ (LL).

```python x=[0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292] n=nu() print(x[n] if n<=11 else 292+(n-11)*49) ```

-1

1,000

B

Light It Up

PROGRAMMING

1,500

[ "greedy" ]

null

Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment $0$ and turn power off at moment $M$. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp. The lamp allows only good programs. Good program can be represented as a non-empty array $a$, where $0 < a_1 < a_2 < \dots < a_{|a|} < M$. All $a_i$ must be integers. Of course, preinstalled program is a good program. The lamp follows program $a$ in next manner: at moment $0$ turns power and light on. Then at moment $a_i$ the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment $1$ and then do nothing, the total time when the lamp is lit will be $1$. Finally, at moment $M$ the lamp is turning its power off regardless of its state. Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program $a$, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of $a$, or even at the begining or at the end of $a$. Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from $x$ till moment $y$, then its lit for $y - x$ units of time. Segments of time when the lamp is lit are summed up.

First line contains two space separated integers $n$ and $M$ ($1 \le n \le 10^5$, $2 \le M \le 10^9$) — the length of program $a$ and the moment when power turns off. Second line contains $n$ space separated integers $a_1, a_2, \dots, a_n$ ($0 < a_1 < a_2 < \dots < a_n < M$) — initially installed program $a$.

Print the only integer — maximum possible total time when the lamp is lit.

[ "3 10\n4 6 7\n", "2 12\n1 10\n", "2 7\n3 4\n" ]

[ "8\n", "9\n", "6\n" ]

In the first example, one of possible optimal solutions is to insert value $x = 3$ before $a_1$, so program will be $[3, 4, 6, 7]$ and time of lamp being lit equals $(3 - 0) + (6 - 4) + (10 - 7) = 8$. Other possible solution is to insert $x = 5$ in appropriate place. In the second example, there is only one optimal solution: to insert $x = 2$ between $a_1$ and $a_2$. Program will become $[1, 2, 10]$, and answer will be $(1 - 0) + (10 - 2) = 9$. In the third example, optimal answer is to leave program untouched, so answer will be $(3 - 0) + (7 - 4) = 6$.

0

[ { "input": "3 10\n4 6 7", "output": "8" }, { "input": "2 12\n1 10", "output": "9" }, { "input": "2 7\n3 4", "output": "6" }, { "input": "1 2\n1", "output": "1" }, { "input": "5 10\n1 3 5 6 8", "output": "6" }, { "input": "7 1000000000\n1 10001 10011 20011 20021 40021 40031", "output": "999999969" }, { "input": "7 1000000000\n3 10001 10011 20011 20021 40021 40031", "output": "999999969" }, { "input": "1 10\n1", "output": "9" }, { "input": "1 10000000\n1", "output": "9999999" }, { "input": "1 8\n1", "output": "7" }, { "input": "7 17\n1 5 9 10 11 14 16", "output": "9" }, { "input": "4 17\n1 5 9 10", "output": "12" }, { "input": "5 12\n1 2 3 4 5", "output": "9" }, { "input": "2 1000000000\n100 111", "output": "999999989" }, { "input": "3 90591\n90579 90580 90581", "output": "90589" }, { "input": "5 16\n1 2 3 4 5", "output": "13" }, { "input": "6 981231233\n1 6 15 30 130 1875", "output": "981229468" }, { "input": "1 3\n1", "output": "2" }, { "input": "3 12\n4 7 11", "output": "8" }, { "input": "1 100000\n1", "output": "99999" }, { "input": "2 5\n1 3", "output": "3" }, { "input": "1 1000000000\n1", "output": "999999999" }, { "input": "1 1000000000\n999999999", "output": "999999999" }, { "input": "3 4\n1 2 3", "output": "2" }, { "input": "3 5\n1 2 3", "output": "3" }, { "input": "1 4\n2", "output": "3" }, { "input": "3 5\n1 3 4", "output": "3" }, { "input": "9 20\n5 9 11 12 14 15 16 17 19", "output": "12" }, { "input": "2 4\n1 2", "output": "3" }, { "input": "1 10\n2", "output": "9" }, { "input": "2 6\n2 4", "output": "4" }, { "input": "2 4\n1 3", "output": "2" }, { "input": "3 6\n1 2 4", "output": "4" }, { "input": "7 9863\n65 96 97 98 101 112 1115", "output": "9819" } ]

1,666,063,389

2,147,483,647

PyPy 3-64

RUNTIME_ERROR

TESTS

0

77

2,867,200

# -*- coding: utf-8 -*- """ Created on Tue Oct 18 10:28:32 2022 @author: 86158 """ def func(list): b = 0 for i in range(1,len(list),2): b+=list[i]-list[i-1] return b def func2(list2): b = 0 if list2[i]>1: for j in range(0,i,2): b+=list2[j] b+=list2[i]-1 if i%2==0: for j in range(i+1,len(list2),2): b+=list2[j] else: for j in range(i+2,len(list2),2): b+=list2[j] return b o,m = [int(i) for i in input().split()] list1 = [int(i) for i in input().split()] list2 = [0] for i in range(len(list1)-1): list2.append(list2[i+1]-list2[i]) list2.append(m) a = func(list2) for i in range(len(list2)): c = func2(list2) if a<c: a=c print(a)

Title: Light It Up Time Limit: None seconds Memory Limit: None megabytes Problem Description: Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment $0$ and turn power off at moment $M$. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp. The lamp allows only good programs. Good program can be represented as a non-empty array $a$, where $0 < a_1 < a_2 < \dots < a_{|a|} < M$. All $a_i$ must be integers. Of course, preinstalled program is a good program. The lamp follows program $a$ in next manner: at moment $0$ turns power and light on. Then at moment $a_i$ the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment $1$ and then do nothing, the total time when the lamp is lit will be $1$. Finally, at moment $M$ the lamp is turning its power off regardless of its state. Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program $a$, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of $a$, or even at the begining or at the end of $a$. Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from $x$ till moment $y$, then its lit for $y - x$ units of time. Segments of time when the lamp is lit are summed up. Input Specification: First line contains two space separated integers $n$ and $M$ ($1 \le n \le 10^5$, $2 \le M \le 10^9$) — the length of program $a$ and the moment when power turns off. Second line contains $n$ space separated integers $a_1, a_2, \dots, a_n$ ($0 < a_1 < a_2 < \dots < a_n < M$) — initially installed program $a$. Output Specification: Print the only integer — maximum possible total time when the lamp is lit. Demo Input: ['3 10\n4 6 7\n', '2 12\n1 10\n', '2 7\n3 4\n'] Demo Output: ['8\n', '9\n', '6\n'] Note: In the first example, one of possible optimal solutions is to insert value $x = 3$ before $a_1$, so program will be $[3, 4, 6, 7]$ and time of lamp being lit equals $(3 - 0) + (6 - 4) + (10 - 7) = 8$. Other possible solution is to insert $x = 5$ in appropriate place. In the second example, there is only one optimal solution: to insert $x = 2$ between $a_1$ and $a_2$. Program will become $[1, 2, 10]$, and answer will be $(1 - 0) + (10 - 2) = 9$. In the third example, optimal answer is to leave program untouched, so answer will be $(3 - 0) + (7 - 4) = 6$.

```python # -*- coding: utf-8 -*- """ Created on Tue Oct 18 10:28:32 2022 @author: 86158 """ def func(list): b = 0 for i in range(1,len(list),2): b+=list[i]-list[i-1] return b def func2(list2): b = 0 if list2[i]>1: for j in range(0,i,2): b+=list2[j] b+=list2[i]-1 if i%2==0: for j in range(i+1,len(list2),2): b+=list2[j] else: for j in range(i+2,len(list2),2): b+=list2[j] return b o,m = [int(i) for i in input().split()] list1 = [int(i) for i in input().split()] list2 = [0] for i in range(len(list1)-1): list2.append(list2[i+1]-list2[i]) list2.append(m) a = func(list2) for i in range(len(list2)): c = func2(list2) if a<c: a=c print(a) ```

-1

461

A

Appleman and Toastman

PROGRAMMING

1,200

[ "greedy", "sortings" ]

null

Appleman and Toastman play a game. Initially Appleman gives one group of *n* numbers to the Toastman, then they start to complete the following tasks: - Each time Toastman gets a group of numbers, he sums up all the numbers and adds this sum to the score. Then he gives the group to the Appleman. - Each time Appleman gets a group consisting of a single number, he throws this group out. Each time Appleman gets a group consisting of more than one number, he splits the group into two non-empty groups (he can do it in any way) and gives each of them to Toastman. After guys complete all the tasks they look at the score value. What is the maximum possible value of score they can get?

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=3·105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=106) — the initial group that is given to Toastman.

Print a single integer — the largest possible score.

[ "3\n3 1 5\n", "1\n10\n" ]

[ "26\n", "10\n" ]

Consider the following situation in the first example. Initially Toastman gets group [3, 1, 5] and adds 9 to the score, then he give the group to Appleman. Appleman splits group [3, 1, 5] into two groups: [3, 5] and [1]. Both of them should be given to Toastman. When Toastman receives group [1], he adds 1 to score and gives the group to Appleman (he will throw it out). When Toastman receives group [3, 5], he adds 8 to the score and gives the group to Appleman. Appleman splits [3, 5] in the only possible way: [5] and [3]. Then he gives both groups to Toastman. When Toastman receives [5], he adds 5 to the score and gives the group to Appleman (he will throws it out). When Toastman receives [3], he adds 3 to the score and gives the group to Appleman (he will throws it out). Finally Toastman have added 9 + 1 + 8 + 5 + 3 = 26 to the score. This is the optimal sequence of actions.

500

[ { "input": "3\n3 1 5", "output": "26" }, { "input": "1\n10", "output": "10" }, { "input": "10\n8 10 2 5 6 2 4 7 2 1", "output": "376" }, { "input": "10\n171308 397870 724672 431255 228496 892002 542924 718337 888642 161821", "output": "40204082" }, { "input": "10\n1 2 2 2 4 5 6 7 8 10", "output": "376" }, { "input": "10\n161821 171308 228496 397870 431255 542924 718337 724672 888642 892002", "output": "40204082" }, { "input": "1\n397870", "output": "397870" }, { "input": "1\n1000000", "output": "1000000" }, { "input": "10\n10 8 7 6 5 4 2 2 2 1", "output": "376" }, { "input": "10\n892002 888642 724672 718337 542924 431255 397870 228496 171308 161821", "output": "40204082" }, { "input": "10\n5 2 6 10 10 10 10 2 2 5", "output": "485" }, { "input": "10\n431255 724672 228496 397870 397870 397870 397870 724672 888642 431255", "output": "36742665" }, { "input": "10\n2 2 2 5 5 6 10 10 10 10", "output": "485" }, { "input": "10\n228496 397870 397870 397870 397870 431255 431255 724672 724672 888642", "output": "36742665" }, { "input": "10\n10 10 10 10 6 5 5 2 2 2", "output": "485" }, { "input": "10\n888642 724672 724672 431255 431255 397870 397870 397870 397870 228496", "output": "36742665" }, { "input": "10\n10 10 10 10 10 10 10 10 10 10", "output": "640" }, { "input": "10\n1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000 1000000", "output": "64000000" }, { "input": "1\n397870", "output": "397870" }, { "input": "2\n1 2", "output": "6" }, { "input": "2\n2 3", "output": "10" }, { "input": "2\n1 1", "output": "4" } ]

1,512,605,135

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

6

2,000

11,161,600

n=int(input()) a=input().split() list1=[] for i in a: list1.append(int(i)) list1.sort() b=0 score=0 while b<=n: for x in list1[b:]: score=score+x b=b+1 for y in list1[:n-1]: score=score+y print(score)

Title: Appleman and Toastman Time Limit: None seconds Memory Limit: None megabytes Problem Description: Appleman and Toastman play a game. Initially Appleman gives one group of *n* numbers to the Toastman, then they start to complete the following tasks: - Each time Toastman gets a group of numbers, he sums up all the numbers and adds this sum to the score. Then he gives the group to the Appleman. - Each time Appleman gets a group consisting of a single number, he throws this group out. Each time Appleman gets a group consisting of more than one number, he splits the group into two non-empty groups (he can do it in any way) and gives each of them to Toastman. After guys complete all the tasks they look at the score value. What is the maximum possible value of score they can get? Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=3·105). The second line contains *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=106) — the initial group that is given to Toastman. Output Specification: Print a single integer — the largest possible score. Demo Input: ['3\n3 1 5\n', '1\n10\n'] Demo Output: ['26\n', '10\n'] Note: Consider the following situation in the first example. Initially Toastman gets group [3, 1, 5] and adds 9 to the score, then he give the group to Appleman. Appleman splits group [3, 1, 5] into two groups: [3, 5] and [1]. Both of them should be given to Toastman. When Toastman receives group [1], he adds 1 to score and gives the group to Appleman (he will throw it out). When Toastman receives group [3, 5], he adds 8 to the score and gives the group to Appleman. Appleman splits [3, 5] in the only possible way: [5] and [3]. Then he gives both groups to Toastman. When Toastman receives [5], he adds 5 to the score and gives the group to Appleman (he will throws it out). When Toastman receives [3], he adds 3 to the score and gives the group to Appleman (he will throws it out). Finally Toastman have added 9 + 1 + 8 + 5 + 3 = 26 to the score. This is the optimal sequence of actions.

```python n=int(input()) a=input().split() list1=[] for i in a: list1.append(int(i)) list1.sort() b=0 score=0 while b<=n: for x in list1[b:]: score=score+x b=b+1 for y in list1[:n-1]: score=score+y print(score) ```

0

612

A

The Text Splitting

PROGRAMMING

1,300

[ "brute force", "implementation", "strings" ]

null

You are given the string *s* of length *n* and the numbers *p*,<=*q*. Split the string *s* to pieces of length *p* and *q*. For example, the string "Hello" for *p*<==<=2, *q*<==<=3 can be split to the two strings "Hel" and "lo" or to the two strings "He" and "llo". Note it is allowed to split the string *s* to the strings only of length *p* or to the strings only of length *q* (see the second sample test).

The first line contains three positive integers *n*,<=*p*,<=*q* (1<=≤<=*p*,<=*q*<=≤<=*n*<=≤<=100). The second line contains the string *s* consists of lowercase and uppercase latin letters and digits.

If it's impossible to split the string *s* to the strings of length *p* and *q* print the only number "-1". Otherwise in the first line print integer *k* — the number of strings in partition of *s*. Each of the next *k* lines should contain the strings in partition. Each string should be of the length *p* or *q*. The string should be in order of their appearing in string *s* — from left to right. If there are several solutions print any of them.

[ "5 2 3\nHello\n", "10 9 5\nCodeforces\n", "6 4 5\nPrivet\n", "8 1 1\nabacabac\n" ]

[ "2\nHe\nllo\n", "2\nCodef\norces\n", "-1\n", "8\na\nb\na\nc\na\nb\na\nc\n" ]

none

0

[ { "input": "5 2 3\nHello", "output": "2\nHe\nllo" }, { "input": "10 9 5\nCodeforces", "output": "2\nCodef\norces" }, { "input": "6 4 5\nPrivet", "output": "-1" }, { "input": "8 1 1\nabacabac", "output": "8\na\nb\na\nc\na\nb\na\nc" }, { "input": "1 1 1\n1", "output": "1\n1" }, { "input": "10 8 1\nuTl9w4lcdo", "output": "10\nu\nT\nl\n9\nw\n4\nl\nc\nd\no" }, { "input": "20 6 4\nfmFRpk2NrzSvnQC9gB61", "output": "5\nfmFR\npk2N\nrzSv\nnQC9\ngB61" }, { "input": "30 23 6\nWXDjl9kitaDTY673R5xyTlbL9gqeQ6", "output": "5\nWXDjl9\nkitaDT\nY673R5\nxyTlbL\n9gqeQ6" }, { "input": "40 14 3\nSOHBIkWEv7ScrkHgMtFFxP9G7JQLYXFoH1sJDAde", "output": "6\nSOHBIkWEv7Scrk\nHgMtFFxP9G7JQL\nYXF\noH1\nsJD\nAde" }, { "input": "50 16 3\nXCgVJUu4aMQ7HMxZjNxe3XARNiahK303g9y7NV8oN6tWdyXrlu", "output": "8\nXCgVJUu4aMQ7HMxZ\njNxe3XARNiahK303\ng9y\n7NV\n8oN\n6tW\ndyX\nrlu" }, { "input": "60 52 8\nhae0PYwXcW2ziQCOSci5VaElHLZCZI81ULSHgpyG3fuZaP0fHjN4hCKogONj", "output": "2\nhae0PYwXcW2ziQCOSci5VaElHLZCZI81ULSHgpyG3fuZaP0fHjN4\nhCKogONj" }, { "input": "70 50 5\n1BH1ECq7hjzooQOZdbiYHTAgATcP5mxI7kLI9rqA9AriWc9kE5KoLa1zmuTDFsd2ClAPPY", "output": "14\n1BH1E\nCq7hj\nzooQO\nZdbiY\nHTAgA\nTcP5m\nxI7kL\nI9rqA\n9AriW\nc9kE5\nKoLa1\nzmuTD\nFsd2C\nlAPPY" }, { "input": "80 51 8\no2mpu1FCofuiLQb472qczCNHfVzz5TfJtVMrzgN3ff7FwlAY0fQ0ROhWmIX2bggodORNA76bHMjA5yyc", "output": "10\no2mpu1FC\nofuiLQb4\n72qczCNH\nfVzz5TfJ\ntVMrzgN3\nff7FwlAY\n0fQ0ROhW\nmIX2bggo\ndORNA76b\nHMjA5yyc" }, { "input": "90 12 7\nclcImtsw176FFOA6OHGFxtEfEyhFh5bH4iktV0Y8onIcn0soTwiiHUFRWC6Ow36tT5bsQjgrVSTcB8fAVoe7dJIWkE", "output": "10\nclcImtsw176F\nFOA6OHGFxtEf\nEyhFh5bH4ikt\nV0Y8onIcn0so\nTwiiHUF\nRWC6Ow3\n6tT5bsQ\njgrVSTc\nB8fAVoe\n7dJIWkE" }, { "input": "100 25 5\n2SRB9mRpXMRND5zQjeRxc4GhUBlEQSmLgnUtB9xTKoC5QM9uptc8dKwB88XRJy02r7edEtN2C6D60EjzK1EHPJcWNj6fbF8kECeB", "output": "20\n2SRB9\nmRpXM\nRND5z\nQjeRx\nc4GhU\nBlEQS\nmLgnU\ntB9xT\nKoC5Q\nM9upt\nc8dKw\nB88XR\nJy02r\n7edEt\nN2C6D\n60Ejz\nK1EHP\nJcWNj\n6fbF8\nkECeB" }, { "input": "100 97 74\nxL8yd8lENYnXZs28xleyci4SxqsjZqkYzkEbQXfLQ4l4gKf9QQ9xjBjeZ0f9xQySf5psDUDkJEtPLsa62n4CLc6lF6E2yEqvt4EJ", "output": "-1" }, { "input": "51 25 11\nwpk5wqrB6d3qE1slUrzJwMFafnnOu8aESlvTEb7Pp42FDG2iGQn", "output": "-1" }, { "input": "70 13 37\nfzL91QIJvNoZRP4A9aNRT2GTksd8jEb1713pnWFaCGKHQ1oYvlTHXIl95lqyZRKJ1UPYvT", "output": "-1" }, { "input": "10 3 1\nXQ2vXLPShy", "output": "10\nX\nQ\n2\nv\nX\nL\nP\nS\nh\ny" }, { "input": "4 2 3\naaaa", "output": "2\naa\naa" }, { "input": "100 1 1\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "100\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb\nb" }, { "input": "99 2 4\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "-1" }, { "input": "11 2 3\nhavanahavan", "output": "4\nha\nvan\naha\nvan" }, { "input": "100 2 2\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "50\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa\naa" }, { "input": "17 3 5\ngopstopmipodoshli", "output": "5\ngop\nsto\npmi\npod\noshli" }, { "input": "5 4 3\nfoyku", "output": "-1" }, { "input": "99 2 2\n123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789", "output": "-1" }, { "input": "99 2 2\nrecursionishellrecursionishellrecursionishellrecursionishellrecursionishellrecursionishelldontuseit", "output": "-1" }, { "input": "11 2 3\nqibwnnvqqgo", "output": "4\nqi\nbwn\nnvq\nqgo" }, { "input": "4 4 3\nhhhh", "output": "1\nhhhh" }, { "input": "99 2 2\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "-1" }, { "input": "99 2 5\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh", "output": "21\nhh\nhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh\nhhhhh" }, { "input": "10 5 9\nCodeforces", "output": "2\nCodef\norces" }, { "input": "10 5 9\naaaaaaaaaa", "output": "2\naaaaa\naaaaa" }, { "input": "11 3 2\nmlmqpohwtsf", "output": "5\nmlm\nqp\noh\nwt\nsf" }, { "input": "3 3 2\nzyx", "output": "1\nzyx" }, { "input": "100 3 3\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "-1" }, { "input": "4 2 3\nzyxw", "output": "2\nzy\nxw" }, { "input": "3 2 3\nejt", "output": "1\nejt" }, { "input": "5 2 4\nzyxwv", "output": "-1" }, { "input": "100 1 1\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "100\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na" }, { "input": "100 5 4\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "25\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa\naaaa" }, { "input": "3 2 2\nzyx", "output": "-1" }, { "input": "99 2 2\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh", "output": "-1" }, { "input": "26 8 9\nabcabcabcabcabcabcabcabcab", "output": "3\nabcabcab\ncabcabcab\ncabcabcab" }, { "input": "6 3 5\naaaaaa", "output": "2\naaa\naaa" }, { "input": "3 2 3\nzyx", "output": "1\nzyx" }, { "input": "5 5 2\naaaaa", "output": "1\naaaaa" }, { "input": "4 3 2\nzyxw", "output": "2\nzy\nxw" }, { "input": "5 4 3\nzyxwv", "output": "-1" }, { "input": "95 3 29\nabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcab", "output": "23\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabc\nabcabcabcabcabcabcabcabcabcab" }, { "input": "3 2 2\naaa", "output": "-1" }, { "input": "91 62 3\nfjzhkfwzoabaauvbkuzaahkozofaophaafhfpuhobufawkzbavaazwavwppfwapkapaofbfjwaavajojgjguahphofj", "output": "-1" }, { "input": "99 2 2\nabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "output": "-1" }, { "input": "56 13 5\nabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcab", "output": "8\nabcabcabcabca\nbcabcabcabcab\ncabca\nbcabc\nabcab\ncabca\nbcabc\nabcab" }, { "input": "79 7 31\nabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabca", "output": "-1" }, { "input": "92 79 6\nxlvplpckwnhmctoethhslkcyashqtsoeltriddglfwtgkfvkvgytygbcyohrvcxvosdioqvackxiuifmkgdngvbbudcb", "output": "-1" }, { "input": "48 16 13\nibhfinipihcbsqnvtgsbkobepmwymlyfmlfgblvhlfhyojsy", "output": "3\nibhfinipihcbsqnv\ntgsbkobepmwymlyf\nmlfgblvhlfhyojsy" }, { "input": "16 3 7\naaaaaaaaaaaaaaaa", "output": "4\naaa\naaa\naaa\naaaaaaa" }, { "input": "11 10 3\naaaaaaaaaaa", "output": "-1" }, { "input": "11 8 8\naaaaaaaaaaa", "output": "-1" }, { "input": "11 7 3\naaaaaaaaaaa", "output": "-1" }, { "input": "41 3 4\nabcabcabcabcabcabcabcabcabcabcabcabcabcab", "output": "11\nabc\nabc\nabc\nabca\nbcab\ncabc\nabca\nbcab\ncabc\nabca\nbcab" }, { "input": "11 3 2\naaaaaaaaaaa", "output": "5\naaa\naa\naa\naa\naa" }, { "input": "14 9 4\nabcdefghijklmn", "output": "-1" }, { "input": "9 9 5\n123456789", "output": "1\n123456789" }, { "input": "92 10 41\nmeotryyfneonmnrvfnhqlehlxtvpracifpadcofecvbikoitrlgeftiqofpvacgocrdiquhatlqosqvtduenaqkwrnnw", "output": "3\nmeotryyfne\nonmnrvfnhqlehlxtvpracifpadcofecvbikoitrlg\neftiqofpvacgocrdiquhatlqosqvtduenaqkwrnnw" }, { "input": "17 16 3\ndxyhgtsxtuyljmclj", "output": "-1" }, { "input": "82 13 30\nfmtwumakkejtolxqxrnydhqoufwtdwldfxcfjrndauqcarhbwmdwxsxfbqjsfspuxobywhcrvlndsdmkqd", "output": "5\nfmtwumakkejto\nlxqxrnydhqouf\nwtdwldfxcfjrn\ndauqcarhbwmdw\nxsxfbqjsfspuxobywhcrvlndsdmkqd" }, { "input": "95 3 3\nihnfqcswushyoirjxlxxnwqtwtaowounkumxukwpacxwatimhhhoggqwkkspcplvyndfukbxickcixidgxkjtnpkoeiwlor", "output": "-1" }, { "input": "7 5 3\nzyxwvut", "output": "-1" }, { "input": "17 16 4\nctvfhkiakagcilrdw", "output": "-1" } ]

1,550,604,127

2,147,483,647

Python 3

OK

TESTS

72

109

0

def main(): n,p,q=map(int,input().split()) ch= input() d=0 test=False for i in range(100): for j in range(100): if i*p+j*q==n: pp,qq=i,j test = True break if test: break if test==False: print(-1) else: print(pp+qq) for i in range(pp): print(ch[d:d+p]) d+=p for i in range(qq): print(ch[d:d+q]) d+=q main()

Title: The Text Splitting Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given the string *s* of length *n* and the numbers *p*,<=*q*. Split the string *s* to pieces of length *p* and *q*. For example, the string "Hello" for *p*<==<=2, *q*<==<=3 can be split to the two strings "Hel" and "lo" or to the two strings "He" and "llo". Note it is allowed to split the string *s* to the strings only of length *p* or to the strings only of length *q* (see the second sample test). Input Specification: The first line contains three positive integers *n*,<=*p*,<=*q* (1<=≤<=*p*,<=*q*<=≤<=*n*<=≤<=100). The second line contains the string *s* consists of lowercase and uppercase latin letters and digits. Output Specification: If it's impossible to split the string *s* to the strings of length *p* and *q* print the only number "-1". Otherwise in the first line print integer *k* — the number of strings in partition of *s*. Each of the next *k* lines should contain the strings in partition. Each string should be of the length *p* or *q*. The string should be in order of their appearing in string *s* — from left to right. If there are several solutions print any of them. Demo Input: ['5 2 3\nHello\n', '10 9 5\nCodeforces\n', '6 4 5\nPrivet\n', '8 1 1\nabacabac\n'] Demo Output: ['2\nHe\nllo\n', '2\nCodef\norces\n', '-1\n', '8\na\nb\na\nc\na\nb\na\nc\n'] Note: none

```python def main(): n,p,q=map(int,input().split()) ch= input() d=0 test=False for i in range(100): for j in range(100): if i*p+j*q==n: pp,qq=i,j test = True break if test: break if test==False: print(-1) else: print(pp+qq) for i in range(pp): print(ch[d:d+p]) d+=p for i in range(qq): print(ch[d:d+q]) d+=q main() ```

3

433

A

Kitahara Haruki's Gift

PROGRAMMING

1,100

[ "brute force", "implementation" ]

null

Kitahara Haruki has bought *n* apples for Touma Kazusa and Ogiso Setsuna. Now he wants to divide all the apples between the friends. Each apple weights 100 grams or 200 grams. Of course Kitahara Haruki doesn't want to offend any of his friend. Therefore the total weight of the apples given to Touma Kazusa must be equal to the total weight of the apples given to Ogiso Setsuna. But unfortunately Kitahara Haruki doesn't have a knife right now, so he cannot split any apple into some parts. Please, tell him: is it possible to divide all the apples in a fair way between his friends?

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of apples. The second line contains *n* integers *w*1,<=*w*2,<=...,<=*w**n* (*w**i*<==<=100 or *w**i*<==<=200), where *w**i* is the weight of the *i*-th apple.

In a single line print "YES" (without the quotes) if it is possible to divide all the apples between his friends. Otherwise print "NO" (without the quotes).

[ "3\n100 200 100\n", "4\n100 100 100 200\n" ]

[ "YES\n", "NO\n" ]

In the first test sample Kitahara Haruki can give the first and the last apple to Ogiso Setsuna and the middle apple to Touma Kazusa.

500

[ { "input": "3\n100 200 100", "output": "YES" }, { "input": "4\n100 100 100 200", "output": "NO" }, { "input": "1\n100", "output": "NO" }, { "input": "1\n200", "output": "NO" }, { "input": "2\n100 100", "output": "YES" }, { "input": "2\n200 200", "output": "YES" }, { "input": "100\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "YES" }, { "input": "100\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "NO" }, { "input": "52\n200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 100 200 100 200 200 200 100 200 200", "output": "YES" }, { "input": "2\n100 200", "output": "NO" }, { "input": "2\n200 100", "output": "NO" }, { "input": "3\n100 100 100", "output": "NO" }, { "input": "3\n200 200 200", "output": "NO" }, { "input": "3\n200 100 200", "output": "NO" }, { "input": "4\n100 100 100 100", "output": "YES" }, { "input": "4\n200 200 200 200", "output": "YES" }, { "input": "100\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "YES" }, { "input": "100\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 100 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "NO" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "YES" }, { "input": "100\n100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "NO" }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "YES" }, { "input": "100\n100 100 100 100 100 100 100 100 200 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "NO" }, { "input": "99\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "NO" }, { "input": "99\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "NO" }, { "input": "99\n200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "YES" }, { "input": "99\n200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200", "output": "NO" }, { "input": "99\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "NO" }, { "input": "99\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "YES" }, { "input": "99\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "NO" }, { "input": "100\n100 100 200 100 100 200 200 200 200 100 200 100 100 100 200 100 100 100 100 200 100 100 100 100 100 100 200 100 100 200 200 100 100 100 200 200 200 100 200 200 100 200 100 100 200 100 200 200 100 200 200 100 100 200 200 100 200 200 100 100 200 100 200 100 200 200 200 200 200 100 200 200 200 200 200 200 100 100 200 200 200 100 100 100 200 100 100 200 100 100 100 200 200 100 100 200 200 200 200 100", "output": "YES" }, { "input": "100\n100 100 200 200 100 200 100 100 100 100 100 100 200 100 200 200 200 100 100 200 200 200 200 200 100 200 100 200 100 100 100 200 100 100 200 100 200 100 100 100 200 200 100 100 100 200 200 200 200 200 100 200 200 100 100 100 100 200 100 100 200 100 100 100 100 200 200 200 100 200 100 200 200 200 100 100 200 200 200 200 100 200 100 200 200 100 200 100 200 200 200 200 200 200 100 100 100 200 200 100", "output": "NO" }, { "input": "100\n100 200 100 100 200 200 200 200 100 200 200 200 200 200 200 200 200 200 100 100 100 200 200 200 200 200 100 200 200 200 200 100 200 200 100 100 200 100 100 100 200 100 100 100 200 100 200 100 200 200 200 100 100 200 100 200 100 200 100 100 100 200 100 200 100 100 100 100 200 200 200 200 100 200 200 100 200 100 100 100 200 100 100 100 100 100 200 100 100 100 200 200 200 100 200 100 100 100 200 200", "output": "YES" }, { "input": "99\n100 200 200 200 100 200 100 200 200 100 100 100 100 200 100 100 200 100 200 100 100 200 100 100 200 200 100 100 100 100 200 200 200 200 200 100 100 200 200 100 100 100 100 200 200 100 100 100 100 100 200 200 200 100 100 100 200 200 200 100 200 100 100 100 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 100 200 100 200 200 200 200 100 200 100 100 100 100 100 100 100 100 100", "output": "YES" }, { "input": "99\n100 200 100 100 100 100 200 200 100 200 100 100 200 100 100 100 100 100 100 200 100 100 100 100 100 100 100 200 100 200 100 100 100 100 100 100 100 200 200 200 200 200 200 200 100 200 100 200 100 200 100 200 100 100 200 200 200 100 200 200 200 200 100 200 100 200 200 200 200 100 200 100 200 200 100 200 200 200 200 200 100 100 200 100 100 100 100 200 200 200 100 100 200 200 200 200 200 200 200", "output": "NO" }, { "input": "99\n200 100 100 100 200 200 200 100 100 100 100 100 100 100 100 100 200 200 100 200 200 100 200 100 100 200 200 200 100 200 100 200 200 100 200 100 200 200 200 100 100 200 200 200 200 100 100 100 100 200 200 200 200 100 200 200 200 100 100 100 200 200 200 100 200 100 200 100 100 100 200 100 200 200 100 200 200 200 100 100 100 200 200 200 100 200 200 200 100 100 100 200 100 200 100 100 100 200 200", "output": "YES" }, { "input": "56\n100 200 200 200 200 200 100 200 100 100 200 100 100 100 100 100 200 200 200 100 200 100 100 200 200 200 100 200 100 200 200 100 100 100 100 100 200 100 200 100 200 200 200 100 100 200 200 200 200 200 200 200 200 200 200 100", "output": "YES" }, { "input": "72\n200 100 200 200 200 100 100 200 200 100 100 100 100 200 100 200 100 100 100 100 200 100 200 100 100 200 100 100 200 100 200 100 100 200 100 200 100 100 200 200 200 200 200 100 100 200 200 200 200 100 100 100 200 200 100 100 100 100 100 200 100 100 200 100 100 200 200 100 100 200 100 200", "output": "YES" }, { "input": "32\n200 200 200 100 100 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 200 200 200 200 200", "output": "YES" }, { "input": "48\n200 200 200 200 200 200 100 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 200 100 200 100 200 200 200 200 200 200", "output": "NO" }, { "input": "60\n100 100 200 200 100 200 100 200 100 100 100 100 100 100 200 100 100 100 200 100 200 100 100 100 100 100 200 100 200 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 200 100 100 100", "output": "YES" }, { "input": "24\n200 200 100 100 200 100 200 200 100 200 200 200 200 200 100 200 200 200 200 200 200 200 200 100", "output": "YES" }, { "input": "40\n100 100 200 200 200 200 100 100 100 200 100 100 200 200 100 100 100 100 100 200 100 200 200 100 200 200 200 100 100 100 100 100 200 200 100 200 100 100 200 100", "output": "NO" }, { "input": "5\n200 200 200 200 200", "output": "NO" }, { "input": "9\n100 100 100 200 100 100 200 100 200", "output": "YES" }, { "input": "1\n200", "output": "NO" }, { "input": "7\n200 200 200 100 200 200 200", "output": "NO" }, { "input": "4\n100 100 200 200", "output": "YES" }, { "input": "6\n100 100 100 200 200 200", "output": "NO" }, { "input": "4\n200 100 100 200", "output": "YES" }, { "input": "5\n100 100 100 100 200", "output": "YES" } ]

1,668,785,025

2,147,483,647

PyPy 3-64

OK

TESTS

50

62

0

n = int(input()) c = list(map(str,input().split())) hund = c.count('100') twohund = c.count('200') if hund==0 and twohund%2==0: print('YES') elif twohund==0 and hund%2==0: print("YES") elif twohund%2==0 and hund%2==0: print("YES") elif twohund%2==1 and hund%2==0 and hund>0 : print("YES") else:print('NO')

Title: Kitahara Haruki's Gift Time Limit: None seconds Memory Limit: None megabytes Problem Description: Kitahara Haruki has bought *n* apples for Touma Kazusa and Ogiso Setsuna. Now he wants to divide all the apples between the friends. Each apple weights 100 grams or 200 grams. Of course Kitahara Haruki doesn't want to offend any of his friend. Therefore the total weight of the apples given to Touma Kazusa must be equal to the total weight of the apples given to Ogiso Setsuna. But unfortunately Kitahara Haruki doesn't have a knife right now, so he cannot split any apple into some parts. Please, tell him: is it possible to divide all the apples in a fair way between his friends? Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of apples. The second line contains *n* integers *w*1,<=*w*2,<=...,<=*w**n* (*w**i*<==<=100 or *w**i*<==<=200), where *w**i* is the weight of the *i*-th apple. Output Specification: In a single line print "YES" (without the quotes) if it is possible to divide all the apples between his friends. Otherwise print "NO" (without the quotes). Demo Input: ['3\n100 200 100\n', '4\n100 100 100 200\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first test sample Kitahara Haruki can give the first and the last apple to Ogiso Setsuna and the middle apple to Touma Kazusa.

```python n = int(input()) c = list(map(str,input().split())) hund = c.count('100') twohund = c.count('200') if hund==0 and twohund%2==0: print('YES') elif twohund==0 and hund%2==0: print("YES") elif twohund%2==0 and hund%2==0: print("YES") elif twohund%2==1 and hund%2==0 and hund>0 : print("YES") else:print('NO') ```

3

598

D

Igor In the Museum

PROGRAMMING

1,700

[ "dfs and similar", "graphs", "shortest paths" ]

null

Igor is in the museum and he wants to see as many pictures as possible. Museum can be represented as a rectangular field of *n*<=×<=*m* cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture. At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one. For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.

First line of the input contains three integers *n*, *m* and *k* (3<=≤<=*n*,<=*m*<=≤<=1000,<=1<=≤<=*k*<=≤<=*min*(*n*·*m*,<=100<=000)) — the museum dimensions and the number of starting positions to process. Each of the next *n* lines contains *m* symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum. Each of the last *k* lines contains two integers *x* and *y* (1<=≤<=*x*<=≤<=*n*,<=1<=≤<=*y*<=≤<=*m*) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.

Print *k* integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.

[ "5 6 3\n******\n*..*.*\n******\n*....*\n******\n2 2\n2 5\n4 3\n", "4 4 1\n****\n*..*\n*.**\n****\n3 2\n" ]

[ "6\n4\n10\n", "8\n" ]

none

0

[ { "input": "5 6 3\n******\n*..*.*\n******\n*....*\n******\n2 2\n2 5\n4 3", "output": "6\n4\n10" }, { "input": "4 4 1\n****\n*..*\n*.**\n****\n3 2", "output": "8" }, { "input": "3 3 1\n***\n*.*\n***\n2 2", "output": "4" }, { "input": "5 5 10\n*****\n*...*\n*..**\n*.***\n*****\n2 4\n4 2\n2 2\n2 3\n2 2\n2 2\n2 4\n3 2\n2 2\n2 2", "output": "12\n12\n12\n12\n12\n12\n12\n12\n12\n12" }, { "input": "10 3 10\n***\n*.*\n*.*\n***\n***\n*.*\n*.*\n*.*\n*.*\n***\n2 2\n2 2\n2 2\n2 2\n8 2\n2 2\n2 2\n7 2\n8 2\n6 2", "output": "6\n6\n6\n6\n10\n6\n6\n10\n10\n10" }, { "input": "3 10 10\n**********\n***.*.*..*\n**********\n2 6\n2 6\n2 9\n2 9\n2 4\n2 9\n2 6\n2 6\n2 4\n2 6", "output": "4\n4\n6\n6\n4\n6\n4\n4\n4\n4" }, { "input": "10 10 50\n**********\n*......***\n***..**..*\n***....***\n**..***..*\n**..**.*.*\n*****..***\n*.***..***\n*..****.**\n**********\n5 9\n5 9\n7 7\n6 4\n6 7\n8 7\n6 7\n9 2\n3 9\n9 2\n4 7\n4 6\n2 7\n9 2\n7 7\n5 8\n8 7\n8 6\n7 7\n5 9\n8 7\n3 8\n3 8\n5 9\n9 8\n9 3\n8 7\n5 9\n9 2\n9 8\n9 3\n3 8\n9 2\n8 6\n2 4\n6 9\n6 3\n9 8\n3 9\n9 8\n4 5\n8 6\n3 8\n5 9\n8 7\n5 8\n6 9\n8 2\n3 9\n3 9", "output": "8\n8\n10\n28\n10\n10\n10\n8\n6\n8\n28\n28\n28\n8\n10\n8\n10\n10\n10\n8\n10\n6\n6\n8\n4\n8\n10\n8\n8\n4\n8\n6\n8\n10\n28\n8\n28\n4\n6\n4\n28\n10\n6\n8\n10\n8\n8\n8\n6\n6" }, { "input": "5 5 21\n*****\n*.***\n*****\n*****\n*****\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2\n2 2", "output": "4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4\n4" } ]

1,642,092,076

2,147,483,647

PyPy 3-64

TIME_LIMIT_EXCEEDED

TESTS

14

1,000

212,582,400

from collections import Counter from types import GeneratorType import sys input = sys.stdin.readline def bootstrap(f, stack=[]): def wrappedfunc(*args, **kwargs): if stack: return f(*args, **kwargs) else: to = f(*args, **kwargs) while True: if type(to) is GeneratorType: stack.append(to) to = next(to) else: stack.pop() if not stack: break to = stack[-1].send(to) return to return wrappedfunc n, m, k = [int(i) for i in input().split()] grid = [] queries = [] for _ in range(n): grid += [[i for i in input()]] for _ in range(k): queries += [[int(i) for i in input().split()]] visited = set() d = Counter() @bootstrap def dfs(x, y, i): grid[y][x] = str(i) for dx, dy in (x, y-1), (x, y+1), (x-1, y), (x+1, y): if grid[dy][dx] not in "*.": continue if grid[dy][dx] == "*": d[i] += 1 else: yield dfs(dx, dy, i) yield -1 i = 0 for x in range(m): for y in range(n): if grid[y][x] == ".": #print(x, y, i) dfs(x, y, i) i += 1 ans = [d[int(grid[x-1][y-1])] for x, y in queries] print(" ".join(str(x) for x in ans))

Title: Igor In the Museum Time Limit: None seconds Memory Limit: None megabytes Problem Description: Igor is in the museum and he wants to see as many pictures as possible. Museum can be represented as a rectangular field of *n*<=×<=*m* cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture. At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one. For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see. Input Specification: First line of the input contains three integers *n*, *m* and *k* (3<=≤<=*n*,<=*m*<=≤<=1000,<=1<=≤<=*k*<=≤<=*min*(*n*·*m*,<=100<=000)) — the museum dimensions and the number of starting positions to process. Each of the next *n* lines contains *m* symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum. Each of the last *k* lines contains two integers *x* and *y* (1<=≤<=*x*<=≤<=*n*,<=1<=≤<=*y*<=≤<=*m*) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells. Output Specification: Print *k* integers — the maximum number of pictures, that Igor can see if he starts in corresponding position. Demo Input: ['5 6 3\n******\n*..*.*\n******\n*....*\n******\n2 2\n2 5\n4 3\n', '4 4 1\n****\n*..*\n*.**\n****\n3 2\n'] Demo Output: ['6\n4\n10\n', '8\n'] Note: none

```python from collections import Counter from types import GeneratorType import sys input = sys.stdin.readline def bootstrap(f, stack=[]): def wrappedfunc(*args, **kwargs): if stack: return f(*args, **kwargs) else: to = f(*args, **kwargs) while True: if type(to) is GeneratorType: stack.append(to) to = next(to) else: stack.pop() if not stack: break to = stack[-1].send(to) return to return wrappedfunc n, m, k = [int(i) for i in input().split()] grid = [] queries = [] for _ in range(n): grid += [[i for i in input()]] for _ in range(k): queries += [[int(i) for i in input().split()]] visited = set() d = Counter() @bootstrap def dfs(x, y, i): grid[y][x] = str(i) for dx, dy in (x, y-1), (x, y+1), (x-1, y), (x+1, y): if grid[dy][dx] not in "*.": continue if grid[dy][dx] == "*": d[i] += 1 else: yield dfs(dx, dy, i) yield -1 i = 0 for x in range(m): for y in range(n): if grid[y][x] == ".": #print(x, y, i) dfs(x, y, i) i += 1 ans = [d[int(grid[x-1][y-1])] for x, y in queries] print(" ".join(str(x) for x in ans)) ```

0

9

A

Die Roll

PROGRAMMING

800

[ "math", "probabilities" ]

A. Die Roll

1

64

Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place. But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams. Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania. It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win.

The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls.

Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1».

[ "4 2\n" ]

[ "1/2\n" ]

Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.

0

[ { "input": "4 2", "output": "1/2" }, { "input": "1 1", "output": "1/1" }, { "input": "1 2", "output": "5/6" }, { "input": "1 3", "output": "2/3" }, { "input": "1 4", "output": "1/2" }, { "input": "1 5", "output": "1/3" }, { "input": "1 6", "output": "1/6" }, { "input": "2 1", "output": "5/6" }, { "input": "2 2", "output": "5/6" }, { "input": "2 3", "output": "2/3" }, { "input": "2 4", "output": "1/2" }, { "input": "2 5", "output": "1/3" }, { "input": "2 6", "output": "1/6" }, { "input": "3 1", "output": "2/3" }, { "input": "3 2", "output": "2/3" }, { "input": "3 3", "output": "2/3" }, { "input": "3 4", "output": "1/2" }, { "input": "3 5", "output": "1/3" }, { "input": "3 6", "output": "1/6" }, { "input": "4 1", "output": "1/2" }, { "input": "4 3", "output": "1/2" }, { "input": "4 4", "output": "1/2" }, { "input": "4 5", "output": "1/3" }, { "input": "4 6", "output": "1/6" }, { "input": "5 1", "output": "1/3" }, { "input": "5 2", "output": "1/3" }, { "input": "5 3", "output": "1/3" }, { "input": "5 4", "output": "1/3" }, { "input": "5 5", "output": "1/3" }, { "input": "5 6", "output": "1/6" }, { "input": "6 1", "output": "1/6" }, { "input": "6 2", "output": "1/6" }, { "input": "6 3", "output": "1/6" }, { "input": "6 4", "output": "1/6" }, { "input": "6 5", "output": "1/6" }, { "input": "6 6", "output": "1/6" } ]

1,677,098,993

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

62

0

import fraction a,b=map (int,input().split()) if a == 0 and b == 0: print(fraction.Fraction(0,6)) else: if a>=b: q=7-a fractions=fraction.Fraction(q,6) print(fractions) if b>a: q=7-b fractions=fraction.Fraction(q,6) print(fractions)

Title: Die Roll Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: Yakko, Wakko and Dot, world-famous animaniacs, decided to rest from acting in cartoons, and take a leave to travel a bit. Yakko dreamt to go to Pennsylvania, his Motherland and the Motherland of his ancestors. Wakko thought about Tasmania, its beaches, sun and sea. Dot chose Transylvania as the most mysterious and unpredictable place. But to their great regret, the leave turned to be very short, so it will be enough to visit one of the three above named places. That's why Yakko, as the cleverest, came up with a truly genius idea: let each of the three roll an ordinary six-sided die, and the one with the highest amount of points will be the winner, and will take the other two to the place of his/her dreams. Yakko thrown a die and got Y points, Wakko — W points. It was Dot's turn. But she didn't hurry. Dot wanted to know for sure what were her chances to visit Transylvania. It is known that Yakko and Wakko are true gentlemen, that's why if they have the same amount of points with Dot, they will let Dot win. Input Specification: The only line of the input file contains two natural numbers Y and W — the results of Yakko's and Wakko's die rolls. Output Specification: Output the required probability in the form of irreducible fraction in format «A/B», where A — the numerator, and B — the denominator. If the required probability equals to zero, output «0/1». If the required probability equals to 1, output «1/1». Demo Input: ['4 2\n'] Demo Output: ['1/2\n'] Note: Dot will go to Transylvania, if she is lucky to roll 4, 5 or 6 points.

```python import fraction a,b=map (int,input().split()) if a == 0 and b == 0: print(fraction.Fraction(0,6)) else: if a>=b: q=7-a fractions=fraction.Fraction(q,6) print(fractions) if b>a: q=7-b fractions=fraction.Fraction(q,6) print(fractions) ```

-1

893

C

Rumor

PROGRAMMING

1,300

[ "dfs and similar", "graphs", "greedy" ]

null

Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it. Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it. Vova knows that there are *n* characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; *i*-th character wants *c**i* gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on. The quest is finished when all *n* characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest? Take a look at the notes if you think you haven't understood the problem completely.

The first line contains two integer numbers *n* and *m* (1<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105) — the number of characters in Overcity and the number of pairs of friends. The second line contains *n* integer numbers *c**i* (0<=≤<=*c**i*<=≤<=109) — the amount of gold *i*-th character asks to start spreading the rumor. Then *m* lines follow, each containing a pair of numbers (*x**i*,<=*y**i*) which represent that characters *x**i* and *y**i* are friends (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*, *x**i*<=≠<=*y**i*). It is guaranteed that each pair is listed at most once.

Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.

[ "5 2\n2 5 3 4 8\n1 4\n4 5\n", "10 0\n1 2 3 4 5 6 7 8 9 10\n", "10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10\n" ]

[ "10\n", "55\n", "15\n" ]

In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor. In the second example Vova has to bribe everyone. In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.

0

[ { "input": "5 2\n2 5 3 4 8\n1 4\n4 5", "output": "10" }, { "input": "10 0\n1 2 3 4 5 6 7 8 9 10", "output": "55" }, { "input": "10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10", "output": "15" }, { "input": "1 0\n0", "output": "0" }, { "input": "1 0\n1000000000", "output": "1000000000" }, { "input": "2 0\n0 0", "output": "0" }, { "input": "2 0\n1000000000 0", "output": "1000000000" }, { "input": "2 0\n0 1000000000", "output": "1000000000" }, { "input": "2 0\n1000000000 1000000000", "output": "2000000000" }, { "input": "2 1\n0 0\n1 2", "output": "0" } ]

1,698,110,767

2,147,483,647

PyPy 3

OK

TESTS

46

1,216

11,878,400

from sys import stdin,stdout #input = stdin.readline def main(): #t = int(input()) t = 1 for z in range(t): #n = int(input()) #a,b,c = map(int,input().split()) #ai = list(map(int,input().split())) n,m = map(int,input().split()) ci = list(map(int,input().split())) sets = list(range(n)) mins = ci sizes = [1]*(n+1) def get(a): if sets[a] != a: sets[a] = get(sets[a]) return sets[a] def union(a, b): a = get(a) b = get(b) if a == b:return if sizes[a] > sizes[b]: a,b = b,a sets[a] = b sizes[b] += sizes[a] mins[b] = min(mins[b],mins[a]) for i in range(m): x,y = map(int,input().split()) x -= 1 y -= 1 union(x,y) ar = [0] * n ans = 0 for i in range(n): num = get(i) if ar[num]: continue ar[num] = 1 ans += mins[num] print(ans) main()

Title: Rumor Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it. Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it. Vova knows that there are *n* characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; *i*-th character wants *c**i* gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on. The quest is finished when all *n* characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest? Take a look at the notes if you think you haven't understood the problem completely. Input Specification: The first line contains two integer numbers *n* and *m* (1<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105) — the number of characters in Overcity and the number of pairs of friends. The second line contains *n* integer numbers *c**i* (0<=≤<=*c**i*<=≤<=109) — the amount of gold *i*-th character asks to start spreading the rumor. Then *m* lines follow, each containing a pair of numbers (*x**i*,<=*y**i*) which represent that characters *x**i* and *y**i* are friends (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*, *x**i*<=≠<=*y**i*). It is guaranteed that each pair is listed at most once. Output Specification: Print one number — the minimum amount of gold Vova has to spend in order to finish the quest. Demo Input: ['5 2\n2 5 3 4 8\n1 4\n4 5\n', '10 0\n1 2 3 4 5 6 7 8 9 10\n', '10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10\n'] Demo Output: ['10\n', '55\n', '15\n'] Note: In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor. In the second example Vova has to bribe everyone. In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.

```python from sys import stdin,stdout #input = stdin.readline def main(): #t = int(input()) t = 1 for z in range(t): #n = int(input()) #a,b,c = map(int,input().split()) #ai = list(map(int,input().split())) n,m = map(int,input().split()) ci = list(map(int,input().split())) sets = list(range(n)) mins = ci sizes = [1]*(n+1) def get(a): if sets[a] != a: sets[a] = get(sets[a]) return sets[a] def union(a, b): a = get(a) b = get(b) if a == b:return if sizes[a] > sizes[b]: a,b = b,a sets[a] = b sizes[b] += sizes[a] mins[b] = min(mins[b],mins[a]) for i in range(m): x,y = map(int,input().split()) x -= 1 y -= 1 union(x,y) ar = [0] * n ans = 0 for i in range(n): num = get(i) if ar[num]: continue ar[num] = 1 ans += mins[num] print(ans) main() ```

3

11

A

Increasing Sequence

PROGRAMMING

900

[ "constructive algorithms", "implementation", "math" ]

A. Increasing Sequence

1

64

A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*. You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*. In each move you may choose one element of the given sequence and add *d* to it. What is the least number of moves required to make the given sequence increasing?

The first line of the input contains two integer numbers *n* and *d* (2<=≤<=*n*<=≤<=2000,<=1<=≤<=*d*<=≤<=106). The second line contains space separated sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 (1<=≤<=*b**i*<=≤<=106).

Output the minimal number of moves needed to make the sequence increasing.

[ "4 2\n1 3 3 2\n" ]

[ "3\n" ]

none

0

[ { "input": "4 2\n1 3 3 2", "output": "3" }, { "input": "2 1\n1 1", "output": "1" }, { "input": "2 1\n2 5", "output": "0" }, { "input": "2 1\n1 2", "output": "0" }, { "input": "2 1\n1 1", "output": "1" }, { "input": "2 7\n10 20", "output": "0" }, { "input": "2 7\n1 1", "output": "1" }, { "input": "3 3\n18 1 9", "output": "10" }, { "input": "3 3\n15 17 9", "output": "3" }, { "input": "3 3\n10 9 12", "output": "2" }, { "input": "10 3\n2 1 17 10 5 16 8 4 15 17", "output": "31" }, { "input": "10 3\n6 11 4 12 22 15 23 26 24 26", "output": "13" }, { "input": "10 3\n10 24 13 15 18 14 15 26 33 35", "output": "29" }, { "input": "100 3\n529 178 280 403 326 531 671 427 188 866 669 646 421 804 494 609 53 1012 211 243 887 833 900 543 226 42 859 718 454 372 971 692 846 770 511 395 499 479 641 756 115 269 206 45 1039 727 400 779 859 614 146 214 196 919 702 959 380 830 535 878 859 784 316 305 782 924 536 243 236 978 564 150 291 877 808 983 537 839 490 120 168 838 267 650 900 170 211 504 326 771 895 984 994 483 776 100 471 1078 317 580", "output": "15717" }, { "input": "100 3\n329 226 331 909 962 112 837 1005 194 818 506 416 125 648 367 459 400 582 989 547 329 438 234 121 272 226 821 376 834 427 718 164 834 113 654 177 737 212 169 696 744 180 89 944 233 147 667 990 809 1072 1085 1093 814 265 1067 312 833 572 303 901 1032 504 185 817 389 158 613 723 239 269 911 352 769 404 225 822 897 606 947 323 913 804 923 1084 552 901 486 249 209 898 847 610 728 1122 986 669 1116 1076 367 327", "output": "16133" } ]

1,663,500,286

2,147,483,647

PyPy 3

OK

TESTS

25

154

1,843,200

n,d = [int(i) for i in input().split()] a = [int(i) for i in input().split()] num = 0 for i in range(1, len(a)): if a[i] < a[i-1]: num += (a[i - 1] - a[i]) // d + 1 a[i] += d * ((a[i - 1] - a[i]) // d + 1) elif a[i] == a[i-1]: a[i] += d num += 1 print(num)

Title: Increasing Sequence Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: A sequence *a*0,<=*a*1,<=...,<=*a**t*<=-<=1 is called increasing if *a**i*<=-<=1<=<<=*a**i* for each *i*:<=0<=<<=*i*<=<<=*t*. You are given a sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 and a positive integer *d*. In each move you may choose one element of the given sequence and add *d* to it. What is the least number of moves required to make the given sequence increasing? Input Specification: The first line of the input contains two integer numbers *n* and *d* (2<=≤<=*n*<=≤<=2000,<=1<=≤<=*d*<=≤<=106). The second line contains space separated sequence *b*0,<=*b*1,<=...,<=*b**n*<=-<=1 (1<=≤<=*b**i*<=≤<=106). Output Specification: Output the minimal number of moves needed to make the sequence increasing. Demo Input: ['4 2\n1 3 3 2\n'] Demo Output: ['3\n'] Note: none

```python n,d = [int(i) for i in input().split()] a = [int(i) for i in input().split()] num = 0 for i in range(1, len(a)): if a[i] < a[i-1]: num += (a[i - 1] - a[i]) // d + 1 a[i] += d * ((a[i - 1] - a[i]) // d + 1) elif a[i] == a[i-1]: a[i] += d num += 1 print(num) ```

3.909267

69

A

Young Physicist

PROGRAMMING

1,000

[ "implementation", "math" ]

A. Young Physicist

2

256

A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" — thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100).

Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not.

[ "3\n4 1 7\n-2 4 -1\n1 -5 -3\n", "3\n3 -1 7\n-5 2 -4\n2 -1 -3\n" ]

[ "NO", "YES" ]

none

500

[ { "input": "3\n4 1 7\n-2 4 -1\n1 -5 -3", "output": "NO" }, { "input": "3\n3 -1 7\n-5 2 -4\n2 -1 -3", "output": "YES" }, { "input": "10\n21 32 -46\n43 -35 21\n42 2 -50\n22 40 20\n-27 -9 38\n-4 1 1\n-40 6 -31\n-13 -2 34\n-21 34 -12\n-32 -29 41", "output": "NO" }, { "input": "10\n25 -33 43\n-27 -42 28\n-35 -20 19\n41 -42 -1\n49 -39 -4\n-49 -22 7\n-19 29 41\n8 -27 -43\n8 34 9\n-11 -3 33", "output": "NO" }, { "input": "10\n-6 21 18\n20 -11 -8\n37 -11 41\n-5 8 33\n29 23 32\n30 -33 -11\n39 -49 -36\n28 34 -49\n22 29 -34\n-18 -6 7", "output": "NO" }, { "input": "10\n47 -2 -27\n0 26 -14\n5 -12 33\n2 18 3\n45 -30 -49\n4 -18 8\n-46 -44 -41\n-22 -10 -40\n-35 -21 26\n33 20 38", "output": "NO" }, { "input": "13\n-3 -36 -46\n-11 -50 37\n42 -11 -15\n9 42 44\n-29 -12 24\n3 9 -40\n-35 13 50\n14 43 18\n-13 8 24\n-48 -15 10\n50 9 -50\n21 0 -50\n0 0 -6", "output": "YES" }, { "input": "14\n43 23 17\n4 17 44\n5 -5 -16\n-43 -7 -6\n47 -48 12\n50 47 -45\n2 14 43\n37 -30 15\n4 -17 -11\n17 9 -45\n-50 -3 -8\n-50 0 0\n-50 0 0\n-16 0 0", "output": "YES" }, { "input": "13\n29 49 -11\n38 -11 -20\n25 1 -40\n-11 28 11\n23 -19 1\n45 -41 -17\n-3 0 -19\n-13 -33 49\n-30 0 28\n34 17 45\n-50 9 -27\n-50 0 0\n-37 0 0", "output": "YES" }, { "input": "12\n3 28 -35\n-32 -44 -17\n9 -25 -6\n-42 -22 20\n-19 15 38\n-21 38 48\n-1 -37 -28\n-10 -13 -50\n-5 21 29\n34 28 50\n50 11 -49\n34 0 0", "output": "YES" }, { "input": "37\n-64 -79 26\n-22 59 93\n-5 39 -12\n77 -9 76\n55 -86 57\n83 100 -97\n-70 94 84\n-14 46 -94\n26 72 35\n14 78 -62\n17 82 92\n-57 11 91\n23 15 92\n-80 -1 1\n12 39 18\n-23 -99 -75\n-34 50 19\n-39 84 -7\n45 -30 -39\n-60 49 37\n45 -16 -72\n33 -51 -56\n-48 28 5\n97 91 88\n45 -82 -11\n-21 -15 -90\n-53 73 -26\n-74 85 -90\n-40 23 38\n100 -13 49\n32 -100 -100\n0 -100 -70\n0 -100 0\n0 -100 0\n0 -100 0\n0 -100 0\n0 -37 0", "output": "YES" }, { "input": "4\n68 3 100\n68 21 -100\n-100 -24 0\n-36 0 0", "output": "YES" }, { "input": "33\n-1 -46 -12\n45 -16 -21\n-11 45 -21\n-60 -42 -93\n-22 -45 93\n37 96 85\n-76 26 83\n-4 9 55\n7 -52 -9\n66 8 -85\n-100 -54 11\n-29 59 74\n-24 12 2\n-56 81 85\n-92 69 -52\n-26 -97 91\n54 59 -51\n58 21 -57\n7 68 56\n-47 -20 -51\n-59 77 -13\n-85 27 91\n79 60 -56\n66 -80 5\n21 -99 42\n-31 -29 98\n66 93 76\n-49 45 61\n100 -100 -100\n100 -100 -100\n66 -75 -100\n0 0 -100\n0 0 -87", "output": "YES" }, { "input": "3\n1 2 3\n3 2 1\n0 0 0", "output": "NO" }, { "input": "2\n5 -23 12\n0 0 0", "output": "NO" }, { "input": "1\n0 0 0", "output": "YES" }, { "input": "1\n1 -2 0", "output": "NO" }, { "input": "2\n-23 77 -86\n23 -77 86", "output": "YES" }, { "input": "26\n86 7 20\n-57 -64 39\n-45 6 -93\n-44 -21 100\n-11 -49 21\n73 -71 -80\n-2 -89 56\n-65 -2 7\n5 14 84\n57 41 13\n-12 69 54\n40 -25 27\n-17 -59 0\n64 -91 -30\n-53 9 42\n-54 -8 14\n-35 82 27\n-48 -59 -80\n88 70 79\n94 57 97\n44 63 25\n84 -90 -40\n-100 100 -100\n-92 100 -100\n0 10 -100\n0 0 -82", "output": "YES" }, { "input": "42\n11 27 92\n-18 -56 -57\n1 71 81\n33 -92 30\n82 83 49\n-87 -61 -1\n-49 45 49\n73 26 15\n-22 22 -77\n29 -93 87\n-68 44 -90\n-4 -84 20\n85 67 -6\n-39 26 77\n-28 -64 20\n65 -97 24\n-72 -39 51\n35 -75 -91\n39 -44 -8\n-25 -27 -57\n91 8 -46\n-98 -94 56\n94 -60 59\n-9 -95 18\n-53 -37 98\n-8 -94 -84\n-52 55 60\n15 -14 37\n65 -43 -25\n94 12 66\n-8 -19 -83\n29 81 -78\n-58 57 33\n24 86 -84\n-53 32 -88\n-14 7 3\n89 97 -53\n-5 -28 -91\n-100 100 -6\n-84 100 0\n0 100 0\n0 70 0", "output": "YES" }, { "input": "3\n96 49 -12\n2 -66 28\n-98 17 -16", "output": "YES" }, { "input": "5\n70 -46 86\n-100 94 24\n-27 63 -63\n57 -100 -47\n0 -11 0", "output": "YES" }, { "input": "18\n-86 -28 70\n-31 -89 42\n31 -48 -55\n95 -17 -43\n24 -95 -85\n-21 -14 31\n68 -18 81\n13 31 60\n-15 28 99\n-42 15 9\n28 -61 -62\n-16 71 29\n-28 75 -48\n-77 -67 36\n-100 83 89\n100 100 -100\n57 34 -100\n0 0 -53", "output": "YES" }, { "input": "44\n52 -54 -29\n-82 -5 -94\n-54 43 43\n91 16 71\n7 80 -91\n3 15 29\n-99 -6 -77\n-3 -77 -64\n73 67 34\n25 -10 -18\n-29 91 63\n-72 86 -16\n-68 85 -81\n-3 36 44\n-74 -14 -80\n34 -96 -97\n-76 -78 -33\n-24 44 -58\n98 12 77\n95 -63 -6\n-51 3 -90\n-92 -10 72\n7 3 -68\n57 -53 71\n29 57 -48\n35 -60 10\n79 -70 -61\n-20 77 55\n-86 -15 -35\n84 -88 -18\n100 -42 77\n-20 46 8\n-41 -43 -65\n38 -98 -23\n-100 65 45\n-7 -91 -63\n46 88 -85\n48 59 100\n0 0 100\n0 0 100\n0 0 100\n0 0 100\n0 0 100\n0 0 1", "output": "YES" }, { "input": "18\n-14 -64 -91\n-8 -66 -86\n-23 92 -40\n6 -3 -53\n57 41 78\n-79 42 -22\n-88 -17 45\n4 -45 44\n83 -18 -25\n34 86 -92\n75 -30 12\n44 99 11\n-67 -13 72\n22 83 -56\n-37 71 72\n-9 -100 100\n0 -100 31\n0 -58 0", "output": "YES" }, { "input": "23\n-70 37 78\n42 84 6\n28 -94 -24\n-49 76 95\n-67 18 84\n-53 78 -5\n65 -63 -64\n-66 -64 -69\n81 -93 95\n10 52 -79\n-89 -61 -64\n-64 -47 43\n-81 -35 55\n80 82 73\n-60 -81 -18\n49 -10 -19\n-58 70 12\n-24 -15 -93\n98 -93 -54\n-28 -75 11\n100 100 -63\n100 100 0\n56 34 0", "output": "YES" }, { "input": "3\n0 2 -2\n1 -1 3\n-3 0 0", "output": "NO" } ]

1,601,741,448

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

186

0

n = int(input()) matrix = [0,0,0] for i in range(n): l = list(map(int,input().split())) matrix[1]+=l[1] matrix[0]+=l[0] mtrix[2]+=l[2] if matrix == [0,0,0]: print("YES") else: print("NO")

Title: Young Physicist Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" — thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces. Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100). Output Specification: Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not. Demo Input: ['3\n4 1 7\n-2 4 -1\n1 -5 -3\n', '3\n3 -1 7\n-5 2 -4\n2 -1 -3\n'] Demo Output: ['NO', 'YES'] Note: none

```python n = int(input()) matrix = [0,0,0] for i in range(n): l = list(map(int,input().split())) matrix[1]+=l[1] matrix[0]+=l[0] mtrix[2]+=l[2] if matrix == [0,0,0]: print("YES") else: print("NO") ```

-1

522

A

Reposts

PROGRAMMING

1,200

[ "*special", "dfs and similar", "dp", "graphs", "trees" ]

null

One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on. These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed. Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.

The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive. We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.

Print a single integer — the maximum length of a repost chain.

[ "5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya\n", "6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp\n", "1\nSoMeStRaNgEgUe reposted PoLyCaRp\n" ]

[ "6\n", "2\n", "2\n" ]

none

500

[ { "input": "5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya", "output": "6" }, { "input": "6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp", "output": "2" }, { "input": "1\nSoMeStRaNgEgUe reposted PoLyCaRp", "output": "2" }, { "input": "1\niuNtwVf reposted POlYcarP", "output": "2" }, { "input": "10\ncs reposted poLYCaRp\nAFIkDrY7Of4V7Mq reposted CS\nsoBiwyN7KOvoFUfbhux reposted aFikDry7Of4v7MQ\nvb6LbwA reposted sObIWYN7KOvoFufBHUx\nDtWKIcVwIHgj4Rcv reposted vb6lbwa\nkt reposted DTwKicvwihgJ4rCV\n75K reposted kT\njKzyxx1 reposted 75K\nuoS reposted jkZyXX1\npZJskHTCIqE3YyZ5ME reposted uoS", "output": "11" }, { "input": "10\nvxrUpCXvx8Isq reposted pOLYcaRP\nICb1 reposted vXRUpCxvX8ISq\nJFMt4b8jZE7iF2m8by7y2 reposted Icb1\nqkG6ZkMIf9QRrBFQU reposted ICb1\nnawsNfcR2palIMnmKZ reposted pOlYcaRP\nKksyH reposted jFMT4b8JzE7If2M8by7y2\nwJtWwQS5FvzN0h8CxrYyL reposted NawsNfcR2paLIMnmKz\nDpBcBPYAcTXEdhldI6tPl reposted NaWSnFCr2pALiMnmkZ\nlEnwTVnlwdQg2vaIRQry reposted kKSYh\nQUVFgwllaWO reposted Wjtwwqs5FVzN0H8cxRyyl", "output": "6" }, { "input": "10\nkkuLGEiHv reposted POLYcArp\n3oX1AoUqyw1eR3nCADY9hLwd reposted kkuLGeIHV\nwf97dqq5bx1dPIchCoT reposted 3OX1AOuQYW1eR3ncAdY9hLwD\nWANr8h reposted Wf97dQQ5bx1dpIcHcoT\n3Fb736lkljZK2LtSbfL reposted wANR8h\n6nq9xLOn reposted 3fB736lKlJZk2LtSbFL\nWL reposted 3Fb736lKLjZk2LTSbfl\ndvxn4Xtc6SBcvKf1 reposted wF97DQq5bX1dPiChCOt\nMCcPLIMISqxDzrj reposted 6nQ9XLOn\nxsQL4Z2Iu reposted MCcpLiMiSqxdzrj", "output": "9" }, { "input": "10\nsMA4 reposted pOLyCARP\nlq3 reposted pOlycARp\nEa16LSFTQxLJnE reposted polYcARp\nkvZVZhJwXcWsnC7NA1DV2WvS reposted polYCArp\nEYqqlrjRwddI reposted pOlyCArP\nsPqQCA67Y6PBBbcaV3EhooO reposted ea16LSFTqxLJne\njjPnneZdF6WLZ3v reposted Ea16LSFTqxLjNe\nWEoi6UpnfBUx79 reposted ea16LSFtqXljNe\nqi4yra reposted eYqqlRJrWDDI\ncw7E1UCSUD reposted eYqqLRJRwDdI", "output": "3" } ]

1,595,318,465

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

108

6,963,200

# 6 # Mike reposted Polycarp # Max reposted Polycarp # EveryOne reposted Polycarp # 111 reposted Polycarp # VkCup reposted Polycarp # Codeforces reposted Polycarp ans = 0 cnt = 0 l = list() t = int(input()) for i in range(t): post = input().split(" ") if(i == 0): l.append(post[2].lower()) l.append(post[0].lower()) else: if(l[-1] == post[2].lower()): l.append(post[0].lower()) else: l.remove(l[-1]) l.append(post[0].lower()) print(len(l))

Title: Reposts Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on. These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed. Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke. Input Specification: The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive. We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user. Output Specification: Print a single integer — the maximum length of a repost chain. Demo Input: ['5\ntourist reposted Polycarp\nPetr reposted Tourist\nWJMZBMR reposted Petr\nsdya reposted wjmzbmr\nvepifanov reposted sdya\n', '6\nMike reposted Polycarp\nMax reposted Polycarp\nEveryOne reposted Polycarp\n111 reposted Polycarp\nVkCup reposted Polycarp\nCodeforces reposted Polycarp\n', '1\nSoMeStRaNgEgUe reposted PoLyCaRp\n'] Demo Output: ['6\n', '2\n', '2\n'] Note: none

```python # 6 # Mike reposted Polycarp # Max reposted Polycarp # EveryOne reposted Polycarp # 111 reposted Polycarp # VkCup reposted Polycarp # Codeforces reposted Polycarp ans = 0 cnt = 0 l = list() t = int(input()) for i in range(t): post = input().split(" ") if(i == 0): l.append(post[2].lower()) l.append(post[0].lower()) else: if(l[-1] == post[2].lower()): l.append(post[0].lower()) else: l.remove(l[-1]) l.append(post[0].lower()) print(len(l)) ```

0