MatrixStudio/Codeforces-Python-Submissions

99

A

Help Far Away Kingdom

PROGRAMMING

800

[ "strings" ]

A. Help Far Away Kingdom

2

256

In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there. Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this: - If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position. Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?

The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.

If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).

[ "0.0\n", "1.49\n", "1.50\n", "2.71828182845904523536\n", "3.14159265358979323846\n", "12345678901234567890.1\n", "123456789123456789.999\n" ]

[ "0", "1", "2", "3", "3", "12345678901234567890", "GOTO Vasilisa." ]

none

500

[ { "input": "0.0", "output": "0" }, { "input": "1.49", "output": "1" }, { "input": "1.50", "output": "2" }, { "input": "2.71828182845904523536", "output": "3" }, { "input": "3.14159265358979323846", "output": "3" }, { "input": "12345678901234567890.1", "output": "12345678901234567890" }, { "input": "123456789123456789.999", "output": "GOTO Vasilisa." }, { "input": "12345678901234567890.9", "output": "12345678901234567891" }, { "input": "123456789123456788.999", "output": "123456789123456789" }, { "input": "9.000", "output": "GOTO Vasilisa." }, { "input": "0.1", "output": "0" }, { "input": "0.2", "output": "0" }, { "input": "0.3", "output": "0" }, { "input": "0.4", "output": "0" }, { "input": "0.5", "output": "1" }, { "input": "0.6", "output": "1" }, { "input": "0.7", "output": "1" }, { "input": "0.8", "output": "1" }, { "input": "0.9", "output": "1" }, { "input": "1.0", "output": "1" }, { "input": "1.1", "output": "1" }, { "input": "1.2", "output": "1" }, { "input": "1.3", "output": "1" }, { "input": "1.4", "output": "1" }, { "input": "1.5", "output": "2" }, { "input": "1.6", "output": "2" }, { "input": "1.7", "output": "2" }, { "input": "1.8", "output": "2" }, { "input": "1.9", "output": "2" }, { "input": "2.0", "output": "2" }, { "input": "2.1", "output": "2" }, { "input": "2.2", "output": "2" }, { "input": "2.3", "output": "2" }, { "input": "2.4", "output": "2" }, { "input": "2.5", "output": "3" }, { "input": "2.6", "output": "3" }, { "input": "2.7", "output": "3" }, { "input": "2.8", "output": "3" }, { "input": "2.9", "output": "3" }, { "input": "3.0", "output": "3" }, { "input": "3.1", "output": "3" }, { "input": "3.2", "output": "3" }, { "input": "3.3", "output": "3" }, { "input": "3.4", "output": "3" }, { "input": "3.5", "output": "4" }, { "input": "3.6", "output": "4" }, { "input": "3.7", "output": "4" }, { "input": "3.8", "output": "4" }, { "input": "3.9", "output": "4" }, { "input": "4.0", "output": "4" }, { "input": "4.1", "output": "4" }, { "input": "4.2", "output": "4" }, { "input": "4.3", "output": "4" }, { "input": "4.4", "output": "4" }, { "input": "4.5", "output": "5" }, { "input": "4.6", "output": "5" }, { "input": "4.7", "output": "5" }, { "input": "4.8", "output": "5" }, { "input": "4.9", "output": "5" }, { "input": "5.0", "output": "5" }, { "input": "5.1", "output": "5" }, { "input": "5.2", "output": "5" }, { "input": "5.3", "output": "5" }, { "input": "5.4", "output": "5" }, { "input": "5.5", "output": "6" }, { "input": "5.6", "output": "6" }, { "input": "5.7", "output": "6" }, { "input": "5.8", "output": "6" }, { "input": "5.9", "output": "6" }, { "input": "6.0", "output": "6" }, { "input": "6.1", "output": "6" }, { "input": "6.2", "output": "6" }, { "input": "6.3", "output": "6" }, { "input": "6.4", "output": "6" }, { "input": "6.5", "output": "7" }, { "input": "6.6", "output": "7" }, { "input": "6.7", "output": "7" }, { "input": "6.8", "output": "7" }, { "input": "6.9", "output": "7" }, { "input": "7.0", "output": "7" }, { "input": "7.1", "output": "7" }, { "input": "7.2", "output": "7" }, { "input": "7.3", "output": "7" }, { "input": "7.4", "output": "7" }, { "input": "7.5", "output": "8" }, { "input": "7.6", "output": "8" }, { "input": "7.7", "output": "8" }, { "input": "7.8", "output": "8" }, { "input": "7.9", "output": "8" }, { "input": "8.0", "output": "8" }, { "input": "8.1", "output": "8" }, { "input": "8.2", "output": "8" }, { "input": "8.3", "output": "8" }, { "input": "8.4", "output": "8" }, { "input": "8.5", "output": "9" }, { "input": "8.6", "output": "9" }, { "input": "8.7", "output": "9" }, { "input": "8.8", "output": "9" }, { "input": "8.9", "output": "9" }, { "input": "9.0", "output": "GOTO Vasilisa." }, { "input": "9.1", "output": "GOTO Vasilisa." }, { "input": "9.2", "output": "GOTO Vasilisa." }, { "input": "9.3", "output": "GOTO Vasilisa." }, { "input": "9.4", "output": "GOTO Vasilisa." }, { "input": "9.5", "output": "GOTO Vasilisa." }, { "input": "9.6", "output": "GOTO Vasilisa." }, { "input": "9.7", "output": "GOTO Vasilisa." }, { "input": "9.8", "output": "GOTO Vasilisa." }, { "input": "9.9", "output": "GOTO Vasilisa." }, { "input": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098.1664915772983166314490532653577560222779830866949001942720729759794777105570672781798092416748052690224813237139640723361527601154465287615917169132637313918577673651098507390501962", "output": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098" }, { "input": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394.20211856263503281388748282682120712214711232598021393495443628276945042110862480888110959179019986486690931930108026302665438087068150666835901617457150158918705186964935221768346957536540345814875615118637945520917367155931078965", "output": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394" }, { "input": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616067.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616068" }, { "input": "718130341896330596635811874410345440628950330.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "718130341896330596635811874410345440628950331" }, { "input": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280722.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280723" }, { "input": "68289614863244584294178637364598054554769889.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "GOTO Vasilisa." }, { "input": "7536521504744364134984603189602839063535643888645969434165019366202558753840519.4999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "output": "GOTO Vasilisa." }, { "input": "646188694587964249318078225173.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "646188694587964249318078225174" }, { "input": "7017472758334494297677068672222822550374695787171163207025095950296957261530.50", "output": "7017472758334494297677068672222822550374695787171163207025095950296957261531" }, { "input": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774368.50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774369" }, { "input": "682500858233333594535201113441004740771119672961581796618069185960107115823662126812159957094407454522028503739299.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "GOTO Vasilisa." }, { "input": "41203422675619090661099806687619.49999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "output": "GOTO Vasilisa." } ]

1,620,581,693

2,147,483,647

PyPy 3

OK

TESTS

150

248

20,172,800

n = input().split(".") if n[0][-1] != '9' and int(n[1][0]) < 5: print(n[0]) elif n[0][-1] != '9' and int(n[1][0]) >= 5: print(int(n[0]) + 1) else : print("GOTO Vasilisa.")

Title: Help Far Away Kingdom Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there. Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this: - If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position. Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order? Input Specification: The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data. Output Specification: If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes). Demo Input: ['0.0\n', '1.49\n', '1.50\n', '2.71828182845904523536\n', '3.14159265358979323846\n', '12345678901234567890.1\n', '123456789123456789.999\n'] Demo Output: ['0', '1', '2', '3', '3', '12345678901234567890', 'GOTO Vasilisa.'] Note: none

```python n = input().split(".") if n[0][-1] != '9' and int(n[1][0]) < 5: print(n[0]) elif n[0][-1] != '9' and int(n[1][0]) >= 5: print(int(n[0]) + 1) else : print("GOTO Vasilisa.") ```

3.900425

432

A

Choosing Teams

PROGRAMMING

800

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

null

The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. According to the ACM ICPC rules, each person can participate in the world championship at most 5 times. The head of the SSU OPTC is recently gathering teams to participate in the world championship. Each team must consist of exactly three people, at that, any person cannot be a member of two or more teams. What maximum number of teams can the head make if he wants each team to participate in the world championship with the same members at least *k* times?

The first line contains two integers, *n* and *k* (1<=≤<=*n*<=≤<=2000; 1<=≤<=*k*<=≤<=5). The next line contains *n* integers: *y*1,<=*y*2,<=...,<=*y**n* (0<=≤<=*y**i*<=≤<=5), where *y**i* shows the number of times the *i*-th person participated in the ACM ICPC world championship.

Print a single number — the answer to the problem.

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

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

In the first sample only one team could be made: the first, the fourth and the fifth participants. In the second sample no teams could be created. In the third sample two teams could be created. Any partition into two teams fits.

500

[ { "input": "5 2\n0 4 5 1 0", "output": "1" }, { "input": "6 4\n0 1 2 3 4 5", "output": "0" }, { "input": "6 5\n0 0 0 0 0 0", "output": "2" }, { "input": "3 4\n0 1 0", "output": "1" }, { "input": "3 4\n0 2 0", "output": "0" }, { "input": "6 5\n0 0 0 0 0 0", "output": "2" }, { "input": "12 2\n0 1 2 3 4 0 1 2 3 4 0 1", "output": "3" }, { "input": "15 2\n0 1 2 3 4 0 1 2 3 4 0 1 2 3 4", "output": "4" }, { "input": "13 1\n5 0 5 0 1 5 0 4 1 1 1 4 1", "output": "3" }, { "input": "20 1\n5 0 4 2 2 3 2 1 2 4 1 3 5 5 5 4 4 1 3 0", "output": "5" }, { "input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4", "output": "4" }, { "input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4", "output": "4" }, { "input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4", "output": "4" }, { "input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4", "output": "4" }, { "input": "6 3\n4 4 4 4 4 4", "output": "0" }, { "input": "1 4\n1", "output": "0" }, { "input": "1 1\n0", "output": "0" }, { "input": "2 3\n0 0", "output": "0" } ]

1,684,330,108

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

31

0

tm = list(map(int, input().split())) n, k = tm[0], tm[1] x = sorted(list(map(int, input().split()))) it = 0 for i in range(n // 3): n1, n2, n3 = x[i], x[i+1], x[i+2] mx = max(n1, n2, n3) if 5 - mx >= k: it += 1 print(it)

Title: Choosing Teams Time Limit: None seconds Memory Limit: None megabytes Problem Description: The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. According to the ACM ICPC rules, each person can participate in the world championship at most 5 times. The head of the SSU OPTC is recently gathering teams to participate in the world championship. Each team must consist of exactly three people, at that, any person cannot be a member of two or more teams. What maximum number of teams can the head make if he wants each team to participate in the world championship with the same members at least *k* times? Input Specification: The first line contains two integers, *n* and *k* (1<=≤<=*n*<=≤<=2000; 1<=≤<=*k*<=≤<=5). The next line contains *n* integers: *y*1,<=*y*2,<=...,<=*y**n* (0<=≤<=*y**i*<=≤<=5), where *y**i* shows the number of times the *i*-th person participated in the ACM ICPC world championship. Output Specification: Print a single number — the answer to the problem. Demo Input: ['5 2\n0 4 5 1 0\n', '6 4\n0 1 2 3 4 5\n', '6 5\n0 0 0 0 0 0\n'] Demo Output: ['1\n', '0\n', '2\n'] Note: In the first sample only one team could be made: the first, the fourth and the fifth participants. In the second sample no teams could be created. In the third sample two teams could be created. Any partition into two teams fits.

```python tm = list(map(int, input().split())) n, k = tm[0], tm[1] x = sorted(list(map(int, input().split()))) it = 0 for i in range(n // 3): n1, n2, n3 = x[i], x[i+1], x[i+2] mx = max(n1, n2, n3) if 5 - mx >= k: it += 1 print(it) ```

0

102

B

Sum of Digits

PROGRAMMING

1,000

[ "implementation" ]

B. Sum of Digits

2

265

Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came across a number *n*. How many times can Gerald put a spell on it until the number becomes one-digit?

The first line contains the only integer *n* (0<=≤<=*n*<=≤<=10100000). It is guaranteed that *n* doesn't contain any leading zeroes.

Print the number of times a number can be replaced by the sum of its digits until it only contains one digit.

[ "0\n", "10\n", "991\n" ]

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

In the first sample the number already is one-digit — Herald can't cast a spell. The second test contains number 10. After one casting of a spell it becomes 1, and here the process is completed. Thus, Gerald can only cast the spell once. The third test contains number 991. As one casts a spell the following transformations take place: 991 → 19 → 10 → 1. After three transformations the number becomes one-digit.

1,000

[ { "input": "0", "output": "0" }, { "input": "10", "output": "1" }, { "input": "991", "output": "3" }, { "input": "99", "output": "2" }, { "input": "100", "output": "1" }, { "input": "123456789", "output": "2" }, { "input": "32", "output": "1" }, { "input": "86", "output": "2" }, { "input": "2", "output": "0" }, { "input": "8", "output": "0" }, { "input": "34", "output": "1" }, { "input": "13", "output": "1" }, { "input": "28", "output": "2" }, { "input": "23", "output": "1" }, { "input": "57", "output": "2" }, { "input": "29", "output": "2" }, { "input": "353869285", "output": "3" }, { "input": "549548646", "output": "2" }, { "input": "858893424", "output": "2" }, { "input": "644818852", "output": "3" }, { "input": "360322525", "output": "3" }, { "input": "122937520", "output": "2" }, { "input": "288403032", "output": "2" }, { "input": "677257481", "output": "3" }, { "input": "58059561", "output": "3" }, { "input": "211288847", "output": "2" }, { "input": "339900034079539584", "output": "2" }, { "input": "784084029310269952", "output": "3" }, { "input": "774730557264864000", "output": "3" }, { "input": "478233807148352256", "output": "3" }, { "input": "165646874056812544", "output": "3" }, { "input": "477533739511673792", "output": "3" }, { "input": "660119944377002240", "output": "3" }, { "input": "448375218506078080", "output": "3" }, { "input": "77213334785795616", "output": "3" }, { "input": "165767221702271872", "output": "3" }, { "input": "1", "output": "0" }, { "input": "5", "output": "0" }, { "input": "8", "output": "0" }, { "input": "156161456146164104103460452045416165146141414651641564105461465156445621465146514562146145465165145145614561465145614561", "output": "3" }, { "input": "9", "output": "0" } ]

1,642,284,826

2,147,483,647

PyPy 3

MEMORY_LIMIT_EXCEEDED

TESTS

0

124

277,913,600

import sys sys.setrecursionlimit(10**6) n = int(input()) cnt = 0 while len(str(n)) != 1: n = sum(map(int, list(str(n)))) cnt += 1 print(cnt)

Title: Sum of Digits Time Limit: 2 seconds Memory Limit: 265 megabytes Problem Description: Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came across a number *n*. How many times can Gerald put a spell on it until the number becomes one-digit? Input Specification: The first line contains the only integer *n* (0<=≤<=*n*<=≤<=10100000). It is guaranteed that *n* doesn't contain any leading zeroes. Output Specification: Print the number of times a number can be replaced by the sum of its digits until it only contains one digit. Demo Input: ['0\n', '10\n', '991\n'] Demo Output: ['0\n', '1\n', '3\n'] Note: In the first sample the number already is one-digit — Herald can't cast a spell. The second test contains number 10. After one casting of a spell it becomes 1, and here the process is completed. Thus, Gerald can only cast the spell once. The third test contains number 991. As one casts a spell the following transformations take place: 991 → 19 → 10 → 1. After three transformations the number becomes one-digit.

```python import sys sys.setrecursionlimit(10**6) n = int(input()) cnt = 0 while len(str(n)) != 1: n = sum(map(int, list(str(n)))) cnt += 1 print(cnt) ```

0

none

0

[ "none" ]

null

Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well. This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good. Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, *m* icons can fit in a horizontal row in any window. Igor K.'s computer contains *n* folders in the D: disk's root catalog. The folders are numbered from 1 to *n* in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from *a* to *b* inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from *a* to *b* and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders.

The only line contains four integers *n*, *m*, *a*, *b* (1<=≤<=*n*,<=*m*<=≤<=109, 1<=≤<=*a*<=≤<=*b*<=≤<=*n*). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted.

Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from *a* to *b*.

[ "11 4 3 9\n", "20 5 2 20\n" ]

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

The images below illustrate statement tests. The first test: <img class="tex-graphics" src="https://espresso.codeforces.com/a0e4ba690dd16e3c68210a28afd82020b23fb605.png" style="max-width: 100.0%;max-height: 100.0%;"/> In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection. The second test: <img class="tex-graphics" src="https://espresso.codeforces.com/289e2666a3d8b3dfe5b22ff3d88976df711640f7.png" style="max-width: 100.0%;max-height: 100.0%;"/> In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.

0

[ { "input": "11 4 3 9", "output": "3" }, { "input": "20 5 2 20", "output": "2" }, { "input": "1 1 1 1", "output": "1" }, { "input": "26 5 2 18", "output": "3" }, { "input": "21 5 1 15", "output": "1" }, { "input": "21 5 1 21", "output": "1" }, { "input": "21 5 8 14", "output": "2" }, { "input": "20 4 1 20", "output": "1" }, { "input": "21 5 1 13", "output": "2" }, { "input": "21 5 4 15", "output": "2" }, { "input": "17 3 1 16", "output": "2" }, { "input": "19 5 7 19", "output": "2" }, { "input": "18 2 1 13", "output": "2" }, { "input": "21 3 6 11", "output": "2" }, { "input": "21 5 3 12", "output": "2" }, { "input": "21 3 6 10", "output": "3" }, { "input": "28 5 4 26", "output": "3" }, { "input": "21 5 6 18", "output": "2" }, { "input": "21 5 4 21", "output": "2" }, { "input": "17 5 6 17", "output": "1" }, { "input": "21 5 9 12", "output": "2" }, { "input": "21 3 6 7", "output": "2" }, { "input": "21 5 7 9", "output": "1" }, { "input": "12 4 5 8", "output": "1" }, { "input": "21 3 6 8", "output": "2" }, { "input": "21 1 5 17", "output": "1" }, { "input": "5 5 2 4", "output": "1" }, { "input": "18 4 6 17", "output": "2" }, { "input": "18 4 6 18", "output": "2" }, { "input": "16 4 1 16", "output": "1" }, { "input": "20 4 7 14", "output": "2" }, { "input": "17 3 12 16", "output": "3" }, { "input": "12 4 8 9", "output": "2" }, { "input": "11 8 2 7", "output": "1" }, { "input": "27 5 4 24", "output": "3" }, { "input": "29 5 12 27", "output": "3" }, { "input": "30 5 5 29", "output": "2" }, { "input": "91 2 15 72", "output": "1" }, { "input": "41 1 8 27", "output": "1" }, { "input": "26 5 7 21", "output": "2" }, { "input": "70 5 31 33", "output": "1" }, { "input": "84 9 6 80", "output": "3" }, { "input": "79 8 41 64", "output": "1" }, { "input": "63 11 23 48", "output": "2" }, { "input": "97 9 18 54", "output": "2" }, { "input": "75 18 20 23", "output": "1" }, { "input": "66 42 43 44", "output": "1" }, { "input": "92 54 20 53", "output": "1" }, { "input": "32 90 31 32", "output": "1" }, { "input": "18 100 6 6", "output": "1" }, { "input": "458 12 203 310", "output": "2" }, { "input": "149 49 92 129", "output": "2" }, { "input": "264 2 9 63", "output": "2" }, { "input": "908 6 407 531", "output": "3" }, { "input": "410 36 109 191", "output": "2" }, { "input": "301 38 97 171", "output": "3" }, { "input": "691 27 313 499", "output": "3" }, { "input": "939 42 86 827", "output": "3" }, { "input": "280 32 64 277", "output": "3" }, { "input": "244 25 94 199", "output": "3" }, { "input": "134 110 11 52", "output": "1" }, { "input": "886 251 61 672", "output": "3" }, { "input": "261 686 243 254", "output": "1" }, { "input": "162 309 68 98", "output": "1" }, { "input": "476 398 77 256", "output": "1" }, { "input": "258 224 84 174", "output": "1" }, { "input": "357 182 73 247", "output": "2" }, { "input": "488 655 290 457", "output": "1" }, { "input": "149 334 78 105", "output": "1" }, { "input": "488 519 203 211", "output": "1" }, { "input": "192293793 2864 5278163 190776899", "output": "3" }, { "input": "38644205 2729 9325777 31658388", "output": "3" }, { "input": "268836959 6117 166683294 249843000", "output": "3" }, { "input": "831447817 8377 549549158 577671489", "output": "3" }, { "input": "444819690 3519 48280371 117052060", "output": "3" }, { "input": "729584406 8367 456501516 557088265", "output": "3" }, { "input": "629207296 3735 112288653 309364482", "output": "3" }, { "input": "775589210 6930 266348458 604992807", "output": "3" }, { "input": "249414894 1999 34827655 127026562", "output": "3" }, { "input": "566377385 227 424126063 478693454", "output": "3" }, { "input": "960442940 572344654 77422042 406189391", "output": "1" }, { "input": "291071313 592207814 6792338 181083636", "output": "1" }, { "input": "191971162 306112722 18212391 188328807", "output": "1" }, { "input": "609162932 300548167 21640850 411089609", "output": "2" }, { "input": "645010014 34698301 217620581 416292490", "output": "3" }, { "input": "51474721 867363452 12231088 43489285", "output": "1" }, { "input": "484381636 927869638 57278216 175514226", "output": "1" }, { "input": "491259590 529594367 305425951 326414536", "output": "1" }, { "input": "733405771 830380469 19971607 389270995", "output": "1" }, { "input": "446237720 920085248 296916273 439113596", "output": "1" }, { "input": "12 6 3 10", "output": "2" }, { "input": "25 2 8 11", "output": "2" }, { "input": "17 8 3 15", "output": "2" }, { "input": "9 2 4 7", "output": "2" }, { "input": "6 7 5 6", "output": "1" }, { "input": "13 2 1 6", "output": "1" }, { "input": "15 8 10 14", "output": "1" }, { "input": "27 2 5 13", "output": "2" }, { "input": "14 8 2 12", "output": "2" }, { "input": "61 1 10 38", "output": "1" }, { "input": "15 6 7 15", "output": "1" }, { "input": "100 1 2 15", "output": "1" }, { "input": "10 1 4 5", "output": "1" }, { "input": "6 3 1 6", "output": "1" }, { "input": "4 3 3 4", "output": "2" }, { "input": "5 2 1 5", "output": "1" }, { "input": "7 3 1 1", "output": "1" }, { "input": "7 3 1 2", "output": "1" }, { "input": "7 3 1 3", "output": "1" }, { "input": "7 3 1 4", "output": "2" }, { "input": "7 3 1 5", "output": "2" }, { "input": "7 3 1 6", "output": "1" }, { "input": "7 3 1 7", "output": "1" }, { "input": "7 3 2 2", "output": "1" }, { "input": "7 3 2 3", "output": "1" }, { "input": "7 3 2 4", "output": "2" }, { "input": "7 3 2 5", "output": "2" }, { "input": "7 3 2 6", "output": "2" }, { "input": "7 3 2 7", "output": "2" }, { "input": "7 3 3 3", "output": "1" }, { "input": "7 3 3 4", "output": "2" }, { "input": "7 3 3 5", "output": "2" }, { "input": "7 3 3 6", "output": "2" }, { "input": "7 3 3 7", "output": "2" }, { "input": "7 3 4 4", "output": "1" }, { "input": "7 3 4 5", "output": "1" }, { "input": "7 3 4 6", "output": "1" }, { "input": "7 3 4 7", "output": "1" }, { "input": "7 3 5 5", "output": "1" }, { "input": "7 3 5 6", "output": "1" }, { "input": "7 3 5 7", "output": "2" }, { "input": "7 3 6 6", "output": "1" }, { "input": "7 3 6 7", "output": "2" }, { "input": "7 3 7 7", "output": "1" }, { "input": "8 3 1 1", "output": "1" }, { "input": "8 3 1 2", "output": "1" }, { "input": "8 3 1 3", "output": "1" }, { "input": "8 3 1 4", "output": "2" }, { "input": "8 3 1 5", "output": "2" }, { "input": "8 3 1 6", "output": "1" }, { "input": "8 3 1 7", "output": "2" }, { "input": "8 3 1 8", "output": "1" }, { "input": "8 3 2 2", "output": "1" }, { "input": "8 3 2 3", "output": "1" }, { "input": "8 3 2 4", "output": "2" }, { "input": "8 3 2 5", "output": "2" }, { "input": "8 3 2 6", "output": "2" }, { "input": "8 3 2 7", "output": "2" }, { "input": "8 3 2 8", "output": "2" }, { "input": "8 3 3 3", "output": "1" }, { "input": "8 3 3 4", "output": "2" }, { "input": "8 3 3 5", "output": "2" }, { "input": "8 3 3 6", "output": "2" }, { "input": "8 3 3 7", "output": "3" }, { "input": "8 3 3 8", "output": "2" }, { "input": "8 3 4 4", "output": "1" }, { "input": "8 3 4 5", "output": "1" }, { "input": "8 3 4 6", "output": "1" }, { "input": "8 3 4 7", "output": "2" }, { "input": "8 3 4 8", "output": "1" }, { "input": "8 3 5 5", "output": "1" }, { "input": "8 3 5 6", "output": "1" }, { "input": "8 3 5 7", "output": "2" }, { "input": "8 3 5 8", "output": "2" }, { "input": "8 3 6 6", "output": "1" }, { "input": "8 3 6 7", "output": "2" }, { "input": "8 3 6 8", "output": "2" }, { "input": "8 3 7 7", "output": "1" }, { "input": "8 3 7 8", "output": "1" }, { "input": "8 3 8 8", "output": "1" } ]

1,507,291,481

4,181

Python 3

WRONG_ANSWER

TESTS

0

60

0

def main(): n = list(map(int, (input().strip().split()))) n, m, a, b = tuple(n) count = 0 minimum = m maximum = n + 1 for i in range(m, n, m): if a > i: maximum = min(maximum, i) if b < i: minimum = max(minimum, i) i += 1 if (maximum - 1) % m == 0: maximum -= 1 while maximum % m != 0: maximum += 1 if maximum / minimum <= 3: return int(maximum / minimum) else: count += 1 if a != minimum - m + 1: count += 1 if b != maximum: count += 1 return int(count) main()

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Throughout Igor K.'s life he has had many situations worthy of attention. We remember the story with the virus, the story of his mathematical career and of course, his famous programming achievements. However, one does not always adopt new hobbies, one can quit something as well. This time Igor K. got disappointed in one of his hobbies: editing and voicing videos. Moreover, he got disappointed in it so much, that he decided to destroy his secret archive for good. Igor K. use Pindows XR operation system which represents files and folders by small icons. At that, *m* icons can fit in a horizontal row in any window. Igor K.'s computer contains *n* folders in the D: disk's root catalog. The folders are numbered from 1 to *n* in the order from the left to the right and from top to bottom (see the images). At that the folders with secret videos have numbers from *a* to *b* inclusive. Igor K. wants to delete them forever, at that making as few frame selections as possible, and then pressing Shift+Delete exactly once. What is the minimum number of times Igor K. will have to select the folder in order to select folders from *a* to *b* and only them? Let us note that if some selected folder is selected repeatedly, then it is deselected. Each selection possesses the shape of some rectangle with sides parallel to the screen's borders. Input Specification: The only line contains four integers *n*, *m*, *a*, *b* (1<=≤<=*n*,<=*m*<=≤<=109, 1<=≤<=*a*<=≤<=*b*<=≤<=*n*). They are the number of folders in Igor K.'s computer, the width of a window and the numbers of the first and the last folders that need to be deleted. Output Specification: Print a single number: the least possible number of times Igor K. will have to select the folders using frames to select only the folders with numbers from *a* to *b*. Demo Input: ['11 4 3 9\n', '20 5 2 20\n'] Demo Output: ['3\n', '2\n'] Note: The images below illustrate statement tests. The first test: <img class="tex-graphics" src="https://espresso.codeforces.com/a0e4ba690dd16e3c68210a28afd82020b23fb605.png" style="max-width: 100.0%;max-height: 100.0%;"/> In this test we can select folders 3 and 4 with out first selection, folders 5, 6, 7, 8 with our second selection and folder 9 with our third, last selection. The second test: <img class="tex-graphics" src="https://espresso.codeforces.com/289e2666a3d8b3dfe5b22ff3d88976df711640f7.png" style="max-width: 100.0%;max-height: 100.0%;"/> In this test we can first select all folders in the first row (2, 3, 4, 5), then — all other ones.

```python def main(): n = list(map(int, (input().strip().split()))) n, m, a, b = tuple(n) count = 0 minimum = m maximum = n + 1 for i in range(m, n, m): if a > i: maximum = min(maximum, i) if b < i: minimum = max(minimum, i) i += 1 if (maximum - 1) % m == 0: maximum -= 1 while maximum % m != 0: maximum += 1 if maximum / minimum <= 3: return int(maximum / minimum) else: count += 1 if a != minimum - m + 1: count += 1 if b != maximum: count += 1 return int(count) main() ```

0

252

B

Unsorting Array

PROGRAMMING

1,800

[ "brute force", "sortings" ]

null

Little Petya likes arrays of integers a lot. Recently his mother has presented him one such array consisting of *n* elements. Petya is now wondering whether he can swap any two distinct integers in the array so that the array got unsorted. Please note that Petya can not swap equal integers even if they are in distinct positions in the array. Also note that Petya must swap some two integers even if the original array meets all requirements. Array *a* (the array elements are indexed from 1) consisting of *n* elements is called sorted if it meets at least one of the following two conditions: 1. *a*1<=≤<=*a*2<=≤<=...<=≤<=*a**n*; 1. *a*1<=≥<=*a*2<=≥<=...<=≥<=*a**n*. Help Petya find the two required positions to swap or else say that they do not exist.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105). The second line contains *n* non-negative space-separated integers *a*1,<=*a*2,<=...,<=*a**n* — the elements of the array that Petya's mother presented him. All integers in the input do not exceed 109.

If there is a pair of positions that make the array unsorted if swapped, then print the numbers of these positions separated by a space. If there are several pairs of positions, print any of them. If such pair does not exist, print -1. The positions in the array are numbered with integers from 1 to *n*.

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

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

In the first two samples the required pairs obviously don't exist. In the third sample you can swap the first two elements. After that the array will look like this: 2 1 3 4. This array is unsorted.

1,000

[ { "input": "1\n1", "output": "-1" }, { "input": "2\n1 2", "output": "-1" }, { "input": "4\n1 2 3 4", "output": "1 2" }, { "input": "3\n1 1 1", "output": "-1" }, { "input": "3\n1 2 2", "output": "1 2" }, { "input": "5\n1 1 1 1 2", "output": "2 5" }, { "input": "6\n1 2 3 3 2 1", "output": "1 2" }, { "input": "7\n6 5 4 3 2 1 0", "output": "1 2" }, { "input": "10\n1 2 1 2 1 2 1 2 1 2", "output": "1 2" }, { "input": "11\n1 1 1 1 1 2 2 2 2 2 1", "output": "1 6" }, { "input": "3\n1 2 1", "output": "-1" }, { "input": "4\n562617869 961148050 596819899 951133776", "output": "1 2" }, { "input": "4\n562617869 596819899 951133776 961148050", "output": "1 2" }, { "input": "4\n961148050 951133776 596819899 562617869", "output": "1 2" }, { "input": "4\n596819899 562617869 951133776 961148050", "output": "1 3" }, { "input": "4\n562617869 596819899 951133776 0", "output": "1 2" }, { "input": "4\n951133776 961148050 596819899 562617869", "output": "1 3" }, { "input": "4\n961148050 951133776 596819899 0", "output": "1 2" }, { "input": "4\n562617869 562617869 562617869 562617869", "output": "-1" }, { "input": "4\n961148050 961148050 562617869 961148050", "output": "2 3" }, { "input": "4\n562617869 961148050 961148050 961148050", "output": "1 2" }, { "input": "4\n961148050 961148050 961148050 562617869", "output": "2 4" }, { "input": "4\n961148050 562617869 961148050 961148050", "output": "2 3" }, { "input": "4\n562617869 961148050 961148050 961148050", "output": "1 2" }, { "input": "4\n562617869 961148050 562617869 562617869", "output": "2 3" }, { "input": "4\n562617869 562617869 562617869 961148050", "output": "2 4" }, { "input": "4\n961148050 562617869 562617869 562617869", "output": "1 2" }, { "input": "4\n961148050 562617869 961148050 961148050", "output": "2 3" }, { "input": "4\n961148050 961148050 562617869 961148050", "output": "2 3" }, { "input": "4\n562617869 562617869 961148050 562617869", "output": "2 3" }, { "input": "4\n562617869 961148050 562617869 562617869", "output": "2 3" }, { "input": "3\n2 1 3", "output": "1 3" }, { "input": "4\n2 1 3 4", "output": "1 3" }, { "input": "3\n2 1 2", "output": "-1" }, { "input": "5\n1 1 2 1 1", "output": "2 3" }, { "input": "3\n1 3 1", "output": "-1" }, { "input": "3\n1 3 2", "output": "1 2" }, { "input": "3\n3 2 3", "output": "-1" } ]

1,663,831,517

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

62

0

b = int(input()) M = list(map(int, input().split(' '))) s = [] mamad = False if M[0] > M[b - 1]: for i in range(1, b - 1): if M[0] > M[i]: s.append(1) s.append(i + 1) mamad = True break if mamad: print(s[0], end=' ') print(s[1], end=' ') else: print(-1) elif M[0] < M[b - 1]: for o in range(1, b - 1): if M[0] < M[o]: s.append(1) s.append(o + 1) mamad = True break if mamad: print(s[0], end=' ') print(s[1], end=' ') else: print(-1) else: print(-1)

Title: Unsorting Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Petya likes arrays of integers a lot. Recently his mother has presented him one such array consisting of *n* elements. Petya is now wondering whether he can swap any two distinct integers in the array so that the array got unsorted. Please note that Petya can not swap equal integers even if they are in distinct positions in the array. Also note that Petya must swap some two integers even if the original array meets all requirements. Array *a* (the array elements are indexed from 1) consisting of *n* elements is called sorted if it meets at least one of the following two conditions: 1. *a*1<=≤<=*a*2<=≤<=...<=≤<=*a**n*; 1. *a*1<=≥<=*a*2<=≥<=...<=≥<=*a**n*. Help Petya find the two required positions to swap or else say that they do not exist. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105). The second line contains *n* non-negative space-separated integers *a*1,<=*a*2,<=...,<=*a**n* — the elements of the array that Petya's mother presented him. All integers in the input do not exceed 109. Output Specification: If there is a pair of positions that make the array unsorted if swapped, then print the numbers of these positions separated by a space. If there are several pairs of positions, print any of them. If such pair does not exist, print -1. The positions in the array are numbered with integers from 1 to *n*. Demo Input: ['1\n1\n', '2\n1 2\n', '4\n1 2 3 4\n', '3\n1 1 1\n'] Demo Output: ['-1\n', '-1\n', '1 2\n', '-1\n'] Note: In the first two samples the required pairs obviously don't exist. In the third sample you can swap the first two elements. After that the array will look like this: 2 1 3 4. This array is unsorted.

```python b = int(input()) M = list(map(int, input().split(' '))) s = [] mamad = False if M[0] > M[b - 1]: for i in range(1, b - 1): if M[0] > M[i]: s.append(1) s.append(i + 1) mamad = True break if mamad: print(s[0], end=' ') print(s[1], end=' ') else: print(-1) elif M[0] < M[b - 1]: for o in range(1, b - 1): if M[0] < M[o]: s.append(1) s.append(o + 1) mamad = True break if mamad: print(s[0], end=' ') print(s[1], end=' ') else: print(-1) else: print(-1) ```

0

960

D

Full Binary Tree Queries

PROGRAMMING

2,100

[ "brute force", "implementation", "trees" ]

null

You have a full binary tree having infinite levels. Each node has an initial value. If a node has value *x*, then its left child has value 2·*x* and its right child has value 2·*x*<=+<=1. The value of the root is 1. You need to answer *Q* queries. There are 3 types of queries: 1. Cyclically shift the values of all nodes on the same level as node with value *X* by *K* units. (The values/nodes of any other level are not affected).1. Cyclically shift the nodes on the same level as node with value *X* by *K* units. (The subtrees of these nodes will move along with them).1. Print the value of every node encountered on the simple path from the node with value *X* to the root. Positive *K* implies right cyclic shift and negative *K* implies left cyclic shift. It is guaranteed that atleast one type 3 query is present.

The first line contains a single integer *Q* (1<=≤<=*Q*<=≤<=105). Then *Q* queries follow, one per line: - Queries of type 1 and 2 have the following format: *T* *X* *K* (1<=≤<=*T*<=≤<=2; 1<=≤<=*X*<=≤<=1018; 0<=≤<=|*K*|<=≤<=1018), where *T* is type of the query.- Queries of type 3 have the following format: 3 *X* (1<=≤<=*X*<=≤<=1018).

For each query of type 3, print the values of all nodes encountered in descending order.

[ "5\n3 12\n1 2 1\n3 12\n2 4 -1\n3 8\n", "5\n3 14\n1 5 -3\n3 14\n1 3 1\n3 14\n" ]

[ "12 6 3 1 \n12 6 2 1 \n8 4 2 1 \n", "14 7 3 1 \n14 6 3 1 \n14 6 2 1 \n" ]

Following are the images of the first 4 levels of the tree in the first test case: Original: After query 1 2 1: After query 2 4 -1:

2,000

[ { "input": "5\n3 12\n1 2 1\n3 12\n2 4 -1\n3 8", "output": "12 6 3 1 \n12 6 2 1 \n8 4 2 1 " }, { "input": "5\n3 14\n1 5 -3\n3 14\n1 3 1\n3 14", "output": "14 7 3 1 \n14 6 3 1 \n14 6 2 1 " }, { "input": "6\n3 1\n2 1 0\n3 10\n2 1 -4\n3 10\n2 10 -5", "output": "1 \n10 5 2 1 \n10 5 2 1 " }, { "input": "3\n3 1000000000000000000\n1 12345 13\n3 1000000000000000000", "output": "1000000000000000000 500000000000000000 250000000000000000 125000000000000000 62500000000000000 31250000000000000 15625000000000000 7812500000000000 3906250000000000 1953125000000000 976562500000000 488281250000000 244140625000000 122070312500000 61035156250000 30517578125000 15258789062500 7629394531250 3814697265625 1907348632812 953674316406 476837158203 238418579101 119209289550 59604644775 29802322387 14901161193 7450580596 3725290298 1862645149 931322574 465661287 232830643 116415321 58207660 29103830..." }, { "input": "10\n3 999\n3 822\n2 339 -75\n2 924 -56\n3 863\n3 311\n1 269 84\n2 604 9\n2 788 -98\n1 233 60", "output": "999 499 249 124 62 31 15 7 3 1 \n822 411 205 102 51 25 12 6 3 1 \n863 403 164 82 41 20 10 5 2 1 \n311 246 123 61 30 15 7 3 1 " }, { "input": "10\n2 64324170 41321444786551040\n2 58204973 -73473234074970084\n1 56906279 -33102897753191948\n1 50660486 43066512304447265\n2 5614300 55244615832513844\n3 63044213\n3 27109227\n3 65485686\n3 36441490\n1 59699160 -19214308468046677", "output": "63044213 19585619 9792809 4896404 4125156 2062578 1031289 515644 257822 128911 64455 32227 16113 8056 4028 2014 1007 503 251 125 62 31 15 7 3 1 \n27109227 13554613 6777306 2968455 1484227 742113 371056 185528 92764 46382 23191 11595 5797 2898 1449 724 362 181 90 45 22 11 5 2 1 \n65485686 20806355 10403177 5201588 2180596 1090298 545149 272574 136287 68143 34071 17035 8517 4258 2129 1064 532 266 133 66 33 16 8 4 2 1 \n36441490 23061473 11530736 5765368 2462486 1231243 615621 307810 153905 76952 38476 19238 ..." }, { "input": "2\n2 1 100000000000000000\n3 1000000000000000", "output": "1000000000000000 500000000000000 250000000000000 125000000000000 62500000000000 31250000000000 15625000000000 7812500000000 3906250000000 1953125000000 976562500000 488281250000 244140625000 122070312500 61035156250 30517578125 15258789062 7629394531 3814697265 1907348632 953674316 476837158 238418579 119209289 59604644 29802322 14901161 7450580 3725290 1862645 931322 465661 232830 116415 58207 29103 14551 7275 3637 1818 909 454 227 113 56 28 14 7 3 1 " } ]

1,523,130,364

2,147,483,647

PyPy 3

TIME_LIMIT_EXCEEDED

TESTS

7

4,000

29,798,400

q = int(input()) op1 = [0 for x in range(100)] def pw(n,k): s = 1 for x in range(k): s *= n return int(s) def getlvl(X): start = 1 end = 2 level = 0 while not (start <= X and X < end): start *= 2 end *= 2 level += 1 return level def mod(n,m): lo = 0 hi = 1000000000000 ans = 0 while lo <= hi: mid = int(int(lo+hi)/int(2)) if n+mid*m >= 0: ans = mid hi = mid-1 else: lo = mid+1 return int((n+m*ans)) % int(m) for test in range(q): A = [int(x) for x in input().split()] if A[0] <= 2: begin = getlvl(A[1]) to = 100 if A[0] == 1: to = begin+1 for x in range(begin,to): op1[x] += A[2] A[2] *= 2; else: level = getlvl(A[1]) arr = [] at = A[1] at -= pw(2,level) at = mod(at+op1[level], pw(2,level)) at += pw(2,level) arr.append(str(A[1])) while level != 0: old = at at //= 2 level -= 1 at -= pw(2,level) at = mod(at-op1[level], pw(2,level)) at += pw(2,level) arr.append(str(at)) at = old // 2 print(" ".join(arr))

Title: Full Binary Tree Queries Time Limit: None seconds Memory Limit: None megabytes Problem Description: You have a full binary tree having infinite levels. Each node has an initial value. If a node has value *x*, then its left child has value 2·*x* and its right child has value 2·*x*<=+<=1. The value of the root is 1. You need to answer *Q* queries. There are 3 types of queries: 1. Cyclically shift the values of all nodes on the same level as node with value *X* by *K* units. (The values/nodes of any other level are not affected).1. Cyclically shift the nodes on the same level as node with value *X* by *K* units. (The subtrees of these nodes will move along with them).1. Print the value of every node encountered on the simple path from the node with value *X* to the root. Positive *K* implies right cyclic shift and negative *K* implies left cyclic shift. It is guaranteed that atleast one type 3 query is present. Input Specification: The first line contains a single integer *Q* (1<=≤<=*Q*<=≤<=105). Then *Q* queries follow, one per line: - Queries of type 1 and 2 have the following format: *T* *X* *K* (1<=≤<=*T*<=≤<=2; 1<=≤<=*X*<=≤<=1018; 0<=≤<=|*K*|<=≤<=1018), where *T* is type of the query.- Queries of type 3 have the following format: 3 *X* (1<=≤<=*X*<=≤<=1018). Output Specification: For each query of type 3, print the values of all nodes encountered in descending order. Demo Input: ['5\n3 12\n1 2 1\n3 12\n2 4 -1\n3 8\n', '5\n3 14\n1 5 -3\n3 14\n1 3 1\n3 14\n'] Demo Output: ['12 6 3 1 \n12 6 2 1 \n8 4 2 1 \n', '14 7 3 1 \n14 6 3 1 \n14 6 2 1 \n'] Note: Following are the images of the first 4 levels of the tree in the first test case: Original: After query 1 2 1: After query 2 4 -1:

```python q = int(input()) op1 = [0 for x in range(100)] def pw(n,k): s = 1 for x in range(k): s *= n return int(s) def getlvl(X): start = 1 end = 2 level = 0 while not (start <= X and X < end): start *= 2 end *= 2 level += 1 return level def mod(n,m): lo = 0 hi = 1000000000000 ans = 0 while lo <= hi: mid = int(int(lo+hi)/int(2)) if n+mid*m >= 0: ans = mid hi = mid-1 else: lo = mid+1 return int((n+m*ans)) % int(m) for test in range(q): A = [int(x) for x in input().split()] if A[0] <= 2: begin = getlvl(A[1]) to = 100 if A[0] == 1: to = begin+1 for x in range(begin,to): op1[x] += A[2] A[2] *= 2; else: level = getlvl(A[1]) arr = [] at = A[1] at -= pw(2,level) at = mod(at+op1[level], pw(2,level)) at += pw(2,level) arr.append(str(A[1])) while level != 0: old = at at //= 2 level -= 1 at -= pw(2,level) at = mod(at-op1[level], pw(2,level)) at += pw(2,level) arr.append(str(at)) at = old // 2 print(" ".join(arr)) ```

0

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,668,143,785

2,147,483,647

Python 3

OK

TESTS

20

46

0

n,m,a=map(int, input().split()) if n%a==0 and m%a==0:print((n//a)*(m//a)) elif n%a==0:print((n//a)*(m//a+1)) elif m%a==0:print((n//a+1)*(m//a)) else:print((n//a+1)*(m//a+1))

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()) if n%a==0 and m%a==0:print((n//a)*(m//a)) elif n%a==0:print((n//a)*(m//a+1)) elif m%a==0:print((n//a+1)*(m//a)) else:print((n//a+1)*(m//a+1)) ```

3.977

312

B

Archer

PROGRAMMING

1,300

[ "math", "probabilities" ]

null

SmallR is an archer. SmallR is taking a match of archer with Zanoes. They try to shoot in the target in turns, and SmallR shoots first. The probability of shooting the target each time is for SmallR while for Zanoes. The one who shoots in the target first should be the winner. Output the probability that SmallR will win the match.

A single line contains four integers .

Print a single real number, the probability that SmallR will win the match. The answer will be considered correct if the absolute or relative error doesn't exceed 10<=-<=6.

[ "1 2 1 2\n" ]

[ "0.666666666667" ]

none

1,000

[ { "input": "1 2 1 2", "output": "0.666666666667" }, { "input": "1 3 1 3", "output": "0.600000000000" }, { "input": "1 3 2 3", "output": "0.428571428571" }, { "input": "3 4 3 4", "output": "0.800000000000" }, { "input": "1 2 10 11", "output": "0.523809523810" }, { "input": "4 5 4 5", "output": "0.833333333333" }, { "input": "466 701 95 721", "output": "0.937693791148" }, { "input": "268 470 444 885", "output": "0.725614009325" }, { "input": "632 916 713 821", "output": "0.719292895126" }, { "input": "269 656 918 992", "output": "0.428937461623" }, { "input": "71 657 187 695", "output": "0.310488463257" }, { "input": "435 852 973 978", "output": "0.511844133157" }, { "input": "518 816 243 359", "output": "0.719734031025" }, { "input": "882 962 311 811", "output": "0.966386645447" }, { "input": "684 774 580 736", "output": "0.906051574446" }, { "input": "486 868 929 999", "output": "0.577723252958" }, { "input": "132 359 996 998", "output": "0.368154532345" }, { "input": "933 977 266 450", "output": "0.972879407907" }, { "input": "298 833 615 872", "output": "0.441270817024" }, { "input": "34 554 14 958", "output": "0.817324099167" }, { "input": "836 934 800 905", "output": "0.906105535462" }, { "input": "482 815 69 509", "output": "0.914365577772" }, { "input": "284 423 137 521", "output": "0.885974839378" }, { "input": "648 881 486 703", "output": "0.800911421248" }, { "input": "450 885 755 836", "output": "0.533901011176" }, { "input": "533 773 823 998", "output": "0.729222130525" }, { "input": "897 957 92 898", "output": "0.993193806364" }, { "input": "699 925 441 928", "output": "0.866816866175" }, { "input": "64 704 148 603", "output": "0.289486317811" }, { "input": "719 735 626 990", "output": "0.986124079764" }, { "input": "1 1000 1 1000", "output": "0.500250125063" } ]

1,593,332,019

2,147,483,647

Python 3

OK

TESTS

31

109

6,656,000

a,b,c,d = map(int,input().split()) x = a*d y = a*d + b*c - a*c print(x/y)

Title: Archer Time Limit: None seconds Memory Limit: None megabytes Problem Description: SmallR is an archer. SmallR is taking a match of archer with Zanoes. They try to shoot in the target in turns, and SmallR shoots first. The probability of shooting the target each time is for SmallR while for Zanoes. The one who shoots in the target first should be the winner. Output the probability that SmallR will win the match. Input Specification: A single line contains four integers . Output Specification: Print a single real number, the probability that SmallR will win the match. The answer will be considered correct if the absolute or relative error doesn't exceed 10<=-<=6. Demo Input: ['1 2 1 2\n'] Demo Output: ['0.666666666667'] Note: none

```python a,b,c,d = map(int,input().split()) x = a*d y = a*d + b*c - a*c print(x/y) ```

3

535

B

Tavas and SaDDas

PROGRAMMING

1,100

[ "bitmasks", "brute force", "combinatorics", "implementation" ]

null

Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you." The problem is: You are given a lucky number *n*. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. If we sort all lucky numbers in increasing order, what's the 1-based index of *n*? Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back.

The first and only line of input contains a lucky number *n* (1<=≤<=*n*<=≤<=109).

Print the index of *n* among all lucky numbers.

[ "4\n", "7\n", "77\n" ]

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

none

1,000

[ { "input": "4", "output": "1" }, { "input": "7", "output": "2" }, { "input": "77", "output": "6" }, { "input": "4", "output": "1" }, { "input": "474744", "output": "83" }, { "input": "777774", "output": "125" }, { "input": "447", "output": "8" }, { "input": "774", "output": "13" }, { "input": "4", "output": "1" }, { "input": "4447747", "output": "140" }, { "input": "7747474", "output": "233" }, { "input": "4444", "output": "15" }, { "input": "4447", "output": "16" }, { "input": "7", "output": "2" }, { "input": "4", "output": "1" }, { "input": "4447744", "output": "139" }, { "input": "77474", "output": "57" }, { "input": "7747", "output": "28" }, { "input": "444", "output": "7" }, { "input": "7", "output": "2" }, { "input": "7774477", "output": "242" }, { "input": "4477774", "output": "157" }, { "input": "7444", "output": "23" }, { "input": "7474747", "output": "212" }, { "input": "77", "output": "6" }, { "input": "774477", "output": "114" }, { "input": "7", "output": "2" }, { "input": "47", "output": "4" }, { "input": "747777", "output": "110" }, { "input": "444444444", "output": "511" }, { "input": "777777777", "output": "1022" }, { "input": "477477447", "output": "728" }, { "input": "777744747", "output": "996" } ]

1,596,890,294

2,147,483,647

PyPy 3

OK

TESTS

33

155

22,016,000

#Anuneet Anand n = input() x = len(n)-1 y = len(n) a = 2 * (2**x-1) Z = [] for i in range(2**y): b = bin(i)[2:] b = "0"*(y-len(b))+b t = "" for j in range(y): if b[j]=="1": t = t + "4" else: t = t + "7" Z.append(t) Z.sort() for i in range(len(Z)): if Z[i]==n: print(a+i+1) break

Title: Tavas and SaDDas Time Limit: None seconds Memory Limit: None megabytes Problem Description: Once again Tavas started eating coffee mix without water! Keione told him that it smells awful, but he didn't stop doing that. That's why Keione told his smart friend, SaDDas to punish him! SaDDas took Tavas' headphones and told him: "If you solve the following problem, I'll return it to you." The problem is: You are given a lucky number *n*. Lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. If we sort all lucky numbers in increasing order, what's the 1-based index of *n*? Tavas is not as smart as SaDDas, so he asked you to do him a favor and solve this problem so he can have his headphones back. Input Specification: The first and only line of input contains a lucky number *n* (1<=≤<=*n*<=≤<=109). Output Specification: Print the index of *n* among all lucky numbers. Demo Input: ['4\n', '7\n', '77\n'] Demo Output: ['1\n', '2\n', '6\n'] Note: none

```python #Anuneet Anand n = input() x = len(n)-1 y = len(n) a = 2 * (2**x-1) Z = [] for i in range(2**y): b = bin(i)[2:] b = "0"*(y-len(b))+b t = "" for j in range(y): if b[j]=="1": t = t + "4" else: t = t + "7" Z.append(t) Z.sort() for i in range(len(Z)): if Z[i]==n: print(a+i+1) break ```

3

106

C

Buns

PROGRAMMING

1,700

[ "dp" ]

C. Buns

2

256

Lavrenty, a baker, is going to make several buns with stuffings and sell them. Lavrenty has *n* grams of dough as well as *m* different stuffing types. The stuffing types are numerated from 1 to *m*. Lavrenty knows that he has *a**i* grams left of the *i*-th stuffing. It takes exactly *b**i* grams of stuffing *i* and *c**i* grams of dough to cook a bun with the *i*-th stuffing. Such bun can be sold for *d**i* tugriks. Also he can make buns without stuffings. Each of such buns requires *c*0 grams of dough and it can be sold for *d*0 tugriks. So Lavrenty can cook any number of buns with different stuffings or without it unless he runs out of dough and the stuffings. Lavrenty throws away all excess material left after baking. Find the maximum number of tugriks Lavrenty can earn.

The first line contains 4 integers *n*, *m*, *c*0 and *d*0 (1<=≤<=*n*<=≤<=1000, 1<=≤<=*m*<=≤<=10, 1<=≤<=*c*0,<=*d*0<=≤<=100). Each of the following *m* lines contains 4 integers. The *i*-th line contains numbers *a**i*, *b**i*, *c**i* and *d**i* (1<=≤<=*a**i*,<=*b**i*,<=*c**i*,<=*d**i*<=≤<=100).

Print the only number — the maximum number of tugriks Lavrenty can earn.

[ "10 2 2 1\n7 3 2 100\n12 3 1 10\n", "100 1 25 50\n15 5 20 10\n" ]

[ "241", "200" ]

To get the maximum number of tugriks in the first sample, you need to cook 2 buns with stuffing 1, 4 buns with stuffing 2 and a bun without any stuffing. In the second sample Lavrenty should cook 4 buns without stuffings.

1,500

[ { "input": "10 2 2 1\n7 3 2 100\n12 3 1 10", "output": "241" }, { "input": "100 1 25 50\n15 5 20 10", "output": "200" }, { "input": "10 1 5 2\n100 1 2 3", "output": "15" }, { "input": "10 1 5 11\n3 1 3 8", "output": "24" }, { "input": "10 2 11 5\n100 1 3 10\n100 1 2 4", "output": "30" }, { "input": "5 8 6 5\n1 2 5 4\n1 2 6 7\n1 2 3 5\n1 2 1 6\n1 2 8 3\n1 2 2 4\n1 2 5 6\n1 2 7 7", "output": "0" }, { "input": "300 4 100 2\n10 1 24 5\n10 1 25 6\n10 1 26 7\n10 1 27 8", "output": "87" }, { "input": "1 1 1 1\n1 1 1 1", "output": "1" }, { "input": "2 1 2 1\n1 2 1 1", "output": "1" }, { "input": "10 2 13 100\n20 1 3 10\n20 1 2 6", "output": "32" }, { "input": "100 5 8 80\n25 8 2 70\n27 6 7 30\n26 1 6 5\n7 1 1 86\n18 8 4 54", "output": "1670" }, { "input": "150 8 3 46\n39 4 10 25\n31 17 8 70\n37 2 13 1\n29 17 17 59\n54 20 5 39\n53 14 10 23\n50 12 16 41\n8 2 6 61", "output": "2300" }, { "input": "231 10 9 30\n98 11 5 17\n59 13 1 47\n83 1 7 2\n42 21 1 6\n50 16 2 9\n44 10 5 31\n12 20 8 9\n61 23 7 2\n85 18 2 19\n82 25 10 20", "output": "1065" }, { "input": "345 10 5 45\n1 23 14 55\n51 26 15 11\n65 4 16 36\n81 14 13 25\n8 9 13 60\n43 4 7 59\n85 11 14 35\n82 13 5 49\n85 28 15 3\n51 21 18 53", "output": "3129" }, { "input": "401 10 2 82\n17 9 14 48\n79 4 3 38\n1 2 6 31\n45 2 9 60\n45 2 4 50\n6 1 3 36\n3 1 19 37\n78 3 8 33\n59 8 19 19\n65 10 2 61", "output": "16400" }, { "input": "777 10 23 20\n50 90 86 69\n33 90 59 73\n79 26 35 31\n57 48 97 4\n5 10 48 87\n35 99 33 34\n7 32 54 35\n56 25 10 38\n5 3 89 76\n13 33 91 66", "output": "734" }, { "input": "990 10 7 20\n38 82 14 69\n5 66 51 5\n11 26 91 11\n29 12 73 96\n93 82 48 59\n19 15 5 50\n15 36 6 63\n16 57 94 90\n45 3 57 72\n61 41 47 18", "output": "2850" }, { "input": "1000 10 51 56\n2 62 82 65\n37 90 87 97\n11 94 47 95\n49 24 97 24\n33 38 40 31\n27 15 17 66\n91 80 34 71\n60 93 42 94\n9 35 73 68\n93 65 83 58", "output": "1145" }, { "input": "1000 10 1 53\n63 1 1 58\n58 1 2 28\n100 1 1 25\n61 1 1 90\n96 2 2 50\n19 2 1 90\n7 2 1 30\n90 1 2 5\n34 2 1 12\n3 2 1 96", "output": "55948" }, { "input": "1000 10 1 65\n77 1 1 36\n74 1 1 41\n96 1 1 38\n48 1 1 35\n1 1 1 54\n42 1 1 67\n26 1 1 23\n43 1 1 89\n82 1 1 7\n45 1 1 63", "output": "66116" }, { "input": "1000 10 1 87\n100 1 1 38\n100 1 1 45\n100 1 1 73\n100 1 1 89\n100 1 1 38\n100 1 1 13\n100 1 1 93\n100 1 1 89\n100 1 1 71\n100 1 1 29", "output": "88000" }, { "input": "1000 10 1 7\n100 1 1 89\n100 1 1 38\n100 1 1 13\n100 1 1 93\n100 1 1 89\n100 1 1 38\n100 1 1 45\n100 1 1 73\n100 1 1 71\n100 1 1 29", "output": "57800" }, { "input": "1000 10 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100\n100 1 1 100", "output": "100000" }, { "input": "99 10 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100\n100 1 100 100", "output": "0" }, { "input": "1000 10 100 75\n100 97 100 95\n100 64 100 78\n100 82 100 35\n100 51 100 64\n100 67 100 25\n100 79 100 33\n100 65 100 85\n100 99 100 78\n100 53 100 74\n100 87 100 73", "output": "786" }, { "input": "999 10 5 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100\n100 1 10 100", "output": "19900" }, { "input": "1000 10 50 100\n7 1 80 100\n5 1 37 100\n9 1 25 100\n7 1 17 100\n6 1 10 100\n5 1 15 100\n6 1 13 100\n2 1 14 100\n4 1 17 100\n3 1 32 100", "output": "4800" }, { "input": "1000 10 1 1\n1 2 1 97\n1 2 1 95\n1 2 1 99\n1 2 1 98\n1 2 1 93\n1 2 1 91\n1 2 1 90\n1 2 1 94\n1 2 1 92\n1 2 1 99", "output": "1000" }, { "input": "1 10 1 97\n1 1 1 98\n1 1 1 99\n1 1 1 76\n1 1 1 89\n1 1 1 64\n1 1 1 83\n1 1 1 72\n1 1 1 66\n1 1 1 54\n1 1 1 73", "output": "99" }, { "input": "3 10 10 98\n10 5 5 97\n6 7 1 56\n23 10 5 78\n40 36 4 35\n30 50 1 30\n60 56 8 35\n70 90 2 17\n10 11 3 68\n1 2 17 70\n13 4 8 19", "output": "0" }, { "input": "1000 1 23 76\n74 22 14 5", "output": "3268" }, { "input": "1000 2 95 56\n58 54 66 61\n61 14 67 65", "output": "713" }, { "input": "1000 3 67 88\n90 86 66 17\n97 38 63 17\n55 78 39 51", "output": "1232" }, { "input": "1000 4 91 20\n74 18 18 73\n33 10 59 21\n7 42 87 79\n9 100 77 100", "output": "515" }, { "input": "1000 5 63 52\n6 98 18 77\n17 34 3 73\n59 6 35 7\n61 16 85 64\n73 62 40 11", "output": "804" }, { "input": "1000 6 87 32\n90 30 70 33\n53 6 99 77\n59 22 83 35\n65 32 93 28\n85 50 60 7\n15 15 5 82", "output": "771" }, { "input": "1000 7 59 64\n22 62 70 89\n37 78 43 29\n11 86 83 63\n17 48 1 92\n97 38 80 55\n15 3 89 42\n87 80 62 35", "output": "1024" }, { "input": "1000 8 31 96\n6 94 70 93\n73 2 39 33\n63 50 31 91\n21 64 9 56\n61 26 100 51\n67 39 21 50\n79 4 2 71\n100 9 18 86", "output": "4609" }, { "input": "1000 9 55 28\n38 74 22 49\n9 74 83 85\n63 66 79 19\n25 32 17 20\n73 62 20 47\n19 27 53 58\n71 80 94 7\n56 69 62 98\n49 7 65 76", "output": "831" }, { "input": "1000 10 67 55\n10 21 31 19\n95 29 53 1\n55 53 19 18\n26 88 19 94\n31 1 45 50\n70 38 33 93\n2 12 7 95\n54 37 81 31\n65 32 63 16\n93 66 98 38", "output": "1161" }, { "input": "1000 10 37 38\n65 27 78 14\n16 70 78 66\n93 86 91 43\n95 6 72 86\n72 59 94 36\n66 58 96 40\n41 72 64 4\n26 47 69 13\n85 2 52 15\n34 62 16 79", "output": "1156" }, { "input": "1000 10 58 21\n73 85 73 10\n38 60 55 31\n32 66 62 16\n63 76 73 78\n61 17 92 70\n61 79 11 87\n27 31 21 62\n47 9 4 94\n4 71 42 61\n76 5 35 72", "output": "1823" }, { "input": "12 2 100 1\n100 1 9 10\n100 1 4 4", "output": "12" }, { "input": "1 1 1 10\n100 100 1 100", "output": "100" }, { "input": "10 3 5 1\n100 1 3 7\n100 1 2 5\n1 1 1 10", "output": "32" }, { "input": "10 3 5 1\n100 1 3 7\n100 1 2 5\n1 1 1 10", "output": "32" }, { "input": "1000 10 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1\n100 1 1 1", "output": "1000" }, { "input": "10 2 100 1\n4 4 5 7\n6 2 3 4", "output": "12" }, { "input": "8 2 10 10\n5 5 5 15\n50 5 4 8", "output": "16" }, { "input": "8 2 10 10\n5 5 5 15\n50 5 4 8", "output": "16" }, { "input": "4 1 2 4\n10 1 3 7", "output": "8" }, { "input": "4 1 2 4\n10 1 3 7", "output": "8" }, { "input": "10 2 5 1\n100 1 2 5\n100 1 3 8", "output": "26" }, { "input": "1000 10 10 10\n100 1 1 1\n100 1 1 2\n100 1 2 1\n100 1 2 2\n100 1 1 1\n100 1 2 3\n100 1 3 2\n100 1 3 3\n100 1 1 3\n100 1 3 1", "output": "1400" }, { "input": "10 3 5 1\n100 1 3 7\n100 1 2 5\n1 1 1 10", "output": "32" } ]

1,644,066,178

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

9

654

37,068,800

import math import sys import queue import itertools from heapq import heappop, heappush import random mod = 1000000007 def solve(): n, m, c0, d0 = map(int, input().split()) f = [] order = [list(i) for i in itertools.permutations([j for j in range(m + 1)], m + 1)] for i in range(m): a, b, c, d = map(int, input().split()) f.append([a, b, c, d]) best = 0 # big brain names moment for o in order: current = 0 rem_n = n * 1 for h in o: if h == m: current += rem_n // c0 * d0 break can_do = min(f[h][0] // f[h][1], rem_n // f[h][2]) rem_n -= can_do * f[h][2] current += f[h][3] * can_do best = max(best, current) print(best) if __name__ == '__main__': multi_test = 0 if multi_test: t = int(sys.stdin.readline()) for _ in range(t): solve() else: solve()

Title: Buns Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Lavrenty, a baker, is going to make several buns with stuffings and sell them. Lavrenty has *n* grams of dough as well as *m* different stuffing types. The stuffing types are numerated from 1 to *m*. Lavrenty knows that he has *a**i* grams left of the *i*-th stuffing. It takes exactly *b**i* grams of stuffing *i* and *c**i* grams of dough to cook a bun with the *i*-th stuffing. Such bun can be sold for *d**i* tugriks. Also he can make buns without stuffings. Each of such buns requires *c*0 grams of dough and it can be sold for *d*0 tugriks. So Lavrenty can cook any number of buns with different stuffings or without it unless he runs out of dough and the stuffings. Lavrenty throws away all excess material left after baking. Find the maximum number of tugriks Lavrenty can earn. Input Specification: The first line contains 4 integers *n*, *m*, *c*0 and *d*0 (1<=≤<=*n*<=≤<=1000, 1<=≤<=*m*<=≤<=10, 1<=≤<=*c*0,<=*d*0<=≤<=100). Each of the following *m* lines contains 4 integers. The *i*-th line contains numbers *a**i*, *b**i*, *c**i* and *d**i* (1<=≤<=*a**i*,<=*b**i*,<=*c**i*,<=*d**i*<=≤<=100). Output Specification: Print the only number — the maximum number of tugriks Lavrenty can earn. Demo Input: ['10 2 2 1\n7 3 2 100\n12 3 1 10\n', '100 1 25 50\n15 5 20 10\n'] Demo Output: ['241', '200'] Note: To get the maximum number of tugriks in the first sample, you need to cook 2 buns with stuffing 1, 4 buns with stuffing 2 and a bun without any stuffing. In the second sample Lavrenty should cook 4 buns without stuffings.

```python import math import sys import queue import itertools from heapq import heappop, heappush import random mod = 1000000007 def solve(): n, m, c0, d0 = map(int, input().split()) f = [] order = [list(i) for i in itertools.permutations([j for j in range(m + 1)], m + 1)] for i in range(m): a, b, c, d = map(int, input().split()) f.append([a, b, c, d]) best = 0 # big brain names moment for o in order: current = 0 rem_n = n * 1 for h in o: if h == m: current += rem_n // c0 * d0 break can_do = min(f[h][0] // f[h][1], rem_n // f[h][2]) rem_n -= can_do * f[h][2] current += f[h][3] * can_do best = max(best, current) print(best) if __name__ == '__main__': multi_test = 0 if multi_test: t = int(sys.stdin.readline()) for _ in range(t): solve() else: solve() ```

0

960

A

Check the string

PROGRAMMING

1,200

[ "implementation" ]

null

A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string. B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time. You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes).

The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'.

Print "YES" or "NO", according to the condition.

[ "aaabccc\n", "bbacc\n", "aabc\n" ]

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

Consider first example: the number of 'c' is equal to the number of 'a'. Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct. Consider third example: the number of 'c' is equal to the number of 'b'.

500

[ { "input": "aaabccc", "output": "YES" }, { "input": "bbacc", "output": "NO" }, { "input": "aabc", "output": "YES" }, { "input": "aabbcc", "output": "YES" }, { "input": "aaacccbb", "output": "NO" }, { "input": "abc", "output": "YES" }, { "input": "acba", "output": "NO" }, { "input": "bbabbc", "output": "NO" }, { "input": "bbbabacca", "output": "NO" }, { "input": "aabcbcaca", "output": "NO" }, { "input": "aaaaabbbbbb", "output": "NO" }, { "input": "c", "output": "NO" }, { "input": "cc", "output": "NO" }, { "input": "bbb", "output": "NO" }, { "input": "bc", "output": "NO" }, { "input": "ccbcc", "output": "NO" }, { "input": "aaa", "output": "NO" }, { "input": "aaccaa", "output": "NO" }, { "input": "a", "output": "NO" }, { "input": "b", "output": "NO" }, { "input": "abca", "output": "NO" }, { "input": "aabbcccc", "output": "NO" }, { "input": "abac", "output": "NO" }, { "input": "abcc", "output": "NO" }, { "input": "abcb", "output": "NO" }, { "input": "aacc", "output": "NO" }, { "input": "aabbaacccc", "output": "NO" }, { "input": "aabb", "output": "NO" }, { "input": "ac", "output": "NO" }, { "input": "abbacc", "output": "NO" }, { "input": "abacc", "output": "NO" }, { "input": "ababc", "output": "NO" }, { "input": "aa", "output": "NO" }, { "input": "aabaccc", "output": "NO" }, { "input": "bbcc", "output": "NO" }, { "input": "aaabcbc", "output": "NO" }, { "input": "acbbc", "output": "NO" }, { "input": "babc", "output": "NO" }, { "input": "bbbcc", "output": "NO" }, { "input": "bbc", "output": "NO" }, { "input": "abababccc", "output": "NO" }, { "input": "ccbbaa", "output": "NO" } ]

1,638,344,805

2,147,483,647

PyPy 3-64

OK

TESTS

55

62

614,400

s=input() ar=list(s) p=0 if(ar!=sorted(ar)): print("NO") else: if(("a" in s) and ("b" in s) and ("c" in s)): if(ar.count("c")==ar.count("a") or ar.count("c")==ar.count("b")): print("YES") else: print("NO") else: print("NO")

Title: Check the string Time Limit: None seconds Memory Limit: None megabytes Problem Description: A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string. B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time. You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes). Input Specification: The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'. Output Specification: Print "YES" or "NO", according to the condition. Demo Input: ['aaabccc\n', 'bbacc\n', 'aabc\n'] Demo Output: ['YES\n', 'NO\n', 'YES\n'] Note: Consider first example: the number of 'c' is equal to the number of 'a'. Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct. Consider third example: the number of 'c' is equal to the number of 'b'.

```python s=input() ar=list(s) p=0 if(ar!=sorted(ar)): print("NO") else: if(("a" in s) and ("b" in s) and ("c" in s)): if(ar.count("c")==ar.count("a") or ar.count("c")==ar.count("b")): print("YES") else: print("NO") else: print("NO") ```

3

32

C

Flea

PROGRAMMING

1,700

[ "math" ]

C. Flea

2

256

It is known that fleas in Berland can jump only vertically and horizontally, and the length of the jump is always equal to *s* centimeters. A flea has found herself at the center of some cell of the checked board of the size *n*<=×<=*m* centimeters (each cell is 1<=×<=1 centimeters). She can jump as she wishes for an arbitrary number of times, she can even visit a cell more than once. The only restriction is that she cannot jump out of the board. The flea can count the amount of cells that she can reach from the starting position (*x*,<=*y*). Let's denote this amount by *d**x*,<=*y*. Your task is to find the number of such starting positions (*x*,<=*y*), which have the maximum possible value of *d**x*,<=*y*.

The first line contains three integers *n*, *m*, *s* (1<=≤<=*n*,<=*m*,<=*s*<=≤<=106) — length of the board, width of the board and length of the flea's jump.

Output the only integer — the number of the required starting positions of the flea.

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

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

none

1,500

[ { "input": "2 3 1000000", "output": "6" }, { "input": "3 3 2", "output": "4" }, { "input": "1 2 3", "output": "2" }, { "input": "4 5 6", "output": "20" }, { "input": "9 8 7", "output": "8" }, { "input": "1000 1000 1000", "output": "1000000" }, { "input": "1 1 1", "output": "1" }, { "input": "1 1 2", "output": "1" }, { "input": "1 1 1000000", "output": "1" }, { "input": "1000000 1000000 1", "output": "1000000000000" }, { "input": "1000000 1000000 2", "output": "1000000000000" }, { "input": "1000000 1000000 999999", "output": "4" }, { "input": "1000000 1000000 12345", "output": "20340100" }, { "input": "1000000 1000000 123456", "output": "12358324224" }, { "input": "43496 179847 327622", "output": "7822625112" }, { "input": "105126 379125 460772", "output": "39855894750" }, { "input": "999463 261665 981183", "output": "9566472400" }, { "input": "836832 336228 50", "output": "100850467200" }, { "input": "303307 400683 999941", "output": "121529958681" }, { "input": "40224 890892 54", "output": "31858297920" }, { "input": "109785 447109 990618", "output": "49085861565" }, { "input": "228385 744978 699604", "output": "20725481980" }, { "input": "694117 431924 737", "output": "13934440800" }, { "input": "923179 799988 998430", "output": "738532121852" }, { "input": "61043 55049 998379", "output": "3360356107" }, { "input": "402841 635488 997633", "output": "256000621408" }, { "input": "213927 672636 865", "output": "27867287808" }, { "input": "391814 220151 3756", "output": "16977831150" }, { "input": "313667 778854 999813", "output": "244300797618" }, { "input": "933241 558702 1", "output": "521403613182" }, { "input": "38614 941895 999986", "output": "36370333530" }, { "input": "242366 216591 4", "output": "19685613696" }, { "input": "282798 941695 999998", "output": "266309462610" }, { "input": "43054 191 1", "output": "8223314" } ]

1,580,101,891

2,147,483,647

Python 3

OK

TESTS

34

218

307,200

n,m,s=[int(s) for s in input().split()] a=(n % s) b=(m % s) if a==0 and n>=s:a=s if b==0 and m>=s:b=s unit=(a*b) print(((n-1)//s+1)*((m-1)//s+1)*unit)

Title: Flea Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: It is known that fleas in Berland can jump only vertically and horizontally, and the length of the jump is always equal to *s* centimeters. A flea has found herself at the center of some cell of the checked board of the size *n*<=×<=*m* centimeters (each cell is 1<=×<=1 centimeters). She can jump as she wishes for an arbitrary number of times, she can even visit a cell more than once. The only restriction is that she cannot jump out of the board. The flea can count the amount of cells that she can reach from the starting position (*x*,<=*y*). Let's denote this amount by *d**x*,<=*y*. Your task is to find the number of such starting positions (*x*,<=*y*), which have the maximum possible value of *d**x*,<=*y*. Input Specification: The first line contains three integers *n*, *m*, *s* (1<=≤<=*n*,<=*m*,<=*s*<=≤<=106) — length of the board, width of the board and length of the flea's jump. Output Specification: Output the only integer — the number of the required starting positions of the flea. Demo Input: ['2 3 1000000\n', '3 3 2\n'] Demo Output: ['6\n', '4\n'] Note: none

```python n,m,s=[int(s) for s in input().split()] a=(n % s) b=(m % s) if a==0 and n>=s:a=s if b==0 and m>=s:b=s unit=(a*b) print(((n-1)//s+1)*((m-1)//s+1)*unit) ```

3.944928

75

A

Life Without Zeros

PROGRAMMING

1,000

[ "implementation" ]

A. Life Without Zeros

2

256

Can you imagine our life if we removed all zeros from it? For sure we will have many problems. In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assume you are given this equation *a*<=+<=*b*<==<=*c*, where *a* and *b* are positive integers, and *c* is the sum of *a* and *b*. Now let's remove all zeros from this equation. Will the equation remain correct after removing all zeros? For example if the equation is 101<=+<=102<==<=203, if we removed all zeros it will be 11<=+<=12<==<=23 which is still a correct equation. But if the equation is 105<=+<=106<==<=211, if we removed all zeros it will be 15<=+<=16<==<=211 which is not a correct equation.

The input will consist of two lines, the first line will contain the integer *a*, and the second line will contain the integer *b* which are in the equation as described above (1<=≤<=*a*,<=*b*<=≤<=109). There won't be any leading zeros in both. The value of *c* should be calculated as *c*<==<=*a*<=+<=*b*.

The output will be just one line, you should print "YES" if the equation will remain correct after removing all zeros, and print "NO" otherwise.

[ "101\n102\n", "105\n106\n" ]

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

none

500

[ { "input": "101\n102", "output": "YES" }, { "input": "105\n106", "output": "NO" }, { "input": "544\n397", "output": "YES" }, { "input": "822\n280", "output": "NO" }, { "input": "101\n413", "output": "NO" }, { "input": "309\n139", "output": "NO" }, { "input": "693\n970", "output": "NO" }, { "input": "981\n1", "output": "YES" }, { "input": "352\n276", "output": "YES" }, { "input": "164\n691", "output": "YES" }, { "input": "110036\n43", "output": "YES" }, { "input": "100\n1000", "output": "NO" }, { "input": "1000000000\n1000000000", "output": "YES" }, { "input": "999999999\n999999999", "output": "YES" }, { "input": "6\n4", "output": "NO" }, { "input": "123456\n876543", "output": "YES" }, { "input": "1234567\n9876543", "output": "NO" }, { "input": "1111111\n1119111", "output": "NO" }, { "input": "10502405\n40403403", "output": "YES" }, { "input": "1\n1", "output": "YES" }, { "input": "5\n4", "output": "YES" }, { "input": "1\n6", "output": "YES" }, { "input": "40\n17", "output": "NO" }, { "input": "35\n81", "output": "YES" }, { "input": "347\n908", "output": "NO" }, { "input": "2081\n7450", "output": "NO" }, { "input": "84355694\n373629503", "output": "NO" }, { "input": "885992048\n510468672", "output": "NO" }, { "input": "540144752\n647307841", "output": "NO" }, { "input": "341781108\n784147010", "output": "NO" }, { "input": "960440938\n572334653", "output": "NO" }, { "input": "657414510\n768771903", "output": "NO" }, { "input": "501871728\n725074574", "output": "NO" }, { "input": "968\n851", "output": "YES" }, { "input": "943\n939", "output": "YES" }, { "input": "347\n908", "output": "NO" }, { "input": "611\n41", "output": "YES" }, { "input": "737\n289", "output": "NO" }, { "input": "168\n571", "output": "YES" }, { "input": "868\n463", "output": "YES" }, { "input": "815732007\n913882008", "output": "NO" }, { "input": "459039901\n453033850", "output": "NO" }, { "input": "975305404\n484601256", "output": "NO" } ]

1,680,578,791

2,147,483,647

Python 3

OK

TESTS

43

124

0

a = int(input()) b = int(input()) c = a + b rem_a = int(''.join(c for c in str(a) if c != '0')) rem_b = int(''.join(c for c in str(b) if c != '0')) rem_c = int(''.join(c for c in str(c) if c != '0')) if rem_a + rem_b == rem_c: print("YES") else: print("NO")

Title: Life Without Zeros Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Can you imagine our life if we removed all zeros from it? For sure we will have many problems. In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assume you are given this equation *a*<=+<=*b*<==<=*c*, where *a* and *b* are positive integers, and *c* is the sum of *a* and *b*. Now let's remove all zeros from this equation. Will the equation remain correct after removing all zeros? For example if the equation is 101<=+<=102<==<=203, if we removed all zeros it will be 11<=+<=12<==<=23 which is still a correct equation. But if the equation is 105<=+<=106<==<=211, if we removed all zeros it will be 15<=+<=16<==<=211 which is not a correct equation. Input Specification: The input will consist of two lines, the first line will contain the integer *a*, and the second line will contain the integer *b* which are in the equation as described above (1<=≤<=*a*,<=*b*<=≤<=109). There won't be any leading zeros in both. The value of *c* should be calculated as *c*<==<=*a*<=+<=*b*. Output Specification: The output will be just one line, you should print "YES" if the equation will remain correct after removing all zeros, and print "NO" otherwise. Demo Input: ['101\n102\n', '105\n106\n'] Demo Output: ['YES\n', 'NO\n'] Note: none

```python a = int(input()) b = int(input()) c = a + b rem_a = int(''.join(c for c in str(a) if c != '0')) rem_b = int(''.join(c for c in str(b) if c != '0')) rem_c = int(''.join(c for c in str(c) if c != '0')) if rem_a + rem_b == rem_c: print("YES") else: print("NO") ```

3.969

801

B

Valued Keys

PROGRAMMING

900

[ "constructive algorithms", "greedy", "strings" ]

null

You found a mysterious function *f*. The function takes two strings *s*1 and *s*2. These strings must consist only of lowercase English letters, and must be the same length. The output of the function *f* is another string of the same length. The *i*-th character of the output is equal to the minimum of the *i*-th character of *s*1 and the *i*-th character of *s*2. For example, *f*("ab", "ba") = "aa", and *f*("nzwzl", "zizez") = "niwel". You found two strings *x* and *y* of the same length and consisting of only lowercase English letters. Find any string *z* such that *f*(*x*,<=*z*)<==<=*y*, or print -1 if no such string *z* exists.

The first line of input contains the string *x*. The second line of input contains the string *y*. Both *x* and *y* consist only of lowercase English letters, *x* and *y* have same length and this length is between 1 and 100.

If there is no string *z* such that *f*(*x*,<=*z*)<==<=*y*, print -1. Otherwise, print a string *z* such that *f*(*x*,<=*z*)<==<=*y*. If there are multiple possible answers, print any of them. The string *z* should be the same length as *x* and *y* and consist only of lowercase English letters.

[ "ab\naa\n", "nzwzl\nniwel\n", "ab\nba\n" ]

[ "ba\n", "xiyez\n", "-1\n" ]

The first case is from the statement. Another solution for the second case is "zizez" There is no solution for the third case. That is, there is no *z* such that *f*("ab", *z*) = "ba".

1,000

[ { "input": "ab\naa", "output": "ba" }, { "input": "nzwzl\nniwel", "output": "xiyez" }, { "input": "ab\nba", "output": "-1" }, { "input": "r\nl", "output": "l" }, { "input": "d\ny", "output": "-1" }, { "input": "yvowz\ncajav", "output": "cajav" }, { "input": "lwzjp\ninjit", "output": "-1" }, { "input": "epqnlxmiicdidyscjaxqznwur\neodnlemiicdedmkcgavqbnqmm", "output": "eodnlemiicdedmkcgavqbnqmm" }, { "input": "qqdabbsxiibnnjgsgxllfvdqj\nuxmypqtwfdezewdxfgplannrs", "output": "-1" }, { "input": "aanerbaqslfmqmuciqbxyznkevukvznpkmxlcorpmrenwxhzfgbmlfpxtkqpxdrmcqcmbf\naanebbaqkgfiimcciqbaoznkeqqkrgapdillccrfeienwbcvfgbmlfbimkqchcrmclcmbf", "output": "aanebbaqkgfiimcciqbaoznkeqqkrgapdillccrfeienwbcvfgbmlfbimkqchcrmclcmbf" }, { "input": "mbyrkhjctrcrayisflptgfudwgrtegidhqicsjqafvdloritbjhciyxuwavxknezwwudnk\nvvixsutlbdewqoabqhpuerfkzrddcqptfwmxdlxwbvsaqfjoxztlddvwgflcteqbwaiaen", "output": "-1" }, { "input": "eufycwztywhbjrpqobvknwfqmnboqcfdiahkagykeibbsqpljcghhmsgfmswwsanzyiwtvuirwmppfivtekaywkzskyydfvkjgxb\necfwavookadbcilfobojnweqinbcpcfdiahkabwkeibbacpljcghhksgfajgmianfnivmhfifogpffiheegayfkxkkcmdfvihgdb", "output": "ecfwavookadbcilfobojnweqinbcpcfdiahkabwkeibbacpljcghhksgfajgmianfnivmhfifogpffiheegayfkxkkcmdfvihgdb" }, { "input": "qvpltcffyeghtbdhjyhfteojezyzziardduzrbwuxmzzkkoehfnxecafizxglboauhynfbawlfxenmykquyhrxswhjuovvogntok\nchvkcvzxptbcepdjfezcpuvtehewbnvqeoezlcnzhpfwujbmhafoeqmjhtwisnobauinkzyigrvahpuetkgpdjfgbzficsmuqnym", "output": "-1" }, { "input": "nmuwjdihouqrnsuahimssnrbxdpwvxiyqtenahtrlshjkmnfuttnpqhgcagoptinnaptxaccptparldzrhpgbyrzedghudtsswxi\nnilhbdghosqnbebafimconrbvdodjsipqmekahhrllhjkemeketapfhgcagopfidnahtlaccpfpafedqicpcbvfgedghudhddwib", "output": "nilhbdghosqnbebafimconrbvdodjsipqmekahhrllhjkemeketapfhgcagopfidnahtlaccpfpafedqicpcbvfgedghudhddwib" }, { "input": "dyxgwupoauwqtcfoyfjdotzirwztdfrueqiypxoqvkmhiehdppwtdoxrbfvtairdbuvlqohjflznggjpifhwjrshcrfbjtklpykx\ngzqlnoizhxolnditjdhlhptjsbczehicudoybzilwnshmywozwnwuipcgirgzldtvtowdsokfeafggwserzdazkxyddjttiopeew", "output": "-1" }, { "input": "hbgwuqzougqzlxemvyjpeizjfwhgugrfnhbrlxkmkdalikfyunppwgdzmalbwewybnjzqsohwhjkdcyhhzmysflambvhpsjilsyv\nfbdjdqjojdafarakvcjpeipjfehgfgrfehbolxkmkdagikflunnpvadocalbkedibhbflmohnhjkdcthhaigsfjaibqhbcjelirv", "output": "fbdjdqjojdafarakvcjpeipjfehgfgrfehbolxkmkdagikflunnpvadocalbkedibhbflmohnhjkdcthhaigsfjaibqhbcjelirv" }, { "input": "xnjjhjfuhgyxqhpzmvgbaohqarugdoaczcfecofltwemieyxolswkcwhlfagfrgmoiqrgftokbqwtxgxzweozzlikrvafiabivlk\npjfosalbsitcnqiazhmepfifjxvmazvdgffcnozmnqubhonwjldmpdsjagmamniylzjdbklcyrzivjyzgnogahobpkwpwpvraqns", "output": "-1" }, { "input": "zrvzedssbsrfldqvjpgmsefrmsatspzoitwvymahiptphiystjlsauzquzqqbmljobdhijcpdvatorwmyojqgnezvzlgjibxepcf\npesoedmqbmffldqsjggmhefkadaesijointrkmahapaahiysfjdiaupqujngbjhjobdhiecadeatgjvelojjgnepvajgeibfepaf", "output": "pesoedmqbmffldqsjggmhefkadaesijointrkmahapaahiysfjdiaupqujngbjhjobdhiecadeatgjvelojjgnepvajgeibfepaf" }, { "input": "pdvkuwyzntzfqpblzmbynknyhlnqbxijuqaincviugxohcsrofozrrsategwkbwxcvkyzxhurokefpbdnmcfogfhsojayysqbrow\nbvxruombdrywlcjkrltyayaazwpauuhbtgwfzdrmfwwucgffucwelzvpsdgtapogchblzahsrfymjlaghkbmbssghrpxalkslcvp", "output": "-1" }, { "input": "tgharsjyihroiiahwgbjezlxvlterxivdhtzjcqegzmtigqmrehvhiyjeywegxaseoyoacouijudbiruoghgxvxadwzgdxtnxlds\ntghaksjsdhkoiiahegbjexlfrctercipdhmvjbgegxdtggqdpbhvhiseehhegnaseoooacnsijubbirjnghgsvpadhaadrtimfdp", "output": "tghaksjsdhkoiiahegbjexlfrctercipdhmvjbgegxdtggqdpbhvhiseehhegnaseoooacnsijubbirjnghgsvpadhaadrtimfdp" }, { "input": "jsinejpfwhzloulxndzvzftgogfdagrsscxmatldssqsgaknnbkcvhptebjjpkjhrjegrotzwcdosezkedzxeoyibmyzunkguoqj\nkfmvybobocdpipiripysioruqvloopvbggpjksgmwzyqwyxnesmvhsawnbbmntulspvsysfkjqwpvoelliopbaukyagedextzoej", "output": "-1" }, { "input": "nttdcfceptruiomtmwzestrfchnqpgqeztpcvthzelfyggjgqadylzubpvbrlgndrcsursczpxlnoyoadxezncqalupfzmjeqihe\nkttdcfceohrjiaahmoldanpfchnfpgheqpdahqhxecfpbgigqadrkjubjfbrlgndbcgcgmcjpeleinaadretncqaiqpfkmjeqihe", "output": "kttdcfceohrjiaahmoldanpfchnfpgheqpdahqhxecfpbgigqadrkjubjfbrlgndbcgcgmcjpeleinaadretncqaiqpfkmjeqihe" }, { "input": "diuopwglduasnaxgduwslbzoyayoypzznqspljcyqehweydhlwifcvnjmaowuvyqfwynjghecqvxdvuquuwpvwrjljozocaxnktv\ntrdydprdzmjhgbhzytelrfjpgsebijicsigmwhynmcyjtqrvojcndodchzxfcvyqjxqzwibccdvsjqhsnectdjyrrhzkeamukang", "output": "-1" }, { "input": "ftfr\nftfr", "output": "ftfr" }, { "input": "ftr\nftr", "output": "ftr" }, { "input": "shftr\nshftr", "output": "shftr" }, { "input": "vkvkkv\nvkvkkv", "output": "vkvkkv" }, { "input": "ftrd\nftrd", "output": "ftrd" }, { "input": "fztr\nfztr", "output": "fztr" }, { "input": "frtr\nfrtr", "output": "frtr" }, { "input": "shdftr\nshdftr", "output": "shdftr" }, { "input": "zzz\nzzz", "output": "zzz" }, { "input": "shtr\nshtr", "output": "shtr" }, { "input": "aaaaa\nzzzzz", "output": "-1" }, { "input": "efr\nefr", "output": "efr" } ]

1,492,357,488

588

Python 3

OK

TESTS

35

61

5,529,600

x=str(input()) y=str(input()) ans='' b=0 for i in range(len(x)): if y[i]>x[i]: b=1 break elif y[i]==x[i]: ans+=x[i] else: ans+=y[i] if b==0: print(ans) else: print(-1)

Title: Valued Keys Time Limit: None seconds Memory Limit: None megabytes Problem Description: You found a mysterious function *f*. The function takes two strings *s*1 and *s*2. These strings must consist only of lowercase English letters, and must be the same length. The output of the function *f* is another string of the same length. The *i*-th character of the output is equal to the minimum of the *i*-th character of *s*1 and the *i*-th character of *s*2. For example, *f*("ab", "ba") = "aa", and *f*("nzwzl", "zizez") = "niwel". You found two strings *x* and *y* of the same length and consisting of only lowercase English letters. Find any string *z* such that *f*(*x*,<=*z*)<==<=*y*, or print -1 if no such string *z* exists. Input Specification: The first line of input contains the string *x*. The second line of input contains the string *y*. Both *x* and *y* consist only of lowercase English letters, *x* and *y* have same length and this length is between 1 and 100. Output Specification: If there is no string *z* such that *f*(*x*,<=*z*)<==<=*y*, print -1. Otherwise, print a string *z* such that *f*(*x*,<=*z*)<==<=*y*. If there are multiple possible answers, print any of them. The string *z* should be the same length as *x* and *y* and consist only of lowercase English letters. Demo Input: ['ab\naa\n', 'nzwzl\nniwel\n', 'ab\nba\n'] Demo Output: ['ba\n', 'xiyez\n', '-1\n'] Note: The first case is from the statement. Another solution for the second case is "zizez" There is no solution for the third case. That is, there is no *z* such that *f*("ab", *z*) = "ba".

```python x=str(input()) y=str(input()) ans='' b=0 for i in range(len(x)): if y[i]>x[i]: b=1 break elif y[i]==x[i]: ans+=x[i] else: ans+=y[i] if b==0: print(ans) else: print(-1) ```

3

152

C

Pocket Book

PROGRAMMING

1,400

[ "combinatorics" ]

null

One day little Vasya found mom's pocket book. The book had *n* names of her friends and unusually enough, each name was exactly *m* letters long. Let's number the names from 1 to *n* in the order in which they are written. As mom wasn't home, Vasya decided to play with names: he chose three integers *i*, *j*, *k* (1<=≤<=*i*<=<<=*j*<=≤<=*n*, 1<=≤<=*k*<=≤<=*m*), then he took names number *i* and *j* and swapped their prefixes of length *k*. For example, if we take names "CBDAD" and "AABRD" and swap their prefixes with the length of 3, the result will be names "AABAD" and "CBDRD". You wonder how many different names Vasya can write instead of name number 1, if Vasya is allowed to perform any number of the described actions. As Vasya performs each action, he chooses numbers *i*, *j*, *k* independently from the previous moves and his choice is based entirely on his will. The sought number can be very large, so you should only find it modulo 1000000007 (109<=+<=7).

The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of names and the length of each name, correspondingly. Then *n* lines contain names, each name consists of exactly *m* uppercase Latin letters.

Print the single number — the number of different names that could end up in position number 1 in the pocket book after the applying the procedures described above. Print the number modulo 1000000007 (109<=+<=7).

[ "2 3\nAAB\nBAA\n", "4 5\nABABA\nBCGDG\nAAAAA\nYABSA\n" ]

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

In the first sample Vasya can get the following names in the position number 1: "AAB", "AAA", "BAA" and "BAB".

1,500

[ { "input": "2 3\nAAB\nBAA", "output": "4" }, { "input": "4 5\nABABA\nBCGDG\nAAAAA\nYABSA", "output": "216" }, { "input": "1 1\nE", "output": "1" }, { "input": "2 2\nNS\nPD", "output": "4" }, { "input": "3 4\nPJKD\nNFJX\nFGFK", "output": "81" }, { "input": "4 5\nSXFMY\nATHLM\nKDDQW\nZWGDS", "output": "1024" }, { "input": "20 14\nJNFKBBBJYZHWQE\nLBOKZCPFNKDBJY\nXKNWGHQHIOXUPF\nDDNRUKVUGHWMXW\nMTIZFNAAFEAPHX\nIXBQOOHEULZYHU\nMRCSREUEOOMUUN\nHJTSQWKUFYZDQU\nGMCMUZCOPRVEIQ\nXBKKGGJECOBLTH\nXXHTLXCNJZJUAF\nVLJRKXXXWMTPKZ\nPTYMNPTBBCWKAD\nQYJGOBUBHMEDYE\nGTKUUVVNKAHTUI\nZNKXYZPCYLBZFP\nQCBLJTRMBDWNNE\nTDOKJOBKEOVNLZ\nFKZUITYAFJOQIM\nUWQNSGLXEEIRWF", "output": "515139391" }, { "input": "5 14\nAQRXUQQNSKZPGC\nDTTKSPFGGVCLPT\nVLZQWWESCHDTAZ\nCOKOWDWDRUOMHP\nXDTRBIZTTCIDGS", "output": "124999979" }, { "input": "9 23\nOILBYKHRGMPENVFNHLSIUOW\nLPJFHTUQUINAALRDGLSQUXR\nLYYJJEBNZATAFQWTDZSPUNZ\nHSJPIQKKWWERJZIEMLCZUKI\nOJYIEYDGPFWRHCMISJCCUEM\nLMGKZVFYIVDRTIHBWPCNUTG\nUBGGNCITVHAIPKXCLTSAULQ\nOWSAWUOXQDBSXXBHTLSXUVD\nUGQTIZQPBGMASRQPVPSFUWK", "output": "454717784" }, { "input": "25 4\nLVKG\nMICU\nZHKW\nLFGG\nOWQO\nLCQG\nLVXU\nOUKB\nLNQX\nZJTO\nOOQX\nLVQP\nMFQB\nMRQV\nOIQH\nOPXX\nXFKU\nFCQB\nZPKH\nLVCH\nNFCU\nOVQW\nOZKU\nLFHX\nLPXO", "output": "5733" }, { "input": "30 10\nUTNTGOKZYJ\nQHOUHNYZVW\nLTVGHJRZVW\nMZHYHOLZYJ\nERYEUEPZYE\nUZDBFTURYJ\nRVSMQTIZGW\nWDJQHMIRYY\nKCORHQPZYE\nRRPLFOZZVY\nJTXMFNNNYJ\nMVTGGOZZVV\nEHAFFNUZVF\nLBRNWJZNYE\nJVMOHTPZYJ\nWTARFJLZVV\nLVJCWOURVW\nLCLQFJYRVV\nQVBVGNJRYF\nNTZGHOLRYE\nMGQKHOUPYJ\nRRSSBXPZYJ\nRYCRGTLZYJ\nJRDEGNKRVW\nRZKFGHYRVG\nMDJBFNIZYG\nMPLWHXIZYE\nSRZMHMURVE\nMTEBBMRZYJ\nJPJIFOLZYM", "output": "919913906" }, { "input": "40 7\nPNTVVER\nPAHTQDR\nRXMJVAS\nVIQNLYC\nILPUSVX\nYJOXQDJ\nSEFODTO\nOTJMREL\nLIQRZGD\nLBJJPOR\nRUTYHQO\nRIWEPBD\nKQUMFIB\nISTRRYH\nXBTOTGK\nRFQODEY\nHDSTZTP\nYCXFAGL\nAREGRFU\nLELZUYU\nGVABDKH\nFJAMMME\nACVULXE\nJHVPJAS\nAAQNMBX\nJJGUCXG\nOQATILQ\nNEOSHJM\nHFLWOFM\nICYEQHY\nFACGLYP\nPLLXJEQ\nDCHXYPB\nAGDDZJJ\nLSQRXTN\nHDQZXIY\nNAHDDWW\nQCMXRQN\nFDUDSZO\nHKBEVTW", "output": "206575993" }, { "input": "2 2\nAA\nBB", "output": "4" }, { "input": "1 10\nAAAAAAAAAA", "output": "1" }, { "input": "2 8\nAAAAAAAA\nBBBBBBBB", "output": "256" }, { "input": "10 10\nAAAAAAAAAA\nBBBBBBBBBB\nCCCCCCCCCC\nDDDDDDDDDD\nAAAAAAAAAA\nBBBBBBBBBB\nCCCCCCCCCC\nDDDDDDDDDD\nAAAAAAAAAA\nBBBBBBBBBB", "output": "1048576" }, { "input": "1 20\nAAAAAAAAAAAAAAAAAAAA", "output": "1" }, { "input": "20 1\nA\nB\nC\nD\nE\nF\nG\nA\nB\nC\nD\nE\nF\nG\nA\nB\nC\nD\nE\nF", "output": "7" }, { "input": "5 60\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\nBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\nCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\nDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD\nEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE", "output": "449874206" }, { "input": "50 4\nAAAA\nBBBB\nCCCC\nDDDD\nEEEE\nFFFF\nGGGG\nHHHH\nIIII\nJJJJ\nAAAA\nBBBB\nCCCC\nDDDD\nEEEE\nFFFF\nGGGG\nHHHH\nIIII\nJJJJ\nAAAA\nBBBB\nCCCC\nDDDD\nEEEE\nFFFF\nGGGG\nHHHH\nIIII\nJJJJ\nAAAA\nBBBB\nCCCC\nDDDD\nEEEE\nFFFF\nGGGG\nHHHH\nIIII\nJJJJ\nAAAA\nBBBB\nCCCC\nDDDD\nEEEE\nFFFF\nGGGG\nHHHH\nIIII\nJJJJ", "output": "10000" }, { "input": "1 100\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "output": "1" }, { "input": "100 1\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", "output": "1" }, { "input": "100 1\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB\nA\nB", "output": "2" }, { "input": "100 1\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nA\nB", "output": "14" }, { "input": "100 1\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\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\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\nA\nB\nC\nD\nE\nF\nG\nH\nI\nJ\nK\nL\nM\nN\nO\nP\nQ\nR\nS\nT\nU\nV", "output": "26" } ]

1,598,430,046

2,147,483,647

PyPy 3

OK

TESTS

60

310

1,433,600

n,m = [int(x) for x in input().split()] arr = [] for i in range(n): arr.append(str(input())) ans = 1 for i in range(m): hm = [] now = 0 for j in range(n): if not arr[j][i] in hm: hm.append(arr[j][i]) now+=1 ans = (ans*now)%1000000007 print(ans)

Title: Pocket Book Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day little Vasya found mom's pocket book. The book had *n* names of her friends and unusually enough, each name was exactly *m* letters long. Let's number the names from 1 to *n* in the order in which they are written. As mom wasn't home, Vasya decided to play with names: he chose three integers *i*, *j*, *k* (1<=≤<=*i*<=<<=*j*<=≤<=*n*, 1<=≤<=*k*<=≤<=*m*), then he took names number *i* and *j* and swapped their prefixes of length *k*. For example, if we take names "CBDAD" and "AABRD" and swap their prefixes with the length of 3, the result will be names "AABAD" and "CBDRD". You wonder how many different names Vasya can write instead of name number 1, if Vasya is allowed to perform any number of the described actions. As Vasya performs each action, he chooses numbers *i*, *j*, *k* independently from the previous moves and his choice is based entirely on his will. The sought number can be very large, so you should only find it modulo 1000000007 (109<=+<=7). Input Specification: The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of names and the length of each name, correspondingly. Then *n* lines contain names, each name consists of exactly *m* uppercase Latin letters. Output Specification: Print the single number — the number of different names that could end up in position number 1 in the pocket book after the applying the procedures described above. Print the number modulo 1000000007 (109<=+<=7). Demo Input: ['2 3\nAAB\nBAA\n', '4 5\nABABA\nBCGDG\nAAAAA\nYABSA\n'] Demo Output: ['4\n', '216\n'] Note: In the first sample Vasya can get the following names in the position number 1: "AAB", "AAA", "BAA" and "BAB".

```python n,m = [int(x) for x in input().split()] arr = [] for i in range(n): arr.append(str(input())) ans = 1 for i in range(m): hm = [] now = 0 for j in range(n): if not arr[j][i] in hm: hm.append(arr[j][i]) now+=1 ans = (ans*now)%1000000007 print(ans) ```

3

84

A

Toy Army

PROGRAMMING

900

[ "math", "number theory" ]

A. Toy Army

2

256

The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows. There are two armies on the playing field each of which consists of *n* men (*n* is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore. The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends. You are asked to calculate the maximum total number of soldiers that may be killed during the game.

The input data consist of a single integer *n* (2<=≤<=*n*<=≤<=108, *n* is even). Please note that before the game starts there are 2*n* soldiers on the fields.

Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns.

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

[ "3\n", "6\n" ]

The first sample test: 1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1. 2) Arcady's soldier 2 shoots at Valera's soldier 1. 3) Valera's soldier 1 shoots at Arcady's soldier 2. There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2.

500

[ { "input": "2", "output": "3" }, { "input": "4", "output": "6" }, { "input": "6", "output": "9" }, { "input": "8", "output": "12" }, { "input": "10", "output": "15" }, { "input": "140", "output": "210" }, { "input": "500", "output": "750" }, { "input": "1000", "output": "1500" }, { "input": "2000", "output": "3000" }, { "input": "50000", "output": "75000" }, { "input": "10000", "output": "15000" }, { "input": "25460", "output": "38190" }, { "input": "54646", "output": "81969" }, { "input": "59790", "output": "89685" }, { "input": "578456", "output": "867684" }, { "input": "56798056", "output": "85197084" }, { "input": "8457980", "output": "12686970" }, { "input": "5687986", "output": "8531979" }, { "input": "10984932", "output": "16477398" }, { "input": "99999994", "output": "149999991" }, { "input": "99999996", "output": "149999994" }, { "input": "99999998", "output": "149999997" }, { "input": "100000000", "output": "150000000" } ]

1,622,294,212

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

2

184

0

def main_function(): n = int(input()) if 2 * n > 6: return 6 else: return 2 * n - 1 print(main_function())

Title: Toy Army Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows. There are two armies on the playing field each of which consists of *n* men (*n* is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore. The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends. You are asked to calculate the maximum total number of soldiers that may be killed during the game. Input Specification: The input data consist of a single integer *n* (2<=≤<=*n*<=≤<=108, *n* is even). Please note that before the game starts there are 2*n* soldiers on the fields. Output Specification: Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns. Demo Input: ['2\n', '4\n'] Demo Output: ['3\n', '6\n'] Note: The first sample test: 1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1. 2) Arcady's soldier 2 shoots at Valera's soldier 1. 3) Valera's soldier 1 shoots at Arcady's soldier 2. There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2.

```python def main_function(): n = int(input()) if 2 * n > 6: return 6 else: return 2 * n - 1 print(main_function()) ```

0

840

A

Leha and Function

PROGRAMMING

1,300

[ "combinatorics", "greedy", "math", "number theory", "sortings" ]

null

Leha like all kinds of strange things. Recently he liked the function *F*(*n*,<=*k*). Consider all possible *k*-element subsets of the set [1,<=2,<=...,<=*n*]. For subset find minimal element in it. *F*(*n*,<=*k*) — mathematical expectation of the minimal element among all *k*-element subsets. But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays *A* and *B*, each consists of *m* integers. For all *i*,<=*j* such that 1<=≤<=*i*,<=*j*<=≤<=*m* the condition *A**i*<=≥<=*B**j* holds. Help Leha rearrange the numbers in the array *A* so that the sum is maximally possible, where *A*' is already rearranged array.

First line of input data contains single integer *m* (1<=≤<=*m*<=≤<=2·105) — length of arrays *A* and *B*. Next line contains *m* integers *a*1,<=*a*2,<=...,<=*a**m* (1<=≤<=*a**i*<=≤<=109) — array *A*. Next line contains *m* integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=109) — array *B*.

Output *m* integers *a*'1,<=*a*'2,<=...,<=*a*'*m* — array *A*' which is permutation of the array *A*.

[ "5\n7 3 5 3 4\n2 1 3 2 3\n", "7\n4 6 5 8 8 2 6\n2 1 2 2 1 1 2\n" ]

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

none

500

[ { "input": "5\n7 3 5 3 4\n2 1 3 2 3", "output": "4 7 3 5 3" }, { "input": "7\n4 6 5 8 8 2 6\n2 1 2 2 1 1 2", "output": "2 6 4 5 8 8 6" } ]

1,576,693,812

2,147,483,647

PyPy 3

OK

TESTS

48

1,372

29,593,600

n = int(input()) a = list(map(int, input().split())) b = list(map(int, input().split())) a.sort() t1= [] for i in range(n): t1.append([b[i], i]) t1.sort(reverse = True) ind = [] for i in t1: ind.append(i[1]) ans = [0] * n for i in range(n): ans[ind[i]] = a[i] print(*ans)

Title: Leha and Function Time Limit: None seconds Memory Limit: None megabytes Problem Description: Leha like all kinds of strange things. Recently he liked the function *F*(*n*,<=*k*). Consider all possible *k*-element subsets of the set [1,<=2,<=...,<=*n*]. For subset find minimal element in it. *F*(*n*,<=*k*) — mathematical expectation of the minimal element among all *k*-element subsets. But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays *A* and *B*, each consists of *m* integers. For all *i*,<=*j* such that 1<=≤<=*i*,<=*j*<=≤<=*m* the condition *A**i*<=≥<=*B**j* holds. Help Leha rearrange the numbers in the array *A* so that the sum is maximally possible, where *A*' is already rearranged array. Input Specification: First line of input data contains single integer *m* (1<=≤<=*m*<=≤<=2·105) — length of arrays *A* and *B*. Next line contains *m* integers *a*1,<=*a*2,<=...,<=*a**m* (1<=≤<=*a**i*<=≤<=109) — array *A*. Next line contains *m* integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**i*<=≤<=109) — array *B*. Output Specification: Output *m* integers *a*'1,<=*a*'2,<=...,<=*a*'*m* — array *A*' which is permutation of the array *A*. Demo Input: ['5\n7 3 5 3 4\n2 1 3 2 3\n', '7\n4 6 5 8 8 2 6\n2 1 2 2 1 1 2\n'] Demo Output: ['4 7 3 5 3\n', '2 6 4 5 8 8 6\n'] Note: none

```python n = int(input()) a = list(map(int, input().split())) b = list(map(int, input().split())) a.sort() t1= [] for i in range(n): t1.append([b[i], i]) t1.sort(reverse = True) ind = [] for i in t1: ind.append(i[1]) ans = [0] * n for i in range(n): ans[ind[i]] = a[i] print(*ans) ```

3

168

A

Wizards and Demonstration

PROGRAMMING

900

[ "implementation", "math" ]

null

Some country is populated by wizards. They want to organize a demonstration. There are *n* people living in the city, *x* of them are the wizards who will surely go to the demonstration. Other city people (*n*<=-<=*x* people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least *y* percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration. So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only *n* people and not containing any clone puppets. Help the wizards and find the minimum number of clones to create to that the demonstration had no less than *y* percent of the city people.

The first line contains three space-separated integers, *n*, *x*, *y* (1<=≤<=*n*,<=*x*,<=*y*<=≤<=104,<=*x*<=≤<=*n*) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly. Please note that *y* can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city (<=><=*n*).

Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than *y* percent of *n* (the real total city population).

[ "10 1 14\n", "20 10 50\n", "1000 352 146\n" ]

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

In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone. In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.

500

[ { "input": "10 1 14", "output": "1" }, { "input": "20 10 50", "output": "0" }, { "input": "1000 352 146", "output": "1108" }, { "input": "68 65 20", "output": "0" }, { "input": "78 28 27", "output": "0" }, { "input": "78 73 58", "output": "0" }, { "input": "70 38 66", "output": "9" }, { "input": "54 4 38", "output": "17" }, { "input": "3 1 69", "output": "2" }, { "input": "11 9 60", "output": "0" }, { "input": "71 49 65", "output": "0" }, { "input": "78 55 96", "output": "20" }, { "input": "2765 768 9020", "output": "248635" }, { "input": "3478 1728 9727", "output": "336578" }, { "input": "9678 6173 5658", "output": "541409" }, { "input": "1138 570 6666", "output": "75290" }, { "input": "7754 204 9038", "output": "700603" }, { "input": "8403 7401 4769", "output": "393339" }, { "input": "4909 2111 8860", "output": "432827" }, { "input": "6571 6449 8965", "output": "582642" }, { "input": "9178 2255 7996", "output": "731618" }, { "input": "6151 6148 3746", "output": "224269" }, { "input": "8890 5449 8734", "output": "771004" }, { "input": "7879 2590 2818", "output": "219441" }, { "input": "8484 6400 547", "output": "40008" }, { "input": "7835 6710 1639", "output": "121706" }, { "input": "2379 1436 9663", "output": "228447" }, { "input": "6487 5670 8", "output": "0" }, { "input": "4470 2543 6", "output": "0" }, { "input": "7261 5328 10", "output": "0" }, { "input": "3871 3795 7", "output": "0" }, { "input": "9620 6557 6", "output": "0" }, { "input": "4890 1112 5", "output": "0" }, { "input": "1 1 1", "output": "0" }, { "input": "1 1 10000", "output": "99" }, { "input": "10000 1 1", "output": "99" }, { "input": "10000 1 10000", "output": "999999" }, { "input": "10000 10000 1", "output": "0" }, { "input": "10000 10000 10000", "output": "990000" }, { "input": "67 1 3", "output": "2" }, { "input": "7878 4534 9159", "output": "717013" }, { "input": "1 1 1", "output": "0" }, { "input": "3271 5 50", "output": "1631" } ]

1,625,586,843

2,147,483,647

Python 3

OK

TESTS

43

124

0

import math n,x,y = map(int,input().split()) if (math.ceil((n*y)/100)-x) > 0: print(math.ceil((n*y)/100)-x) else: print(0)

Title: Wizards and Demonstration Time Limit: None seconds Memory Limit: None megabytes Problem Description: Some country is populated by wizards. They want to organize a demonstration. There are *n* people living in the city, *x* of them are the wizards who will surely go to the demonstration. Other city people (*n*<=-<=*x* people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least *y* percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration. So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only *n* people and not containing any clone puppets. Help the wizards and find the minimum number of clones to create to that the demonstration had no less than *y* percent of the city people. Input Specification: The first line contains three space-separated integers, *n*, *x*, *y* (1<=≤<=*n*,<=*x*,<=*y*<=≤<=104,<=*x*<=≤<=*n*) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly. Please note that *y* can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city (<=><=*n*). Output Specification: Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than *y* percent of *n* (the real total city population). Demo Input: ['10 1 14\n', '20 10 50\n', '1000 352 146\n'] Demo Output: ['1\n', '0\n', '1108\n'] Note: In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone. In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.

```python import math n,x,y = map(int,input().split()) if (math.ceil((n*y)/100)-x) > 0: print(math.ceil((n*y)/100)-x) else: print(0) ```

3

965

D

Single-use Stones

PROGRAMMING

1,900

[ "binary search", "flows", "greedy", "two pointers" ]

null

A lot of frogs want to cross a river. A river is $w$ units width, but frogs can only jump $l$ units long, where $l < w$. Frogs can also jump on lengths shorter than $l$. but can't jump longer. Hopefully, there are some stones in the river to help them. The stones are located at integer distances from the banks. There are $a_i$ stones at the distance of $i$ units from the bank the frogs are currently at. Each stone can only be used once by one frog, after that it drowns in the water. What is the maximum number of frogs that can cross the river, given that then can only jump on the stones?

The first line contains two integers $w$ and $l$ ($1 \le l < w \le 10^5$) — the width of the river and the maximum length of a frog's jump. The second line contains $w - 1$ integers $a_1, a_2, \ldots, a_{w-1}$ ($0 \le a_i \le 10^4$), where $a_i$ is the number of stones at the distance $i$ from the bank the frogs are currently at.

Print a single integer — the maximum number of frogs that can cross the river.

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

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

In the first sample two frogs can use the different stones at the distance $5$, and one frog can use the stones at the distances $3$ and then $8$. In the second sample although there are two stones at the distance $5$, that does not help. The three paths are: $0 \to 3 \to 6 \to 9 \to 10$, $0 \to 2 \to 5 \to 8 \to 10$, $0 \to 1 \to 4 \to 7 \to 10$.

2,000

[ { "input": "10 5\n0 0 1 0 2 0 0 1 0", "output": "3" }, { "input": "10 3\n1 1 1 1 2 1 1 1 1", "output": "3" }, { "input": "2 1\n0", "output": "0" }, { "input": "2 1\n5", "output": "5" }, { "input": "10 4\n0 0 6 2 7 1 6 4 0", "output": "8" }, { "input": "100 15\n0 0 1 1 1 0 1 1 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 0 0 1 1 0 0 1 0 0 1 0 0 1 0 1 0 1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 1 1 1 1 0 1 0 1 0 1 0 0 0 0 1 1 0 1 1 0 0 1 0 1 0 1 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 1 0", "output": "5" }, { "input": "10 4\n10 10 10 10 10 10 10 10 10", "output": "40" }, { "input": "100 34\n16 0 10 11 12 13 0 5 4 14 6 15 4 9 1 20 19 14 1 7 14 11 10 20 6 9 12 8 3 19 20 4 17 17 8 11 14 18 5 20 17 0 3 18 14 12 11 12 5 5 11 7 9 17 4 8 4 10 0 0 12 9 15 3 15 14 19 12 6 8 17 19 4 18 19 3 8 3 9 1 6 15 4 16 1 18 13 16 3 5 20 11 10 9 9 17 20 15 12", "output": "312" } ]

1,524,899,861

2,147,483,647

Python 3

OK

TESTS

16

171

14,336,000

w, l = [int(x) for x in input().split()] a = [int(x) for x in input().split()] s = res = sum(a[:l]) for i in range(l, w - 1): s += a[i] - a[i - l] res = min(res, s) print(res)

Title: Single-use Stones Time Limit: None seconds Memory Limit: None megabytes Problem Description: A lot of frogs want to cross a river. A river is $w$ units width, but frogs can only jump $l$ units long, where $l < w$. Frogs can also jump on lengths shorter than $l$. but can't jump longer. Hopefully, there are some stones in the river to help them. The stones are located at integer distances from the banks. There are $a_i$ stones at the distance of $i$ units from the bank the frogs are currently at. Each stone can only be used once by one frog, after that it drowns in the water. What is the maximum number of frogs that can cross the river, given that then can only jump on the stones? Input Specification: The first line contains two integers $w$ and $l$ ($1 \le l < w \le 10^5$) — the width of the river and the maximum length of a frog's jump. The second line contains $w - 1$ integers $a_1, a_2, \ldots, a_{w-1}$ ($0 \le a_i \le 10^4$), where $a_i$ is the number of stones at the distance $i$ from the bank the frogs are currently at. Output Specification: Print a single integer — the maximum number of frogs that can cross the river. Demo Input: ['10 5\n0 0 1 0 2 0 0 1 0\n', '10 3\n1 1 1 1 2 1 1 1 1\n'] Demo Output: ['3\n', '3\n'] Note: In the first sample two frogs can use the different stones at the distance $5$, and one frog can use the stones at the distances $3$ and then $8$. In the second sample although there are two stones at the distance $5$, that does not help. The three paths are: $0 \to 3 \to 6 \to 9 \to 10$, $0 \to 2 \to 5 \to 8 \to 10$, $0 \to 1 \to 4 \to 7 \to 10$.

```python w, l = [int(x) for x in input().split()] a = [int(x) for x in input().split()] s = res = sum(a[:l]) for i in range(l, w - 1): s += a[i] - a[i - l] res = min(res, s) print(res) ```

3

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,607,446,862

2,147,483,647

PyPy 3

OK

TESTS

95

1,856

41,164,800

def main(): n = int(input()) friend_dict = {} for i in range(n): friend_dict[input()] = i friend_dict = dict(sorted(friend_dict.items(), key=lambda x: x[1], reverse=True)) for friend in friend_dict.keys(): print(friend) main()

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 def main(): n = int(input()) friend_dict = {} for i in range(n): friend_dict[input()] = i friend_dict = dict(sorted(friend_dict.items(), key=lambda x: x[1], reverse=True)) for friend in friend_dict.keys(): print(friend) main() ```

3

471

A

MUH and Sticks

PROGRAMMING

1,100

[ "implementation" ]

null

Two polar bears Menshykov and Uslada from the St.Petersburg zoo and elephant Horace from the Kiev zoo got six sticks to play with and assess the animals' creativity. Menshykov, Uslada and Horace decided to make either an elephant or a bear from those sticks. They can make an animal from sticks in the following way: - Four sticks represent the animal's legs, these sticks should have the same length. - Two remaining sticks represent the animal's head and body. The bear's head stick must be shorter than the body stick. The elephant, however, has a long trunk, so his head stick must be as long as the body stick. Note that there are no limits on the relations between the leg sticks and the head and body sticks. Your task is to find out which animal can be made from the given stick set. The zoo keeper wants the sticks back after the game, so they must never be broken, even bears understand it.

The single line contains six space-separated integers *l**i* (1<=≤<=*l**i*<=≤<=9) — the lengths of the six sticks. It is guaranteed that the input is such that you cannot make both animals from the sticks.

If you can make a bear from the given set, print string "Bear" (without the quotes). If you can make an elephant, print string "Elephant" (wıthout the quotes). If you can make neither a bear nor an elephant, print string "Alien" (without the quotes).

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

[ "Bear", "Elephant", "Alien" ]

If you're out of creative ideas, see instructions below which show how to make a bear and an elephant in the first two samples. The stick of length 2 is in red, the sticks of length 4 are in green, the sticks of length 5 are in blue.

500

[ { "input": "4 2 5 4 4 4", "output": "Bear" }, { "input": "4 4 5 4 4 5", "output": "Elephant" }, { "input": "1 2 3 4 5 6", "output": "Alien" }, { "input": "5 5 5 5 5 5", "output": "Elephant" }, { "input": "1 1 1 2 3 5", "output": "Alien" }, { "input": "1 1 1 1 1 1", "output": "Elephant" }, { "input": "9 9 9 9 9 9", "output": "Elephant" }, { "input": "1 8 9 1 1 1", "output": "Bear" }, { "input": "9 9 9 1 9 9", "output": "Bear" }, { "input": "1 2 3 8 9 7", "output": "Alien" }, { "input": "5 5 5 6 6 6", "output": "Alien" }, { "input": "1 1 2 2 3 4", "output": "Alien" }, { "input": "4 4 4 4 4 2", "output": "Bear" }, { "input": "2 2 3 3 4 4", "output": "Alien" }, { "input": "4 4 4 4 4 5", "output": "Bear" }, { "input": "1 1 2 2 2 2", "output": "Elephant" }, { "input": "1 2 5 5 5 5", "output": "Bear" }, { "input": "4 4 2 2 2 2", "output": "Elephant" }, { "input": "1 1 1 1 1 2", "output": "Bear" }, { "input": "2 2 4 4 4 4", "output": "Elephant" }, { "input": "4 4 4 4 4 3", "output": "Bear" }, { "input": "4 4 5 6 7 8", "output": "Alien" }, { "input": "4 4 4 4 2 2", "output": "Elephant" }, { "input": "1 1 1 1 2 2", "output": "Elephant" }, { "input": "1 1 3 3 3 5", "output": "Alien" }, { "input": "1 2 2 3 3 3", "output": "Alien" }, { "input": "1 2 2 2 2 2", "output": "Bear" }, { "input": "1 3 3 3 4 5", "output": "Alien" }, { "input": "5 1 1 1 1 1", "output": "Bear" } ]

1,439,644,158

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

15

62

0

from sys import stdin, stdout input = stdin.readline l = list(map(int, input().split())) l.sort() if len(set(l[:4])) == len(set(l[4:])) == 1: stdout.write("Elephant") elif len(set(l[:4])) == 1 or len(set(l[1:5])) == 1 or len(set(l[2:])) == 1: stdout.write("Bear") else: stdout.write("Alien")

Title: MUH and Sticks Time Limit: None seconds Memory Limit: None megabytes Problem Description: Two polar bears Menshykov and Uslada from the St.Petersburg zoo and elephant Horace from the Kiev zoo got six sticks to play with and assess the animals' creativity. Menshykov, Uslada and Horace decided to make either an elephant or a bear from those sticks. They can make an animal from sticks in the following way: - Four sticks represent the animal's legs, these sticks should have the same length. - Two remaining sticks represent the animal's head and body. The bear's head stick must be shorter than the body stick. The elephant, however, has a long trunk, so his head stick must be as long as the body stick. Note that there are no limits on the relations between the leg sticks and the head and body sticks. Your task is to find out which animal can be made from the given stick set. The zoo keeper wants the sticks back after the game, so they must never be broken, even bears understand it. Input Specification: The single line contains six space-separated integers *l**i* (1<=≤<=*l**i*<=≤<=9) — the lengths of the six sticks. It is guaranteed that the input is such that you cannot make both animals from the sticks. Output Specification: If you can make a bear from the given set, print string "Bear" (without the quotes). If you can make an elephant, print string "Elephant" (wıthout the quotes). If you can make neither a bear nor an elephant, print string "Alien" (without the quotes). Demo Input: ['4 2 5 4 4 4\n', '4 4 5 4 4 5\n', '1 2 3 4 5 6\n'] Demo Output: ['Bear', 'Elephant', 'Alien'] Note: If you're out of creative ideas, see instructions below which show how to make a bear and an elephant in the first two samples. The stick of length 2 is in red, the sticks of length 4 are in green, the sticks of length 5 are in blue.

```python from sys import stdin, stdout input = stdin.readline l = list(map(int, input().split())) l.sort() if len(set(l[:4])) == len(set(l[4:])) == 1: stdout.write("Elephant") elif len(set(l[:4])) == 1 or len(set(l[1:5])) == 1 or len(set(l[2:])) == 1: stdout.write("Bear") else: stdout.write("Alien") ```

0

302

A

Eugeny and Array

PROGRAMMING

800

[ "implementation" ]

null

Eugeny has array *a*<==<=*a*1,<=*a*2,<=...,<=*a**n*, consisting of *n* integers. Each integer *a**i* equals to -1, or to 1. Also, he has *m* queries: - Query number *i* is given as a pair of integers *l**i*, *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). - The response to the query will be integer 1, if the elements of array *a* can be rearranged so as the sum *a**l**i*<=+<=*a**l**i*<=+<=1<=+<=...<=+<=*a**r**i*<==<=0, otherwise the response to the query will be integer 0. Help Eugeny, answer all his queries.

The first line contains integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=2·105). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (*a**i*<==<=-1,<=1). Next *m* lines contain Eugene's queries. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*).

Print *m* integers — the responses to Eugene's queries in the order they occur in the input.

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

[ "0\n1\n0\n", "0\n1\n0\n1\n0\n" ]

none

500

[ { "input": "2 3\n1 -1\n1 1\n1 2\n2 2", "output": "0\n1\n0" }, { "input": "5 5\n-1 1 1 1 -1\n1 1\n2 3\n3 5\n2 5\n1 5", "output": "0\n1\n0\n1\n0" }, { "input": "3 3\n1 1 1\n2 2\n1 1\n1 1", "output": "0\n0\n0" }, { "input": "4 4\n-1 -1 -1 -1\n1 3\n1 2\n1 2\n1 1", "output": "0\n0\n0\n0" }, { "input": "5 5\n-1 -1 -1 -1 -1\n1 1\n1 1\n3 4\n1 1\n1 4", "output": "0\n0\n0\n0\n0" }, { "input": "6 6\n-1 -1 1 -1 -1 1\n1 1\n3 4\n1 1\n1 1\n1 3\n1 4", "output": "0\n1\n0\n0\n0\n1" }, { "input": "7 7\n-1 -1 -1 1 -1 -1 -1\n1 1\n2 7\n1 3\n1 5\n4 7\n1 7\n6 7", "output": "0\n0\n0\n0\n0\n0\n1" }, { "input": "8 8\n1 1 1 1 1 1 1 1\n5 8\n2 6\n2 3\n1 7\n7 7\n1 6\n1 8\n1 3", "output": "0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "9 9\n-1 1 1 1 1 1 1 1 1\n1 7\n5 6\n1 4\n1 1\n1 1\n6 8\n1 1\n6 7\n3 5", "output": "0\n1\n0\n0\n0\n0\n0\n1\n0" }, { "input": "10 10\n-1 1 -1 1 -1 -1 -1 -1 -1 -1\n6 7\n2 5\n3 6\n1 3\n3 5\n4 5\n3 4\n1 6\n1 1\n1 1", "output": "1\n1\n1\n0\n0\n1\n1\n0\n0\n0" }, { "input": "1 1\n-1\n1 1", "output": "0" }, { "input": "1 1\n1\n1 1", "output": "0" } ]

1,540,996,878

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

2

124

102,400

from collections import Counter n,m = map(int,input().split()) k1 = list(map(int,input().split())) a = dict(Counter(k1)) count1 = a[1] count2 = a[-1] for i in range(m): a,b = map(int,input().split()) if (b-a+1)%2 == 0: c = (b-a+1)//2 if c<=count1 and c<=count2: print(1) else: print(0) else: print(0)

Title: Eugeny and Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Eugeny has array *a*<==<=*a*1,<=*a*2,<=...,<=*a**n*, consisting of *n* integers. Each integer *a**i* equals to -1, or to 1. Also, he has *m* queries: - Query number *i* is given as a pair of integers *l**i*, *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). - The response to the query will be integer 1, if the elements of array *a* can be rearranged so as the sum *a**l**i*<=+<=*a**l**i*<=+<=1<=+<=...<=+<=*a**r**i*<==<=0, otherwise the response to the query will be integer 0. Help Eugeny, answer all his queries. Input Specification: The first line contains integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=2·105). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (*a**i*<==<=-1,<=1). Next *m* lines contain Eugene's queries. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=*n*). Output Specification: Print *m* integers — the responses to Eugene's queries in the order they occur in the input. Demo Input: ['2 3\n1 -1\n1 1\n1 2\n2 2\n', '5 5\n-1 1 1 1 -1\n1 1\n2 3\n3 5\n2 5\n1 5\n'] Demo Output: ['0\n1\n0\n', '0\n1\n0\n1\n0\n'] Note: none

```python from collections import Counter n,m = map(int,input().split()) k1 = list(map(int,input().split())) a = dict(Counter(k1)) count1 = a[1] count2 = a[-1] for i in range(m): a,b = map(int,input().split()) if (b-a+1)%2 == 0: c = (b-a+1)//2 if c<=count1 and c<=count2: print(1) else: print(0) else: print(0) ```

-1

960

A

Check the string

PROGRAMMING

1,200

[ "implementation" ]

null

A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string. B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time. You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes).

The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'.

Print "YES" or "NO", according to the condition.

[ "aaabccc\n", "bbacc\n", "aabc\n" ]

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

Consider first example: the number of 'c' is equal to the number of 'a'. Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct. Consider third example: the number of 'c' is equal to the number of 'b'.

500

[ { "input": "aaabccc", "output": "YES" }, { "input": "bbacc", "output": "NO" }, { "input": "aabc", "output": "YES" }, { "input": "aabbcc", "output": "YES" }, { "input": "aaacccbb", "output": "NO" }, { "input": "abc", "output": "YES" }, { "input": "acba", "output": "NO" }, { "input": "bbabbc", "output": "NO" }, { "input": "bbbabacca", "output": "NO" }, { "input": "aabcbcaca", "output": "NO" }, { "input": "aaaaabbbbbb", "output": "NO" }, { "input": "c", "output": "NO" }, { "input": "cc", "output": "NO" }, { "input": "bbb", "output": "NO" }, { "input": "bc", "output": "NO" }, { "input": "ccbcc", "output": "NO" }, { "input": "aaa", "output": "NO" }, { "input": "aaccaa", "output": "NO" }, { "input": "a", "output": "NO" }, { "input": "b", "output": "NO" }, { "input": "abca", "output": "NO" }, { "input": "aabbcccc", "output": "NO" }, { "input": "abac", "output": "NO" }, { "input": "abcc", "output": "NO" }, { "input": "abcb", "output": "NO" }, { "input": "aacc", "output": "NO" }, { "input": "aabbaacccc", "output": "NO" }, { "input": "aabb", "output": "NO" }, { "input": "ac", "output": "NO" }, { "input": "abbacc", "output": "NO" }, { "input": "abacc", "output": "NO" }, { "input": "ababc", "output": "NO" }, { "input": "aa", "output": "NO" }, { "input": "aabaccc", "output": "NO" }, { "input": "bbcc", "output": "NO" }, { "input": "aaabcbc", "output": "NO" }, { "input": "acbbc", "output": "NO" }, { "input": "babc", "output": "NO" }, { "input": "bbbcc", "output": "NO" }, { "input": "bbc", "output": "NO" }, { "input": "abababccc", "output": "NO" }, { "input": "ccbbaa", "output": "NO" } ]

1,524,984,322

2,147,483,647

Python 3

OK

TESTS

55

93

7,065,600

s = input() a = s.count('a') b = s.count('b') if a and b and (s == 'a' * a + 'b' * b + 'c' * a or s == 'a' * a + 'b' * b + 'c' * b): print("YES") else: print("NO")

Title: Check the string Time Limit: None seconds Memory Limit: None megabytes Problem Description: A has a string consisting of some number of lowercase English letters 'a'. He gives it to his friend B who appends some number of letters 'b' to the end of this string. Since both A and B like the characters 'a' and 'b', they have made sure that at this point, at least one 'a' and one 'b' exist in the string. B now gives this string to C and he appends some number of letters 'c' to the end of the string. However, since C is a good friend of A and B, the number of letters 'c' he appends is equal to the number of 'a' or to the number of 'b' in the string. It is also possible that the number of letters 'c' equals both to the number of letters 'a' and to the number of letters 'b' at the same time. You have a string in your hands, and you want to check if it is possible to obtain the string in this way or not. If it is possible to obtain the string, print "YES", otherwise print "NO" (without the quotes). Input Specification: The first and only line consists of a string $S$ ($ 1 \le |S| \le 5\,000 $). It is guaranteed that the string will only consist of the lowercase English letters 'a', 'b', 'c'. Output Specification: Print "YES" or "NO", according to the condition. Demo Input: ['aaabccc\n', 'bbacc\n', 'aabc\n'] Demo Output: ['YES\n', 'NO\n', 'YES\n'] Note: Consider first example: the number of 'c' is equal to the number of 'a'. Consider second example: although the number of 'c' is equal to the number of the 'b', the order is not correct. Consider third example: the number of 'c' is equal to the number of 'b'.

```python s = input() a = s.count('a') b = s.count('b') if a and b and (s == 'a' * a + 'b' * b + 'c' * a or s == 'a' * a + 'b' * b + 'c' * b): print("YES") else: print("NO") ```

3

50

B

Choosing Symbol Pairs

PROGRAMMING

1,500

[ "strings" ]

B. Choosing Symbol Pairs

2

256

There is a given string *S* consisting of *N* symbols. Your task is to find the number of ordered pairs of integers *i* and *j* such that 1. 1<=≤<=*i*,<=*j*<=≤<=*N* 2. *S*[*i*]<==<=*S*[*j*], that is the *i*-th symbol of string *S* is equal to the *j*-th.

The single input line contains *S*, consisting of lowercase Latin letters and digits. It is guaranteed that string *S* in not empty and its length does not exceed 105.

Print a single number which represents the number of pairs *i* and *j* with the needed property. Pairs (*x*,<=*y*) and (*y*,<=*x*) should be considered different, i.e. the ordered pairs count.

[ "great10\n", "aaaaaaaaaa\n" ]

[ "7\n", "100\n" ]

none

1,000

[ { "input": "great10", "output": "7" }, { "input": "aaaaaaaaaa", "output": "100" }, { "input": "great10", "output": "7" }, { "input": "aaaaaaaaaa", "output": "100" }, { "input": "aabb", "output": "8" }, { "input": "w", "output": "1" }, { "input": "129a", "output": "4" }, { "input": "233444", "output": "14" }, { "input": "abacaba", "output": "21" }, { "input": "abcdefghijklmnopqrstuvwxyz0987654321abcdefghijklmnopqrstuvwxyz0987654321abcdefghijklmnopqrstuvwxyz0987654321", "output": "324" }, { "input": "zazaeeeeeeeq34443333444tttttt", "output": "155" }, { "input": "00000000000000000000000", "output": "529" }, { "input": "999000888775646453342311", "output": "62" } ]

1,677,758,695

2,147,483,647

Python 3

OK

TESTS

30

92

0

# LUOGU_RID: 103453417 n=0 d={} s=input() for i in s: d[i]=d.get(i,0)+1 for x in d.values(): n+=x**2 print(n)

Title: Choosing Symbol Pairs Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: There is a given string *S* consisting of *N* symbols. Your task is to find the number of ordered pairs of integers *i* and *j* such that 1. 1<=≤<=*i*,<=*j*<=≤<=*N* 2. *S*[*i*]<==<=*S*[*j*], that is the *i*-th symbol of string *S* is equal to the *j*-th. Input Specification: The single input line contains *S*, consisting of lowercase Latin letters and digits. It is guaranteed that string *S* in not empty and its length does not exceed 105. Output Specification: Print a single number which represents the number of pairs *i* and *j* with the needed property. Pairs (*x*,<=*y*) and (*y*,<=*x*) should be considered different, i.e. the ordered pairs count. Demo Input: ['great10\n', 'aaaaaaaaaa\n'] Demo Output: ['7\n', '100\n'] Note: none

```python # LUOGU_RID: 103453417 n=0 d={} s=input() for i in s: d[i]=d.get(i,0)+1 for x in d.values(): n+=x**2 print(n) ```

3.977

910

A

The Way to Home

PROGRAMMING

800

[ "dfs and similar", "dp", "greedy", "implementation" ]

null

A frog lives on the axis *Ox* and needs to reach home which is in the point *n*. She starts from the point 1. The frog can jump to the right at a distance not more than *d*. So, after she jumped from the point *x* she can reach the point *x*<=+<=*a*, where *a* is an integer from 1 to *d*. For each point from 1 to *n* is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and *n*. Determine the minimal number of jumps that the frog needs to reach home which is in the point *n* from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.

The first line contains two integers *n* and *d* (2<=≤<=*n*<=≤<=100, 1<=≤<=*d*<=≤<=*n*<=-<=1) — the point, which the frog wants to reach, and the maximal length of the frog jump. The second line contains a string *s* of length *n*, consisting of zeros and ones. If a character of the string *s* equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string *s* equal to one.

If the frog can not reach the home, print -1. In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point *n* from the point 1.

[ "8 4\n10010101\n", "4 2\n1001\n", "8 4\n11100101\n", "12 3\n101111100101\n" ]

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

In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four). In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.

500

[ { "input": "8 4\n10010101", "output": "2" }, { "input": "4 2\n1001", "output": "-1" }, { "input": "8 4\n11100101", "output": "3" }, { "input": "12 3\n101111100101", "output": "4" }, { "input": "5 4\n11011", "output": "1" }, { "input": "5 4\n10001", "output": "1" }, { "input": "10 7\n1101111011", "output": "2" }, { "input": "10 9\n1110000101", "output": "1" }, { "input": "10 9\n1100000001", "output": "1" }, { "input": "20 5\n11111111110111101001", "output": "4" }, { "input": "20 11\n11100000111000011011", "output": "2" }, { "input": "20 19\n10100000000000000001", "output": "1" }, { "input": "50 13\n10011010100010100111010000010000000000010100000101", "output": "5" }, { "input": "50 8\n11010100000011001100001100010001110000101100110011", "output": "8" }, { "input": "99 4\n111111111111111111111111111111111111111111111111111111111011111111111111111111111111111111111111111", "output": "25" }, { "input": "99 98\n100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "1" }, { "input": "100 5\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "20" }, { "input": "100 4\n1111111111111111111111111111111111111111111111111111111111111111111111111111110111111111111111111111", "output": "25" }, { "input": "100 4\n1111111111111111111111111111111111111111111111111111111111111101111111011111111111111111111111111111", "output": "25" }, { "input": "100 3\n1111110111111111111111111111111111111111101111111111111111111111111101111111111111111111111111111111", "output": "34" }, { "input": "100 8\n1111111111101110111111111111111111111111111111111111111111111111111111110011111111111111011111111111", "output": "13" }, { "input": "100 7\n1011111111111111111011101111111011111101111111111101111011110111111111111111111111110111111011111111", "output": "15" }, { "input": "100 9\n1101111110111110101111111111111111011001110111011101011111111111010101111111100011011111111010111111", "output": "12" }, { "input": "100 6\n1011111011111111111011010110011001010101111110111111000111011011111110101101110110101111110000100111", "output": "18" }, { "input": "100 7\n1110001111101001110011111111111101111101101001010001101000101100000101101101011111111101101000100001", "output": "16" }, { "input": "100 11\n1000010100011100011011100000010011001111011110100100001011010100011011111001101101110110010110001101", "output": "10" }, { "input": "100 9\n1001001110000011100100000001000110111101101010101001000101001010011001101100110011011110110011011111", "output": "13" }, { "input": "100 7\n1010100001110101111011000111000001110100100110110001110110011010100001100100001110111100110000101001", "output": "18" }, { "input": "100 10\n1110110000000110000000101110100000111000001011100000100110010001110111001010101000011000000001011011", "output": "12" }, { "input": "100 13\n1000000100000000100011000010010000101010011110000000001000011000110100001000010001100000011001011001", "output": "9" }, { "input": "100 11\n1000000000100000010000100001000100000000010000100100000000100100001000000001011000110001000000000101", "output": "12" }, { "input": "100 22\n1000100000001010000000000000000001000000100000000000000000010000000000001000000000000000000100000001", "output": "7" }, { "input": "100 48\n1000000000000000011000000000000000000000000000000001100000000000000000000000000000000000000000000001", "output": "3" }, { "input": "100 48\n1000000000000000000000100000000000000000000000000000000000000000000001000000000000000000100000000001", "output": "3" }, { "input": "100 75\n1000000100000000000000000000000000000000000000000000000000000000000000000000000001000000000000000001", "output": "3" }, { "input": "100 73\n1000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000001", "output": "2" }, { "input": "100 99\n1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "1" }, { "input": "100 1\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "99" }, { "input": "100 2\n1111111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111", "output": "50" }, { "input": "100 1\n1111111111111111011111111111111111111111111111111111111111111111111101111111111111111111111111111111", "output": "-1" }, { "input": "100 3\n1111111111111111111111111101111111111111111111111011111111111111111111111111111011111111111111111111", "output": "33" }, { "input": "100 1\n1101111111111111111111101111111111111111111111111111111111111011111111101111101111111111111111111111", "output": "-1" }, { "input": "100 6\n1111111111111111111111101111111101011110001111111111111111110111111111111111111111111110010111111111", "output": "17" }, { "input": "100 2\n1111111101111010110111011011110111101111111011111101010101011111011111111111111011111001101111101111", "output": "-1" }, { "input": "100 8\n1100110101111001101001111000111100110100011110111011001011111110000110101000001110111011100111011011", "output": "14" }, { "input": "100 10\n1000111110100000001001101100000010011100010101001100010011111001001101111110110111101111001010001101", "output": "11" }, { "input": "100 7\n1110000011010001110101011010000011110001000000011101110111010110001000011101111010010001101111110001", "output": "-1" }, { "input": "100 3\n1111010001000001011011000011001111000100101000101101000010111101111000010000011110110011001101010111", "output": "-1" }, { "input": "100 9\n1101010101101100010111011000010100001010000101010011001001100010110110000000010000101000000001101101", "output": "13" }, { "input": "100 14\n1010100000000000010101000010001100000000000011100010000001000001011010001110001010100000100001101101", "output": "9" }, { "input": "100 13\n1000000001101001110000010000011001000000000000001010000000100001001010000000000000000100010000000001", "output": "-1" }, { "input": "100 18\n1000000000000000110000000000000000010000000001000001000001000000000100000000000010000000000000000001", "output": "-1" }, { "input": "100 32\n1000000000000000000000000001000000000000000000000101000000000000000000000000000000000001000000000001", "output": "-1" }, { "input": "100 79\n1000000001000000000101000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "2" }, { "input": "100 41\n1000000000000000000000000000000000010000000000000000000000000000000000000000100000000000000000000001", "output": "3" }, { "input": "100 82\n1000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "2" }, { "input": "100 96\n1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "-1" }, { "input": "43 30\n1001000001111111010100100100110101011101101", "output": "2" }, { "input": "7 1\n1111111", "output": "6" }, { "input": "9 3\n101000001", "output": "-1" }, { "input": "10 3\n1100000001", "output": "-1" }, { "input": "8 2\n10000101", "output": "-1" }, { "input": "2 1\n11", "output": "1" } ]

1,688,181,706

2,147,483,647

Python 3

OK

TESTS

63

46

0

n, d = [int(x) for x in input().split()] s = str(input()) i = 0 ans = 0 temp = 0 while(1): temp = min(d, n-i-1) while(temp > 0): if s[i+temp] == "1": flag = 1 break else: temp -= 1 if temp == 0: flag = 0 ans += 1 i += temp # print(i, ans) if i == n-1 or not(flag): break if i+1 == n: print(ans) else: print(-1)

Title: The Way to Home Time Limit: None seconds Memory Limit: None megabytes Problem Description: A frog lives on the axis *Ox* and needs to reach home which is in the point *n*. She starts from the point 1. The frog can jump to the right at a distance not more than *d*. So, after she jumped from the point *x* she can reach the point *x*<=+<=*a*, where *a* is an integer from 1 to *d*. For each point from 1 to *n* is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and *n*. Determine the minimal number of jumps that the frog needs to reach home which is in the point *n* from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1. Input Specification: The first line contains two integers *n* and *d* (2<=≤<=*n*<=≤<=100, 1<=≤<=*d*<=≤<=*n*<=-<=1) — the point, which the frog wants to reach, and the maximal length of the frog jump. The second line contains a string *s* of length *n*, consisting of zeros and ones. If a character of the string *s* equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string *s* equal to one. Output Specification: If the frog can not reach the home, print -1. In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point *n* from the point 1. Demo Input: ['8 4\n10010101\n', '4 2\n1001\n', '8 4\n11100101\n', '12 3\n101111100101\n'] Demo Output: ['2\n', '-1\n', '3\n', '4\n'] Note: In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four). In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two.

```python n, d = [int(x) for x in input().split()] s = str(input()) i = 0 ans = 0 temp = 0 while(1): temp = min(d, n-i-1) while(temp > 0): if s[i+temp] == "1": flag = 1 break else: temp -= 1 if temp == 0: flag = 0 ans += 1 i += temp # print(i, ans) if i == n-1 or not(flag): break if i+1 == n: print(ans) else: print(-1) ```

3

916

C

Jamie and Interesting Graph

PROGRAMMING

1,600

[ "constructive algorithms", "graphs", "shortest paths" ]

null

Jamie has recently found undirected weighted graphs with the following properties very interesting: - The graph is connected and contains exactly *n* vertices and *m* edges. - All edge weights are integers and are in range [1,<=109] inclusive. - The length of shortest path from 1 to *n* is a prime number. - The sum of edges' weights in the minimum spanning tree (MST) of the graph is a prime number. - The graph contains no loops or multi-edges. If you are not familiar with some terms from the statement you can find definitions of them in notes section. Help Jamie construct any graph with given number of vertices and edges that is interesting!

First line of input contains 2 integers *n*, *m* — the required number of vertices and edges.

In the first line output 2 integers *sp*, *mstw* (1<=≤<=*sp*,<=*mstw*<=≤<=1014) — the length of the shortest path and the sum of edges' weights in the minimum spanning tree. In the next *m* lines output the edges of the graph. In each line output 3 integers *u*, *v*, *w* (1<=≤<=*u*,<=*v*<=≤<=*n*,<=1<=≤<=*w*<=≤<=109) describing the edge connecting *u* and *v* and having weight *w*.

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

[ "7 7\n1 2 3\n2 3 2\n3 4 2\n2 4 4\n", "7 13\n1 2 2\n1 3 4\n1 4 3\n4 5 4\n" ]

The graph of sample 1: <img class="tex-graphics" src="https://espresso.codeforces.com/42f9750de41b0d9a6b21e8615170113cfe19b0f2.png" style="max-width: 100.0%;max-height: 100.0%;"/> Shortest path sequence: {1, 2, 3, 4}. MST edges are marked with an asterisk (*). Definition of terms used in the problem statement: A shortest path in an undirected graph is a sequence of vertices (*v*1, *v*2, ... , *v**k*) such that *v**i* is adjacent to *v**i* + 1 1 ≤ *i* < *k* and the sum of weight <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/e7f62cfd5c2c3b81dc80aaf2f512898495354f03.png" style="max-width: 100.0%;max-height: 100.0%;"/> is minimized where *w*(*i*, *j*) is the edge weight between *i* and *j*. ([https://en.wikipedia.org/wiki/Shortest_path_problem](https://en.wikipedia.org/wiki/Shortest_path_problem)) A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. ([https://en.wikipedia.org/wiki/Prime_number](https://en.wikipedia.org/wiki/Prime_number)) A minimum spanning tree (MST) is a subset of the edges of a connected, edge-weighted undirected graph that connects all the vertices together, without any cycles and with the minimum possible total edge weight. ([https://en.wikipedia.org/wiki/Minimum_spanning_tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree)) [https://en.wikipedia.org/wiki/Multiple_edges](https://en.wikipedia.org/wiki/Multiple_edges)

1,500

[ { "input": "4 4", "output": "100003 100003\n1 2 100001\n2 3 1\n3 4 1\n1 3 1000000000" }, { "input": "5 4", "output": "100003 100003\n1 2 100000\n2 3 1\n3 4 1\n4 5 1" }, { "input": "2 1", "output": "100003 100003\n1 2 100003" }, { "input": "10 19", "output": "100003 100003\n1 2 99995\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n1 3 1000000000\n1 4 1000000000\n1 5 1000000000\n1 6 1000000000\n1 7 1000000000\n1 8 1000000000\n1 9 1000000000\n1 10 1000000000\n2 4 1000000000\n2 5 1000000000" }, { "input": "9 18", "output": "100003 100003\n1 2 99996\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n1 3 1000000000\n1 4 1000000000\n1 5 1000000000\n1 6 1000000000\n1 7 1000000000\n1 8 1000000000\n1 9 1000000000\n2 4 1000000000\n2 5 1000000000\n2 6 1000000000" }, { "input": "92 280", "output": "100003 100003\n1 2 99913\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "89 3439", "output": "100003 100003\n1 2 99916\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "926 31057", "output": "100003 100003\n1 2 99079\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "753 98686", "output": "100003 100003\n1 2 99252\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9724 31045", "output": "100003 100003\n1 2 90281\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "8732 93395", "output": "100003 100003\n1 2 91273\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "80297 83088", "output": "100003 100003\n1 2 19708\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "86549 98929", "output": "100003 100003\n1 2 13456\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "87 109", "output": "100003 100003\n1 2 99918\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "95 3582", "output": "100003 100003\n1 2 99910\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "96 557", "output": "100003 100003\n1 2 99909\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "85 3106", "output": "100003 100003\n1 2 99920\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "98 367", "output": "100003 100003\n1 2 99907\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "77 2344", "output": "100003 100003\n1 2 99928\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "84 286", "output": "100003 100003\n1 2 99921\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "100 4665", "output": "100003 100003\n1 2 99905\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "94 350", "output": "100003 100003\n1 2 99911\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "100 4309", "output": "100003 100003\n1 2 99905\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "88 666", "output": "100003 100003\n1 2 99917\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "93 4075", "output": "100003 100003\n1 2 99912\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "100 342", "output": "100003 100003\n1 2 99905\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "84 3482", "output": "100003 100003\n1 2 99921\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "943 51645", "output": "100003 100003\n1 2 99062\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "808 63768", "output": "100003 100003\n1 2 99197\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "898 1882", "output": "100003 100003\n1 2 99107\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "662 76813", "output": "100003 100003\n1 2 99343\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "681 13806", "output": "100003 100003\n1 2 99324\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "991 92176", "output": "100003 100003\n1 2 99014\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "745 4986", "output": "100003 100003\n1 2 99260\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "954 94880", "output": "100003 100003\n1 2 99051\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "965 5451", "output": "100003 100003\n1 2 99040\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "943 95302", "output": "100003 100003\n1 2 99062\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "879 8524", "output": "100003 100003\n1 2 99126\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "953 98192", "output": "100003 100003\n1 2 99052\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "806 1771", "output": "100003 100003\n1 2 99199\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "790 97497", "output": "100003 100003\n1 2 99215\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9492 36483", "output": "100003 100003\n1 2 90513\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "5839 48668", "output": "100003 100003\n1 2 94166\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9029 15632", "output": "100003 100003\n1 2 90976\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "5127 53185", "output": "100003 100003\n1 2 94878\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "7044 33010", "output": "100003 100003\n1 2 92961\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9637 98924", "output": "100003 100003\n1 2 90368\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "7837 45130", "output": "100003 100003\n1 2 92168\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9603 99398", "output": "100003 100003\n1 2 90402\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9204 11722", "output": "100003 100003\n1 2 90801\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "6996 90227", "output": "100003 100003\n1 2 93009\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9897 21204", "output": "100003 100003\n1 2 90108\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9051 92600", "output": "100003 100003\n1 2 90954\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9880 13424", "output": "100003 100003\n1 2 90125\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "9811 89446", "output": "100003 100003\n1 2 90194\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "90498 92256", "output": "100003 100003\n1 2 9507\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "99840 99968", "output": "100003 100003\n1 2 165\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 1..." }, { "input": "92340 92571", "output": "100003 100003\n1 2 7665\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "99019 99681", "output": "100003 100003\n1 2 986\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 1..." }, { "input": "93750 94653", "output": "100003 100003\n1 2 6255\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "99831 99956", "output": "100003 100003\n1 2 174\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 1..." }, { "input": "95373 95859", "output": "100003 100003\n1 2 4632\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "95519 99837", "output": "100003 100003\n1 2 4486\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "94183 94638", "output": "100003 100003\n1 2 5822\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "84935 98326", "output": "100003 100003\n1 2 15070\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "94995 95821", "output": "100003 100003\n1 2 5010\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "88804 99911", "output": "100003 100003\n1 2 11201\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "93394 94036", "output": "100003 100003\n1 2 6611\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "97796 99885", "output": "100003 100003\n1 2 2209\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 ..." }, { "input": "3 2", "output": "100003 100003\n1 2 100002\n2 3 1" }, { "input": "3 3", "output": "100003 100003\n1 2 100002\n2 3 1\n1 3 1000000000" }, { "input": "4 3", "output": "100003 100003\n1 2 100001\n2 3 1\n3 4 1" }, { "input": "4 5", "output": "100003 100003\n1 2 100001\n2 3 1\n3 4 1\n1 3 1000000000\n1 4 1000000000" }, { "input": "4 6", "output": "100003 100003\n1 2 100001\n2 3 1\n3 4 1\n1 3 1000000000\n1 4 1000000000\n2 4 1000000000" }, { "input": "100000 100000", "output": "100003 100003\n1 2 5\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58 1\n..." }, { "input": "50000 100000", "output": "100003 100003\n1 2 50005\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "1415 100000", "output": "100003 100003\n1 2 98590\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n19 20 1\n20 21 1\n21 22 1\n22 23 1\n23 24 1\n24 25 1\n25 26 1\n26 27 1\n27 28 1\n28 29 1\n29 30 1\n30 31 1\n31 32 1\n32 33 1\n33 34 1\n34 35 1\n35 36 1\n36 37 1\n37 38 1\n38 39 1\n39 40 1\n40 41 1\n41 42 1\n42 43 1\n43 44 1\n44 45 1\n45 46 1\n46 47 1\n47 48 1\n48 49 1\n49 50 1\n50 51 1\n51 52 1\n52 53 1\n53 54 1\n54 55 1\n55 56 1\n56 57 1\n57 58..." }, { "input": "13 17", "output": "100003 100003\n1 2 99992\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n1 3 1000000000\n1 4 1000000000\n1 5 1000000000\n1 6 1000000000\n1 7 1000000000" }, { "input": "19 31", "output": "100003 100003\n1 2 99986\n2 3 1\n3 4 1\n4 5 1\n5 6 1\n6 7 1\n7 8 1\n8 9 1\n9 10 1\n10 11 1\n11 12 1\n12 13 1\n13 14 1\n14 15 1\n15 16 1\n16 17 1\n17 18 1\n18 19 1\n1 3 1000000000\n1 4 1000000000\n1 5 1000000000\n1 6 1000000000\n1 7 1000000000\n1 8 1000000000\n1 9 1000000000\n1 10 1000000000\n1 11 1000000000\n1 12 1000000000\n1 13 1000000000\n1 14 1000000000\n1 15 1000000000" } ]

1,596,384,490

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

77

6,963,200

n, m = map(int, input().split()) p = 524287 print(2, (p if m > 1 else 2)) for i in range(2, n + 1): w = 1 if i == 2: w = p - n if i == n: w = 2 print(1, i, w) if m >= n: c = 1 count = 1 for i in range(0, m - n + 1): print(c, c + count, p) count += 1 if c == n - 1: c += 1 count = 1

Title: Jamie and Interesting Graph Time Limit: None seconds Memory Limit: None megabytes Problem Description: Jamie has recently found undirected weighted graphs with the following properties very interesting: - The graph is connected and contains exactly *n* vertices and *m* edges. - All edge weights are integers and are in range [1,<=109] inclusive. - The length of shortest path from 1 to *n* is a prime number. - The sum of edges' weights in the minimum spanning tree (MST) of the graph is a prime number. - The graph contains no loops or multi-edges. If you are not familiar with some terms from the statement you can find definitions of them in notes section. Help Jamie construct any graph with given number of vertices and edges that is interesting! Input Specification: First line of input contains 2 integers *n*, *m* — the required number of vertices and edges. Output Specification: In the first line output 2 integers *sp*, *mstw* (1<=≤<=*sp*,<=*mstw*<=≤<=1014) — the length of the shortest path and the sum of edges' weights in the minimum spanning tree. In the next *m* lines output the edges of the graph. In each line output 3 integers *u*, *v*, *w* (1<=≤<=*u*,<=*v*<=≤<=*n*,<=1<=≤<=*w*<=≤<=109) describing the edge connecting *u* and *v* and having weight *w*. Demo Input: ['4 4\n', '5 4\n'] Demo Output: ['7 7\n1 2 3\n2 3 2\n3 4 2\n2 4 4\n', '7 13\n1 2 2\n1 3 4\n1 4 3\n4 5 4\n'] Note: The graph of sample 1: <img class="tex-graphics" src="https://espresso.codeforces.com/42f9750de41b0d9a6b21e8615170113cfe19b0f2.png" style="max-width: 100.0%;max-height: 100.0%;"/> Shortest path sequence: {1, 2, 3, 4}. MST edges are marked with an asterisk (*). Definition of terms used in the problem statement: A shortest path in an undirected graph is a sequence of vertices (*v*1, *v*2, ... , *v**k*) such that *v**i* is adjacent to *v**i* + 1 1 ≤ *i* < *k* and the sum of weight <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/e7f62cfd5c2c3b81dc80aaf2f512898495354f03.png" style="max-width: 100.0%;max-height: 100.0%;"/> is minimized where *w*(*i*, *j*) is the edge weight between *i* and *j*. ([https://en.wikipedia.org/wiki/Shortest_path_problem](https://en.wikipedia.org/wiki/Shortest_path_problem)) A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. ([https://en.wikipedia.org/wiki/Prime_number](https://en.wikipedia.org/wiki/Prime_number)) A minimum spanning tree (MST) is a subset of the edges of a connected, edge-weighted undirected graph that connects all the vertices together, without any cycles and with the minimum possible total edge weight. ([https://en.wikipedia.org/wiki/Minimum_spanning_tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree)) [https://en.wikipedia.org/wiki/Multiple_edges](https://en.wikipedia.org/wiki/Multiple_edges)

```python n, m = map(int, input().split()) p = 524287 print(2, (p if m > 1 else 2)) for i in range(2, n + 1): w = 1 if i == 2: w = p - n if i == n: w = 2 print(1, i, w) if m >= n: c = 1 count = 1 for i in range(0, m - n + 1): print(c, c + count, p) count += 1 if c == n - 1: c += 1 count = 1 ```

0

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,695,584,851

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

186

0

def solvePuzzle(n,m,arr): arr.sort() return min(arr[n-1] - arr[0],arr[-1] - arr[m-n]); n,m = map(int,input().split()); arr = list(map(int,input().split())); print(solvePuzzle(n,m,arr));

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 def solvePuzzle(n,m,arr): arr.sort() return min(arr[n-1] - arr[0],arr[-1] - arr[m-n]); n,m = map(int,input().split()); arr = list(map(int,input().split())); print(solvePuzzle(n,m,arr)); ```

0

114

A

Cifera

PROGRAMMING

1,000

[ "math" ]

null

When Petya went to school, he got interested in large numbers and what they were called in ancient times. For instance, he learned that the Russian word "tma" (which now means "too much to be counted") used to stand for a thousand and "tma tmyschaya" (which literally means "the tma of tmas") used to stand for a million. Petya wanted to modernize the words we use for numbers and invented a word petricium that represents number *k*. Moreover, petricium la petricium stands for number *k*2, petricium la petricium la petricium stands for *k*3 and so on. All numbers of this form are called petriciumus cifera, and the number's importance is the number of articles la in its title. Petya's invention brought on a challenge that needed to be solved quickly: does some number *l* belong to the set petriciumus cifera? As Petya is a very busy schoolboy he needs to automate the process, he asked you to solve it.

The first input line contains integer number *k*, the second line contains integer number *l* (2<=≤<=*k*,<=*l*<=≤<=231<=-<=1).

You should print in the first line of the output "YES", if the number belongs to the set petriciumus cifera and otherwise print "NO". If the number belongs to the set, then print on the seconds line the only number — the importance of number *l*.

[ "5\n25\n", "3\n8\n" ]

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

none

500

[ { "input": "5\n25", "output": "YES\n1" }, { "input": "3\n8", "output": "NO" }, { "input": "123\n123", "output": "YES\n0" }, { "input": "99\n970300", "output": "NO" }, { "input": "1000\n6666666", "output": "NO" }, { "input": "59\n3571", "output": "NO" }, { "input": "256\n16777217", "output": "NO" }, { "input": "4638\n21511044", "output": "YES\n1" }, { "input": "24\n191102976", "output": "YES\n5" }, { "input": "52010\n557556453", "output": "NO" }, { "input": "61703211\n1750753082", "output": "NO" }, { "input": "137\n2571353", "output": "YES\n2" }, { "input": "8758\n1746157336", "output": "NO" }, { "input": "2\n64", "output": "YES\n5" }, { "input": "96\n884736", "output": "YES\n2" }, { "input": "1094841453\n1656354409", "output": "NO" }, { "input": "1154413\n1229512809", "output": "NO" }, { "input": "2442144\n505226241", "output": "NO" }, { "input": "11548057\n1033418098", "output": "NO" }, { "input": "581\n196122941", "output": "YES\n2" }, { "input": "146\n1913781536", "output": "NO" }, { "input": "945916\n1403881488", "output": "NO" }, { "input": "68269\n365689065", "output": "NO" }, { "input": "30\n900", "output": "YES\n1" }, { "input": "6\n1296", "output": "YES\n3" }, { "input": "1470193122\n1420950405", "output": "NO" }, { "input": "90750\n1793111557", "output": "NO" }, { "input": "1950054\n1664545956", "output": "NO" }, { "input": "6767692\n123762320", "output": "NO" }, { "input": "1437134\n1622348229", "output": "NO" }, { "input": "444103\n1806462642", "output": "NO" }, { "input": "2592\n6718464", "output": "YES\n1" }, { "input": "50141\n366636234", "output": "NO" }, { "input": "835\n582182875", "output": "YES\n2" }, { "input": "156604\n902492689", "output": "NO" }, { "input": "27385965\n1742270058", "output": "NO" }, { "input": "3\n9", "output": "YES\n1" }, { "input": "35\n1838265625", "output": "YES\n5" }, { "input": "8\n4096", "output": "YES\n3" }, { "input": "85955\n945811082", "output": "NO" }, { "input": "54958832\n956670209", "output": "NO" }, { "input": "1475381\n1348159738", "output": "NO" }, { "input": "7313241\n413670642", "output": "NO" }, { "input": "582470\n2116368165", "output": "NO" }, { "input": "26859739\n595086170", "output": "NO" }, { "input": "249766393\n1582130", "output": "NO" }, { "input": "11734\n137686756", "output": "YES\n1" }, { "input": "925093\n1098566745", "output": "NO" }, { "input": "40\n1600", "output": "YES\n1" }, { "input": "2147483647\n2147483647", "output": "YES\n0" }, { "input": "2147483646\n2147483647", "output": "NO" }, { "input": "2147483647\n2147483646", "output": "NO" }, { "input": "2\n2147483647", "output": "NO" }, { "input": "2\n1073741825", "output": "NO" }, { "input": "2\n1073741824", "output": "YES\n29" }, { "input": "10000\n10", "output": "NO" }, { "input": "10\n10000", "output": "YES\n3" }, { "input": "10\n2000000000", "output": "NO" }, { "input": "10\n1000000000", "output": "YES\n8" }, { "input": "5\n1808548329", "output": "NO" }, { "input": "2\n2147483646", "output": "NO" }, { "input": "25\n125", "output": "NO" }, { "input": "6\n18", "output": "NO" }, { "input": "5\n30", "output": "NO" } ]

1,579,275,003

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

8

218

0

n = int(input()) p = int(input()) f = 0 for i in range(1, int(2**31)): if p ** (1/i) == n: print('YES') print(i-1) f = 1 elif p**(1/i) < n: break if not f: print('NO')

Title: Cifera Time Limit: None seconds Memory Limit: None megabytes Problem Description: When Petya went to school, he got interested in large numbers and what they were called in ancient times. For instance, he learned that the Russian word "tma" (which now means "too much to be counted") used to stand for a thousand and "tma tmyschaya" (which literally means "the tma of tmas") used to stand for a million. Petya wanted to modernize the words we use for numbers and invented a word petricium that represents number *k*. Moreover, petricium la petricium stands for number *k*2, petricium la petricium la petricium stands for *k*3 and so on. All numbers of this form are called petriciumus cifera, and the number's importance is the number of articles la in its title. Petya's invention brought on a challenge that needed to be solved quickly: does some number *l* belong to the set petriciumus cifera? As Petya is a very busy schoolboy he needs to automate the process, he asked you to solve it. Input Specification: The first input line contains integer number *k*, the second line contains integer number *l* (2<=≤<=*k*,<=*l*<=≤<=231<=-<=1). Output Specification: You should print in the first line of the output "YES", if the number belongs to the set petriciumus cifera and otherwise print "NO". If the number belongs to the set, then print on the seconds line the only number — the importance of number *l*. Demo Input: ['5\n25\n', '3\n8\n'] Demo Output: ['YES\n1\n', 'NO\n'] Note: none

```python n = int(input()) p = int(input()) f = 0 for i in range(1, int(2**31)): if p ** (1/i) == n: print('YES') print(i-1) f = 1 elif p**(1/i) < n: break if not f: print('NO') ```

0

141

A

Amusing Joke

PROGRAMMING

800

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

null

So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. One night, when everyone went to bed, someone took all the letters of our characters' names. Then he may have shuffled the letters and put them in one pile in front of the door. The next morning it was impossible to find the culprit who had made the disorder. But everybody wondered whether it is possible to restore the names of the host and his guests from the letters lying at the door? That is, we need to verify that there are no extra letters, and that nobody will need to cut more letters. Help the "New Year and Christmas Men" and their friends to cope with this problem. You are given both inscriptions that hung over the front door the previous night, and a pile of letters that were found at the front door next morning.

The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line does not exceed 100.

Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes.

[ "SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS\n", "PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI\n", "BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER\n" ]

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

In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left. In the second sample letter "P" is missing from the pile and there's an extra letter "L". In the third sample there's an extra letter "L".

500

[ { "input": "SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS", "output": "YES" }, { "input": "PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI", "output": "NO" }, { "input": "BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER", "output": "NO" }, { "input": "B\nA\nAB", "output": "YES" }, { "input": "ONDOL\nJNPB\nONLNJBODP", "output": "YES" }, { "input": "Y\nW\nYW", "output": "YES" }, { "input": "OI\nM\nIMO", "output": "YES" }, { "input": "VFQRWWWACX\nGHZJPOQUSXRAQDGOGMR\nOPAWDOUSGWWCGQXXQAZJRQRGHRMVF", "output": "YES" }, { "input": "JUTCN\nPIGMZOPMEUFADQBW\nNWQGZMAIPUPOMCDUB", "output": "NO" }, { "input": "Z\nO\nZOCNDOLTBZKQLTBOLDEGXRHZGTTPBJBLSJCVSVXISQZCSFDEBXRCSGBGTHWOVIXYHACAGBRYBKBJAEPIQZHVEGLYH", "output": "NO" }, { "input": "IQ\nOQ\nQOQIGGKFNHJSGCGM", "output": "NO" }, { "input": "ROUWANOPNIGTVMIITVMZ\nOQTUPZMTKUGY\nVTVNGZITGPUNPMQOOATUUIYIWMMKZOTR", "output": "YES" }, { "input": "OVQELLOGFIOLEHXMEMBJDIGBPGEYFG\nJNKFPFFIJOFHRIFHXEWYZOPDJBZTJZKBWQTECNHRFSJPJOAPQT\nYAIPFFFEXJJNEJPLREIGODEGQZVMCOBDFKWTMWJSBEBTOFFQOHIQJLHFNXIGOHEZRZLFOKJBJPTPHPGY", "output": "YES" }, { "input": "NBJGVNGUISUXQTBOBKYHQCOOVQWUXWPXBUDLXPKX\nNSFQDFUMQDQWQ\nWXKKVNTDQQFXCUQBIMQGQHSLVGWSBFYBUPOWPBDUUJUXQNOQDNXOX", "output": "YES" }, { "input": "IJHHGKCXWDBRWJUPRDBZJLNTTNWKXLUGJSBWBOAUKWRAQWGFNL\nNJMWRMBCNPHXTDQQNZ\nWDNJRCLILNQRHWBANLTXWMJBPKUPGKJDJZAQWKTZFBRCTXHHBNXRGUQUNBNMWODGSJWW", "output": "YES" }, { "input": "SRROWANGUGZHCIEFYMQVTWVOMDWPUZJFRDUMVFHYNHNTTGNXCJ\nDJYWGLBFCCECXFHOLORDGDCNRHPWXNHXFCXQCEZUHRRNAEKUIX\nWCUJDNYHNHYOPWMHLDCDYRWBVOGHFFUKOZTXJRXJHRGWICCMRNEVNEGQWTZPNFCSHDRFCFQDCXMHTLUGZAXOFNXNVGUEXIACRERU", "output": "YES" }, { "input": "H\nJKFGHMIAHNDBMFXWYQLZRSVNOTEGCQSVUBYUOZBTNKTXPFQDCMKAGFITEUGOYDFIYQIORMFJEOJDNTFVIQEBICSNGKOSNLNXJWC\nBQSVDOGIHCHXSYNYTQFCHNJGYFIXTSOQINZOKSVQJMTKNTGFNXAVTUYEONMBQMGJLEWJOFGEARIOPKFUFCEMUBRBDNIIDFZDCLWK", "output": "YES" }, { "input": "DSWNZRFVXQ\nPVULCZGOOU\nUOLVZXNUPOQRZGWFVDSCANQTCLEIE", "output": "NO" }, { "input": "EUHTSCENIPXLTSBMLFHD\nIZAVSZPDLXOAGESUSE\nLXAELAZ", "output": "NO" }, { "input": "WYSJFEREGELSKRQRXDXCGBODEFZVSI\nPEJKMGFLBFFDWRCRFSHVEFLEBTJCVCHRJTLDTISHPOGFWPLEWNYJLMXWIAOTYOXMV\nHXERTZWLEXTPIOTFRVMEJVYFFJLRPFMXDEBNSGCEOFFCWTKIDDGCFYSJKGLHBORWEPLDRXRSJYBGASSVCMHEEJFLVI", "output": "NO" }, { "input": "EPBMDIUQAAUGLBIETKOKFLMTCVEPETWJRHHYKCKU\nHGMAETVPCFZYNNKDQXVXUALHYLOTCHM\nECGXACVKEYMCEDOTMKAUFHLHOMT", "output": "NO" }, { "input": "NUBKQEJHALANSHEIFUZHYEZKKDRFHQKAJHLAOWTZIMOCWOVVDW\nEFVOBIGAUAUSQGVSNBKNOBDMINODMFSHDL\nKLAMKNTHBFFOHVKWICHBKNDDQNEISODUSDNLUSIOAVWY", "output": "NO" }, { "input": "VXINHOMEQCATZUGAJEIUIZZLPYFGUTVLNBNWCUVMEENUXKBWBGZTMRJJVJDLVSLBABVCEUDDSQFHOYPYQTWVAGTWOLKYISAGHBMC\nZMRGXPZSHOGCSAECAPGVOIGCWEOWWOJXLGYRDMPXBLOKZVRACPYQLEQGFQCVYXAGBEBELUTDAYEAGPFKXRULZCKFHZCHVCWIRGPK\nRCVUXGQVNWFGRUDLLENNDQEJHYYVWMKTLOVIPELKPWCLSQPTAXAYEMGWCBXEVAIZGGDDRBRT", "output": "NO" }, { "input": "PHBDHHWUUTZAHELGSGGOPOQXSXEZIXHZTOKYFBQLBDYWPVCNQSXHEAXRRPVHFJBVBYCJIFOTQTWSUOWXLKMVJJBNLGTVITWTCZZ\nFUPDLNVIHRWTEEEHOOEC\nLOUSUUSZCHJBPEWIILUOXEXRQNCJEGTOBRVZLTTZAHTKVEJSNGHFTAYGY", "output": "NO" }, { "input": "GDSLNIIKTO\nJF\nPDQYFKDTNOLI", "output": "NO" }, { "input": "AHOKHEKKPJLJIIWJRCGY\nORELJCSIX\nZVWPXVFWFSWOXXLIHJKPXIOKRELYE", "output": "NO" }, { "input": "ZWCOJFORBPHXCOVJIDPKVECMHVHCOC\nTEV\nJVGTBFTLFVIEPCCHODOFOMCVZHWXVCPEH", "output": "NO" }, { "input": "AGFIGYWJLVMYZGNQHEHWKJIAWBPUAQFERMCDROFN\nPMJNHMVNRGCYZAVRWNDSMLSZHFNYIUWFPUSKKIGU\nMCDVPPRXGUAYLSDRHRURZASXUWZSIIEZCPXUVEONKNGNWRYGOSFMCKESMVJZHWWUCHWDQMLASLNNMHAU", "output": "NO" }, { "input": "XLOWVFCZSSXCSYQTIIDKHNTKNKEEDFMDZKXSPVLBIDIREDUAIN\nZKIWNDGBISDB\nSLPKLYFYSRNRMOSWYLJJDGFFENPOXYLPZFTQDANKBDNZDIIEWSUTTKYBKVICLG", "output": "NO" }, { "input": "PMUKBTRKFIAYVGBKHZHUSJYSSEPEOEWPOSPJLWLOCTUYZODLTUAFCMVKGQKRRUSOMPAYOTBTFPXYAZXLOADDEJBDLYOTXJCJYTHA\nTWRRAJLCQJTKOKWCGUH\nEWDPNXVCXWCDQCOYKKSOYTFSZTOOPKPRDKFJDETKSRAJRVCPDOBWUGPYRJPUWJYWCBLKOOTUPBESTOFXZHTYLLMCAXDYAEBUTAHM", "output": "NO" }, { "input": "QMIMGQRQDMJDPNFEFXSXQMCHEJKTWCTCVZPUAYICOIRYOWKUSIWXJLHDYWSBOITHTMINXFKBKAWZTXXBJIVYCRWKXNKIYKLDDXL\nV\nFWACCXBVDOJFIUAVYRALBYJKXXWIIFORRUHKHCXLDBZMXIYJWISFEAWTIQFIZSBXMKNOCQKVKRWDNDAMQSTKYLDNYVTUCGOJXJTW", "output": "NO" }, { "input": "XJXPVOOQODELPPWUISSYVVXRJTYBPDHJNENQEVQNVFIXSESKXVYPVVHPMOSX\nLEXOPFPVPSZK\nZVXVPYEYOYXVOISVLXPOVHEQVXPNQJIOPFDTXEUNMPEPPHELNXKKWSVSOXSBPSJDPVJVSRFQ", "output": "YES" }, { "input": "OSKFHGYNQLSRFSAHPXKGPXUHXTRBJNAQRBSSWJVEENLJCDDHFXVCUNPZAIVVO\nFNUOCXAGRRHNDJAHVVLGGEZQHWARYHENBKHP\nUOEFNWVXCUNERLKVTHAGPSHKHDYFPYWZHJKHQLSNFBJHVJANRXCNSDUGVDABGHVAOVHBJZXGRACHRXEGNRPQEAPORQSILNXFS", "output": "YES" }, { "input": "VYXYVVACMLPDHONBUTQFZTRREERBLKUJYKAHZRCTRLRCLOZYWVPBRGDQPFPQIF\nFE\nRNRPEVDRLYUQFYRZBCQLCYZEABKLRXCJLKVZBVFUEYRATOMDRTHFPGOWQVTIFPPH", "output": "YES" }, { "input": "WYXUZQJQNLASEGLHPMSARWMTTQMQLVAZLGHPIZTRVTCXDXBOLNXZPOFCTEHCXBZ\nBLQZRRWP\nGIQZXPLTTMNHQVWPPEAPLOCDMBSTHRCFLCQRRZXLVAOQEGZBRUZJXXZTMAWLZHSLWNQTYXB", "output": "YES" }, { "input": "MKVJTSSTDGKPVVDPYSRJJYEVGKBMSIOKHLZQAEWLRIBINVRDAJIBCEITKDHUCCVY\nPUJJQFHOGZKTAVNUGKQUHMKTNHCCTI\nQVJKUSIGTSVYUMOMLEGHWYKSKQTGATTKBNTKCJKJPCAIRJIRMHKBIZISEGFHVUVQZBDERJCVAKDLNTHUDCHONDCVVJIYPP", "output": "YES" }, { "input": "OKNJOEYVMZXJMLVJHCSPLUCNYGTDASKSGKKCRVIDGEIBEWRVBVRVZZTLMCJLXHJIA\nDJBFVRTARTFZOWN\nAGHNVUNJVCPLWSVYBJKZSVTFGLELZASLWTIXDDJXCZDICTVIJOTMVEYOVRNMJGRKKHRMEBORAKFCZJBR", "output": "YES" }, { "input": "OQZACLPSAGYDWHFXDFYFRRXWGIEJGSXWUONAFWNFXDTGVNDEWNQPHUXUJNZWWLBPYL\nOHBKWRFDRQUAFRCMT\nWIQRYXRJQWWRUWCYXNXALKFZGXFTLOODWRDPGURFUFUQOHPWBASZNVWXNCAGHWEHFYESJNFBMNFDDAPLDGT", "output": "YES" }, { "input": "OVIRQRFQOOWVDEPLCJETWQSINIOPLTLXHSQWUYUJNFBMKDNOSHNJQQCDHZOJVPRYVSV\nMYYDQKOOYPOOUELCRIT\nNZSOTVLJTTVQLFHDQEJONEOUOFOLYVSOIYUDNOSIQVIRMVOERCLMYSHPCQKIDRDOQPCUPQBWWRYYOXJWJQPNKH", "output": "YES" }, { "input": "WGMBZWNMSJXNGDUQUJTCNXDSJJLYRDOPEGPQXYUGBESDLFTJRZDDCAAFGCOCYCQMDBWK\nYOBMOVYTUATTFGJLYUQD\nDYXVTLQCYFJUNJTUXPUYOPCBCLBWNSDUJRJGWDOJDSQAAMUOJWSYERDYDXYTMTOTMQCGQZDCGNFBALGGDFKZMEBG", "output": "YES" }, { "input": "CWLRBPMEZCXAPUUQFXCUHAQTLPBTXUUKWVXKBHKNSSJFEXLZMXGVFHHVTPYAQYTIKXJJE\nMUFOSEUEXEQTOVLGDSCWM\nJUKEQCXOXWEHCGKFPBIGMWVJLXUONFXBYTUAXERYTXKCESKLXAEHVPZMMUFTHLXTTZSDMBJLQPEUWCVUHSQQVUASPF", "output": "YES" }, { "input": "IDQRX\nWETHO\nODPDGBHVUVSSISROHQJTUKPUCLXABIZQQPPBPKOSEWGEHRSRRNBAVLYEMZISMWWGKHVTXKUGUXEFBSWOIWUHRJGMWBMHQLDZHBWA", "output": "NO" }, { "input": "IXFDY\nJRMOU\nDF", "output": "NO" }, { "input": "JPSPZ\nUGCUB\nJMZZZZZZZZ", "output": "NO" }, { "input": "AC\nA\nBBA", "output": "NO" }, { "input": "UIKWWKXLSHTOOZOVGXKYSOJEHAUEEG\nKZXQDWJJWRXFHKJDQHJK\nXMZHTFOGEXAUJXXJUYVJIFOTKLZHDKELJWERHMGAWGKWAQKEKHIDWGGZVYOHKXRPWSJDPESFJUMKQYWBYUTHQYEFZUGKQOBHYDWB", "output": "NO" }, { "input": "PXWRXRPFLR\nPJRWWXIVHODV\nXW", "output": "NO" }, { "input": "CHTAZVHGSHCVIBK\nEQINEBKXEPYJSAZIMLDF\nZCZZZZDZMCZZEZDZZEZZZZQZZBZZZOZZCZE", "output": "NO" }, { "input": "GXPZFSELJJNDAXYRV\nUYBKPMVBSOVOJWMONLTJOJCNQKMTAHEWLHOWIIBH\nHCWNFWJPEJIWOVPTBMVCRJLSISSVNOHCKLBFMIUAIMASQWPXEYXBOXQGFEMYJLBKDCZIMJNHOJEDGGANIVYKQTUOSOVOPWHVJGXH", "output": "NO" }, { "input": "LFGJCJJDUTUP\nOVSBILTIYCJCRHKCIXCETJQJJ\nGIJJTJCLTJJJ", "output": "NO" }, { "input": "GIO\nPRL\nPRL", "output": "NO" }, { "input": "A\nB\nABC", "output": "NO" }, { "input": "KKK\nKKK\nZZZZZ", "output": "NO" }, { "input": "ZMYGQLDBLAPN\nZFJBKWHROVNPSJQUDFTHOCGREUFLYIWYICD\nZMJZZEDAZANKZZZZZZEZZBZDZZZZZZKHZZFZZZDZNZMDZZA", "output": "NO" } ]

1,688,148,398

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

8

62

0

a=input() b=input() c=input() x=[*a] y=[*b] z=[*c] l=z[:] v=0 for i in range(len(z)): if z[i] in x: x.remove(z[i]) l.remove(z[i]) elif z[i] in y: y.remove(z[i]) l.remove(z[i]) else: v+=1 break if v==1: print("NO") elif(len(x)==0 and len(y)==0 and len(l)==0): print("YES")

Title: Amusing Joke Time Limit: None seconds Memory Limit: None megabytes Problem Description: So, the New Year holidays are over. Santa Claus and his colleagues can take a rest and have guests at last. When two "New Year and Christmas Men" meet, thear assistants cut out of cardboard the letters from the guest's name and the host's name in honor of this event. Then the hung the letters above the main entrance. One night, when everyone went to bed, someone took all the letters of our characters' names. Then he may have shuffled the letters and put them in one pile in front of the door. The next morning it was impossible to find the culprit who had made the disorder. But everybody wondered whether it is possible to restore the names of the host and his guests from the letters lying at the door? That is, we need to verify that there are no extra letters, and that nobody will need to cut more letters. Help the "New Year and Christmas Men" and their friends to cope with this problem. You are given both inscriptions that hung over the front door the previous night, and a pile of letters that were found at the front door next morning. Input Specification: The input file consists of three lines: the first line contains the guest's name, the second line contains the name of the residence host and the third line contains letters in a pile that were found at the door in the morning. All lines are not empty and contain only uppercase Latin letters. The length of each line does not exceed 100. Output Specification: Print "YES" without the quotes, if the letters in the pile could be permuted to make the names of the "New Year and Christmas Men". Otherwise, print "NO" without the quotes. Demo Input: ['SANTACLAUS\nDEDMOROZ\nSANTAMOROZDEDCLAUS\n', 'PAPAINOEL\nJOULUPUKKI\nJOULNAPAOILELUPUKKI\n', 'BABBONATALE\nFATHERCHRISTMAS\nBABCHRISTMASBONATALLEFATHER\n'] Demo Output: ['YES\n', 'NO\n', 'NO\n'] Note: In the first sample the letters written in the last line can be used to write the names and there won't be any extra letters left. In the second sample letter "P" is missing from the pile and there's an extra letter "L". In the third sample there's an extra letter "L".

```python a=input() b=input() c=input() x=[*a] y=[*b] z=[*c] l=z[:] v=0 for i in range(len(z)): if z[i] in x: x.remove(z[i]) l.remove(z[i]) elif z[i] in y: y.remove(z[i]) l.remove(z[i]) else: v+=1 break if v==1: print("NO") elif(len(x)==0 and len(y)==0 and len(l)==0): print("YES") ```

0

301

A

Yaroslav and Sequence

PROGRAMMING

1,800

[ "constructive algorithms" ]

null

Yaroslav has an array, consisting of (2·*n*<=-<=1) integers. In a single operation Yaroslav can change the sign of exactly *n* elements in the array. In other words, in one operation Yaroslav can select exactly *n* array elements, and multiply each of them by -1. Yaroslav is now wondering: what maximum sum of array elements can be obtained if it is allowed to perform any number of described operations? Help Yaroslav.

The first line contains an integer *n* (2<=≤<=*n*<=≤<=100). The second line contains (2·*n*<=-<=1) integers — the array elements. The array elements do not exceed 1000 in their absolute value.

In a single line print the answer to the problem — the maximum sum that Yaroslav can get.

[ "2\n50 50 50\n", "2\n-1 -100 -1\n" ]

[ "150\n", "100\n" ]

In the first sample you do not need to change anything. The sum of elements equals 150. In the second sample you need to change the sign of the first two elements. Then we get the sum of the elements equal to 100.

500

[ { "input": "2\n50 50 50", "output": "150" }, { "input": "2\n-1 -100 -1", "output": "100" }, { "input": "3\n-959 -542 -669 -513 160", "output": "2843" }, { "input": "4\n717 473 344 -51 -548 703 -869", "output": "3603" }, { "input": "5\n270 -181 957 -509 -6 937 -175 434 -625", "output": "4094" }, { "input": "6\n-403 901 -847 -708 -624 413 -293 709 886 445 716", "output": "6359" }, { "input": "7\n-236 533 869 903 655 -714 27 890 -311 800 307 -682 665", "output": "7592" }, { "input": "8\n-338 134 708 -761 -135 535 631 -354 -259 -973 -147 -281 737 516 -222", "output": "6463" }, { "input": "9\n-690 34 -821 842 -712 -909 36 -62 255 -363 433 794 883 -274 -642 343 -1", "output": "8094" }, { "input": "10\n86 -619 547 620 -383 -928 945 -253 835 -36 373 925 -705 -64 -577 -386 318 535 528", "output": "9591" }, { "input": "19\n-919 -82 -467 -169 100 -363 644 -307 926 971 -695 658 -625 19 -269 -89 63 -733 827 -236 566 95 -496 975 284 157 -373 -656 -245 644 567 -971 -954 337 150 -67 714", "output": "17413" }, { "input": "22\n697 556 -538 879 -623 73 -293 -401 -491 -7 -144 853 -319 395 785 248 -585 0 -420 -830 -720 75 411 -397 746 828 -83 -833 -847 709 181 967 314 -633 -322 415 -450 433 -459 438 508 -870 -949", "output": "21725" }, { "input": "19\n752 -869 -583 -729 984 -321 -477 -462 429 857 -57 -807 184 296 -594 -728 -903 -524 -726 -551 722 -895 696 301 -339 784 -743 -689 -657 170 -957 -88 -197 832 -65 -689 743", "output": "21400" }, { "input": "22\n549 635 969 -519 -858 185 -788 126 -840 533 -560 168 -539 -962 649 -721 -574 245 -986 -859 496 -257 -361 180 -691 -528 -992 -833 -989 -222 901 950 388 -803 624 -536 -588 310 812 320 862 -640 -851", "output": "26399" }, { "input": "34\n-944 484 -717 515 -827 765 -746 763 -333 184 979 101 -524 199 624 -200 -903 -488 -376 543 924 18 958 55 -826 -12 419 497 580 -286 25 -512 -858 214 271 58 897 178 -644 -598 -41 -737 156 -765 -182 702 748 -113 -335 282 -456 -860 688 -306 614 -995 -876 -437 684 -353 -711 363 -545 -324 -418 840 472", "output": "34048" }, { "input": "19\n-550 109 141 -201 -922 45 926 6 -245 -846 -695 572 -788 -963 -253 161 107 879 78 551 486 563 -533 -376 615 627 913 411 -494 -101 -45 -877 -416 736 255 -810 -491", "output": "17787" }, { "input": "56\n-157 136 457 598 -138 -586 -338 752 -566 -718 -333 -965 309 -125 -938 -188 -390 17 -75 -902 -320 163 820 -970 -525 -329 81 488 -412 978 138 344 305 -358 -273 -967 253 -665 -245 187 602 252 -825 -511 828 764 -402 278 995 541 542 549 612 -536 527 -884 225 800 160 -409 -926 -795 -321 -791 981 812 599 381 752 -331 -585 -987 -918 -930 -223 491 -42 -716 836 -412 -497 211 -348 704 -638 6 -840 476 -769 -842 530 616 -97 588 -299 803 228 -250 193 -27 539 -697 417 88 242 578 642 -30 856 -98 70", "output": "54799" }, { "input": "46\n-302 538 -331 769 255 -485 979 -725 937 -136 -469 234 496 -696 857 597 -691 122 -540 139 75 -444 749 887 95 -584 526 595 -44 -992 563 -972 533 335 -913 -58 -369 -602 -550 47 -321 588 337 -392 -956 211 758 940 -122 -861 -310 946 -163 420 608 -252 54 -466 -227 -974 -790 178 35 849 617 219 741 914 358 -759 -246 -58 -52 307 -290 399 15 -655 -14 -462 492 -425 511 956 331 -929 905 -866 181 938 60", "output": "44689" }, { "input": "27\n-401 -840 -583 -612 -298 -384 798 366 -922 -443 -972 -271 127 -201 992 -748 -351 925 -177 -528 355 5 131 -779 833 -382 -990 -379 -816 681 650 660 624 -112 -652 406 446 -999 259 -778 452 -705 -374 -710 -751 -852 119 -689 -789 96 -984 186 70", "output": "28653" }, { "input": "19\n-150 -962 -857 346 257 898 675 629 -104 -105 560 -525 -64 282 647 -341 -781 400 -80 830 360 877 -751 -1 -392 960 989 935 777 -509 -614 -331 301 -305 587 -284 936", "output": "19402" }, { "input": "38\n-593 446 -769 -498 957 958 -510 515 257 -75 -145 -942 -307 965 -749 110 -793 -457 812 -679 38 -803 274 -932 954 -923 -300 -528 -238 -624 801 939 -462 -894 679 102 886 62 -212 966 -877 942 -325 -900 -997 -65 783 723 353 -972 172 -234 197 69 885 964 71 328 -144 -860 -712 -848 -185 672 622 -364 -403 308 -309 -316 -935 -889 -757 -346 528", "output": "42209" }, { "input": "5\n0 0 0 0 0 -1 -1 -1 -1", "output": "4" }, { "input": "4\n0 0 0 0 0 -1 -1", "output": "2" }, { "input": "5\n0 0 0 0 0 -1 -1 1 1", "output": "4" }, { "input": "4\n0 0 0 0 0 -1 1", "output": "2" }, { "input": "2\n-1 -1 1", "output": "3" }, { "input": "3\n-1 1 1 1 1", "output": "5" }, { "input": "5\n-1 -1 -1 2 2 2 2 2 2", "output": "15" }, { "input": "3\n-100 100 100 100 100", "output": "500" }, { "input": "5\n-1 -2 -3 -4 -5 -6 -7 8 9", "output": "45" }, { "input": "5\n-1 -1 -1 -1 -1 -1 -1 -1 -1", "output": "9" }, { "input": "3\n-1 -1 -1 -1 -1", "output": "5" }, { "input": "4\n-1 -1 -1 0 1 1 1", "output": "6" }, { "input": "7\n-5 -10 12 40 20 -33 23 12 -23 21 -32 14 24", "output": "269" }, { "input": "3\n-2 3 4 5 6", "output": "20" }, { "input": "5\n-10 -100 -100 -10 -20 -5 -1 2 3", "output": "251" } ]

1,630,729,902

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

2

154

20,172,800

import sys input=sys.stdin.readline n=int(input()) a=list(map(int,input().split())) minus=0 for i in range(n): if a[i]<0: minus+=1 a[i]*=-1 if minus%2==0 or n%2==1: print(sum(a)) else: print(sum(a)-min(a)*2)

Title: Yaroslav and Sequence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Yaroslav has an array, consisting of (2·*n*<=-<=1) integers. In a single operation Yaroslav can change the sign of exactly *n* elements in the array. In other words, in one operation Yaroslav can select exactly *n* array elements, and multiply each of them by -1. Yaroslav is now wondering: what maximum sum of array elements can be obtained if it is allowed to perform any number of described operations? Help Yaroslav. Input Specification: The first line contains an integer *n* (2<=≤<=*n*<=≤<=100). The second line contains (2·*n*<=-<=1) integers — the array elements. The array elements do not exceed 1000 in their absolute value. Output Specification: In a single line print the answer to the problem — the maximum sum that Yaroslav can get. Demo Input: ['2\n50 50 50\n', '2\n-1 -100 -1\n'] Demo Output: ['150\n', '100\n'] Note: In the first sample you do not need to change anything. The sum of elements equals 150. In the second sample you need to change the sign of the first two elements. Then we get the sum of the elements equal to 100.

```python import sys input=sys.stdin.readline n=int(input()) a=list(map(int,input().split())) minus=0 for i in range(n): if a[i]<0: minus+=1 a[i]*=-1 if minus%2==0 or n%2==1: print(sum(a)) else: print(sum(a)-min(a)*2) ```

0

26

A

Almost Prime

PROGRAMMING

900

[ "number theory" ]

A. Almost Prime

2

256

A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive.

Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000).

Output the amount of almost prime numbers between 1 and *n*, inclusive.

[ "10\n", "21\n" ]

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

none

500

[ { "input": "10", "output": "2" }, { "input": "21", "output": "8" }, { "input": "1", "output": "0" }, { "input": "2", "output": "0" }, { "input": "4", "output": "0" }, { "input": "3", "output": "0" }, { "input": "8", "output": "1" }, { "input": "19", "output": "6" }, { "input": "40", "output": "19" }, { "input": "77", "output": "41" }, { "input": "222", "output": "125" }, { "input": "987", "output": "501" }, { "input": "1000", "output": "508" }, { "input": "2000", "output": "958" }, { "input": "3000", "output": "1375" }, { "input": "2999", "output": "1375" }, { "input": "2998", "output": "1375" }, { "input": "2997", "output": "1374" }, { "input": "1429", "output": "706" }, { "input": "1673", "output": "808" }, { "input": "1500", "output": "732" }, { "input": "500", "output": "266" }, { "input": "856", "output": "439" } ]

1,680,276,591

2,147,483,647

PyPy 3-64

OK

TESTS

23

154

1,638,400

n = int(input()) answer = 0 ansss = [] for x in range(1, n + 1): d = 2 ans = 0 saved = x while d // 2 <= x: if not x % d: while not x % d: x //= d ans += 1 if ans > 2: break d += 1 if ans == 2: answer += 1 print(answer)

Title: Almost Prime Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive. Input Specification: Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000). Output Specification: Output the amount of almost prime numbers between 1 and *n*, inclusive. Demo Input: ['10\n', '21\n'] Demo Output: ['2\n', '8\n'] Note: none

```python n = int(input()) answer = 0 ansss = [] for x in range(1, n + 1): d = 2 ans = 0 saved = x while d // 2 <= x: if not x % d: while not x % d: x //= d ans += 1 if ans > 2: break d += 1 if ans == 2: answer += 1 print(answer) ```

3.958448

986

D

Perfect Encoding

PROGRAMMING

3,100

[ "fft", "math" ]

null

You are working as an analyst in a company working on a new system for big data storage. This system will store $n$ different objects. Each object should have a unique ID. To create the system, you choose the parameters of the system — integers $m \ge 1$ and $b_{1}, b_{2}, \ldots, b_{m}$. With these parameters an ID of some object in the system is an array of integers $[a_{1}, a_{2}, \ldots, a_{m}]$ where $1 \le a_{i} \le b_{i}$ holds for every $1 \le i \le m$. Developers say that production costs are proportional to $\sum_{i=1}^{m} b_{i}$. You are asked to choose parameters $m$ and $b_{i}$ so that the system will be able to assign unique IDs to $n$ different objects and production costs are minimized. Note that you don't have to use all available IDs.

In the only line of input there is one positive integer $n$. The length of the decimal representation of $n$ is no greater than $1.5 \cdot 10^{6}$. The integer does not contain leading zeros.

Print one number — minimal value of $\sum_{i=1}^{m} b_{i}$.

[ "36\n", "37\n", "12345678901234567890123456789\n" ]

[ "10\n", "11\n", "177\n" ]

none

2,500

[ { "input": "36", "output": "10" }, { "input": "37", "output": "11" }, { "input": "12345678901234567890123456789", "output": "177" }, { "input": "1", "output": "1" }, { "input": "2", "output": "2" }, { "input": "3", "output": "3" }, { "input": "4", "output": "4" }, { "input": "7421902501252475186372406731932548506197390793597574544727433297197476846519276598727359617092494798", "output": "629" }, { "input": "71057885893313745806894531138592341136175030511382512555364579061229040750815096670263802546201989828165866147027119861863385397179695224216202346062872417111920113483747119385957051753101263769591892062039112567316036455789217245754461225443096439906225767290690128677713047690686004149082311677134836383178262318973298581951974863511315252485252083010690948164456205330279738760034861583874764199950445592461479109814313530332776429627014232776723160331462731018692207739471347664936326394313671025", "output": "3144" }, { "input": "515377520732011331036461129765621272702107522001", "output": "300" }, { "input": "515377520732011331036461129765621272702107522002", "output": "301" }, { "input": "515377520732011331036461129765621272702107522000", "output": "300" }, { "input": "2644141638961613273780910519504288731930844065504296335329840736453657194693409799081556627701216123927819555393745164711901909164201237823730685450515907348055240450396641607756029548457929682548780800235177236082257895631246188876123132346108173348981012356250960688811094108794077791634930736509832272441660537127557164580456832796615775793837112808169797875218746484343692719877391033530037881176218120852179342877728205628700771297494331664021228732264346205537805710440002", "output": "3002" } ]

1,596,636,135

7,335

PyPy 3

WRONG_ANSWER

TESTS

0

124

20,172,800

import math def calc(n): x = 3 k = 1 xs = [3] ks = [1] res = 0 while x <= n: n = (n + x - 1) // x res += k x = x * x k = k + k xs.append(x) ks.append(k) while len(xs) > 0: x = xs.pop() k = ks.pop() if x <= n: n = (n + x - 1) // x res += k if n != 0: res += 1 return res * 3 n = int(input()) ans = min(calc(n), calc((n + 1) // 2) + 2, calc((n + 3) // 4) + 4) print(ans)

Title: Perfect Encoding Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are working as an analyst in a company working on a new system for big data storage. This system will store $n$ different objects. Each object should have a unique ID. To create the system, you choose the parameters of the system — integers $m \ge 1$ and $b_{1}, b_{2}, \ldots, b_{m}$. With these parameters an ID of some object in the system is an array of integers $[a_{1}, a_{2}, \ldots, a_{m}]$ where $1 \le a_{i} \le b_{i}$ holds for every $1 \le i \le m$. Developers say that production costs are proportional to $\sum_{i=1}^{m} b_{i}$. You are asked to choose parameters $m$ and $b_{i}$ so that the system will be able to assign unique IDs to $n$ different objects and production costs are minimized. Note that you don't have to use all available IDs. Input Specification: In the only line of input there is one positive integer $n$. The length of the decimal representation of $n$ is no greater than $1.5 \cdot 10^{6}$. The integer does not contain leading zeros. Output Specification: Print one number — minimal value of $\sum_{i=1}^{m} b_{i}$. Demo Input: ['36\n', '37\n', '12345678901234567890123456789\n'] Demo Output: ['10\n', '11\n', '177\n'] Note: none

```python import math def calc(n): x = 3 k = 1 xs = [3] ks = [1] res = 0 while x <= n: n = (n + x - 1) // x res += k x = x * x k = k + k xs.append(x) ks.append(k) while len(xs) > 0: x = xs.pop() k = ks.pop() if x <= n: n = (n + x - 1) // x res += k if n != 0: res += 1 return res * 3 n = int(input()) ans = min(calc(n), calc((n + 1) // 2) + 2, calc((n + 3) // 4) + 4) print(ans) ```

0

329

A

Purification

PROGRAMMING

1,500

[ "constructive algorithms", "greedy" ]

null

You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak zombies, you arrived at a square room consisting of tiles forming an *n*<=×<=*n* grid. The rows are numbered 1 through *n* from top to bottom, and the columns are numbered 1 through *n* from left to right. At the far side of the room lies a door locked with evil magical forces. The following inscriptions are written on the door: Being a very senior adventurer, you immediately realize what this means. You notice that every single cell in the grid are initially evil. You should purify all of these cells. The only method of tile purification known to you is by casting the "Purification" spell. You cast this spell on a single tile — then, all cells that are located in the same row and all cells that are located in the same column as the selected tile become purified (including the selected tile)! It is allowed to purify a cell more than once. You would like to purify all *n*<=×<=*n* cells while minimizing the number of times you cast the "Purification" spell. This sounds very easy, but you just noticed that some tiles are particularly more evil than the other tiles. You cannot cast the "Purification" spell on those particularly more evil tiles, not even after they have been purified. They can still be purified if a cell sharing the same row or the same column gets selected by the "Purification" spell. Please find some way to purify all the cells with the minimum number of spells cast. Print -1 if there is no such way.

The first line will contain a single integer *n* (1<=≤<=*n*<=≤<=100). Then, *n* lines follows, each contains *n* characters. The *j*-th character in the *i*-th row represents the cell located at row *i* and column *j*. It will be the character 'E' if it is a particularly more evil cell, and '.' otherwise.

If there exists no way to purify all the cells, output -1. Otherwise, if your solution casts *x* "Purification" spells (where *x* is the minimum possible number of spells), output *x* lines. Each line should consist of two integers denoting the row and column numbers of the cell on which you should cast the "Purification" spell.

[ "3\n.E.\nE.E\n.E.\n", "3\nEEE\nE..\nE.E\n", "5\nEE.EE\nE.EE.\nE...E\n.EE.E\nEE.EE\n" ]

[ "1 1\n2 2\n3 3\n", "-1\n", "3 3\n1 3\n2 2\n4 4\n5 3" ]

The first example is illustrated as follows. Purple tiles are evil tiles that have not yet been purified. Red tile is the tile on which "Purification" is cast. Yellow tiles are the tiles being purified as a result of the current "Purification" spell. Green tiles are tiles that have been purified previously. In the second example, it is impossible to purify the cell located at row 1 and column 1. For the third example:

500

[ { "input": "3\n.E.\nE.E\n.E.", "output": "1 1\n2 2\n3 1" }, { "input": "3\nEEE\nE..\nE.E", "output": "-1" }, { "input": "5\nEE.EE\nE.EE.\nE...E\n.EE.E\nEE.EE", "output": "1 3\n2 2\n3 2\n4 1\n5 3" }, { "input": "3\n.EE\n.EE\n.EE", "output": "1 1\n2 1\n3 1" }, { "input": "5\nEE.EE\nEE..E\nEEE..\nEE..E\nEE.EE", "output": "1 3\n2 3\n3 4\n4 3\n5 3" }, { "input": "1\nE", "output": "-1" }, { "input": "8\nE.EEE..E\nEEE.E.E.\nEEE.E.E.\nEE.E.E..\nE...EE..\nE.EE....\n..EE....\nE..E.EE.", "output": "1 2\n2 4\n3 4\n4 3\n5 2\n6 2\n7 1\n8 2" }, { "input": "17\nEE...E.EE.EE..E..\nE.....EE..E..E..E\nEEEE.EEEE..E..E.E\n.E.E.EEE.EEEEE...\nEEEEEEEEEEEEEEEEE\nEE.E.EEEEE.E.....\n..E.EE.EEE.E....E\n.E..E..E...EE.E.E\nEEEE.EEE.E.EEEE..\n...E...EEEEEEE.E.\n..E.E.EE..E.EE..E\n.E..E..E.EEE.....\n.E.....E..EEE.EE.\nEE.E...E.EEEE.EE.\n...EEEEEEE.E..E.E\nEEEE.EEEEEE....E.\n..EEEEEEE....EEEE", "output": "-1" }, { "input": "17\n.EEEEE...EEEE..EE\nEEE..E...EEEEE..E\n.E..E..EEE.EE...E\n.EEE.EE..EE...E..\nE..EEEEEE.EE.....\nE.EE...EEEEEEE.E.\nEEEE....EE..E.EEE\n...EEEEE.E..EE...\nEEE.E..EEEE.EEE..\n..E.E....EEE.....\nEE..E..E.E..EEEEE\nEEE..E.EEEEE.E...\n..EEEEE.E..EE.EE.\nEE.E...E..E..E.EE\n..E.EEE.EE..EE.E.\nE..EE........E.E.\nE..E..EEE.E...E..", "output": "1 1\n2 4\n3 1\n4 1\n5 2\n6 2\n7 5\n8 1\n9 4\n10 1\n11 3\n12 4\n13 1\n14 3\n15 1\n16 2\n17 2" }, { "input": "1\n.", "output": "1 1" }, { "input": "2\nEE\nEE", "output": "-1" }, { "input": "2\n.E\n.E", "output": "1 1\n2 1" }, { "input": "3\n.EE\nEEE\nEEE", "output": "-1" }, { "input": "3\n...\nEEE\n..E", "output": "1 1\n1 2\n1 3" }, { "input": "4\nE...\nE.EE\nEEEE\nEEEE", "output": "-1" }, { "input": "4\n....\nE..E\nEEE.\n.EE.", "output": "1 1\n2 2\n3 4\n4 1" }, { "input": "8\nE..EEEEE\nEE..EEE.\nEE..E...\nEEE.E..E\n.E.EEEE.\nEEEEEEEE\n.EEEE.EE\n.EE.E.E.", "output": "-1" }, { "input": "3\nE..\nEEE\nE..", "output": "-1" }, { "input": "4\nEEEE\n..E.\n..E.\n..E.", "output": "-1" }, { "input": "3\n..E\n.EE\n.EE", "output": "1 1\n2 1\n3 1" }, { "input": "6\n.EEEEE\n.EEEEE\n......\n......\n......\nEEEEEE", "output": "1 1\n3 2\n3 3\n3 4\n3 5\n3 6" } ]

1,581,458,732

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

186

307,200

n = int(input()) l = [] for _ in range(n): l.append([x for x in input()]) results = [] thing = True for i in range(n): hit = False for j in range(n): if l[i][j] != "E": results.append(f"{i + 1} {j + 1}") hit = True break if not hit: thing = False break if not thing: for j in range(n): hit = False for i in range(n): if l[i][j] != "E": results.append(f"{j + 1} {i + 1}") hit = True break if not hit: thing = False break if thing: for r in results: print(r) else: print(-1)

Title: Purification Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak zombies, you arrived at a square room consisting of tiles forming an *n*<=×<=*n* grid. The rows are numbered 1 through *n* from top to bottom, and the columns are numbered 1 through *n* from left to right. At the far side of the room lies a door locked with evil magical forces. The following inscriptions are written on the door: Being a very senior adventurer, you immediately realize what this means. You notice that every single cell in the grid are initially evil. You should purify all of these cells. The only method of tile purification known to you is by casting the "Purification" spell. You cast this spell on a single tile — then, all cells that are located in the same row and all cells that are located in the same column as the selected tile become purified (including the selected tile)! It is allowed to purify a cell more than once. You would like to purify all *n*<=×<=*n* cells while minimizing the number of times you cast the "Purification" spell. This sounds very easy, but you just noticed that some tiles are particularly more evil than the other tiles. You cannot cast the "Purification" spell on those particularly more evil tiles, not even after they have been purified. They can still be purified if a cell sharing the same row or the same column gets selected by the "Purification" spell. Please find some way to purify all the cells with the minimum number of spells cast. Print -1 if there is no such way. Input Specification: The first line will contain a single integer *n* (1<=≤<=*n*<=≤<=100). Then, *n* lines follows, each contains *n* characters. The *j*-th character in the *i*-th row represents the cell located at row *i* and column *j*. It will be the character 'E' if it is a particularly more evil cell, and '.' otherwise. Output Specification: If there exists no way to purify all the cells, output -1. Otherwise, if your solution casts *x* "Purification" spells (where *x* is the minimum possible number of spells), output *x* lines. Each line should consist of two integers denoting the row and column numbers of the cell on which you should cast the "Purification" spell. Demo Input: ['3\n.E.\nE.E\n.E.\n', '3\nEEE\nE..\nE.E\n', '5\nEE.EE\nE.EE.\nE...E\n.EE.E\nEE.EE\n'] Demo Output: ['1 1\n2 2\n3 3\n', '-1\n', '3 3\n1 3\n2 2\n4 4\n5 3'] Note: The first example is illustrated as follows. Purple tiles are evil tiles that have not yet been purified. Red tile is the tile on which "Purification" is cast. Yellow tiles are the tiles being purified as a result of the current "Purification" spell. Green tiles are tiles that have been purified previously. In the second example, it is impossible to purify the cell located at row 1 and column 1. For the third example:

```python n = int(input()) l = [] for _ in range(n): l.append([x for x in input()]) results = [] thing = True for i in range(n): hit = False for j in range(n): if l[i][j] != "E": results.append(f"{i + 1} {j + 1}") hit = True break if not hit: thing = False break if not thing: for j in range(n): hit = False for i in range(n): if l[i][j] != "E": results.append(f"{j + 1} {i + 1}") hit = True break if not hit: thing = False break if thing: for r in results: print(r) else: print(-1) ```

0

9

C

Hexadecimal's Numbers

PROGRAMMING

1,200

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

C. Hexadecimal's Numbers

1

64

One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of *n* different natural numbers from 1 to *n* to obtain total control over her energy. But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully.

Input data contains the only number *n* (1<=≤<=*n*<=≤<=109).

Output the only number — answer to the problem.

[ "10\n" ]

[ "2" ]

For *n* = 10 the answer includes numbers 1 and 10.

0

[ { "input": "10", "output": "2" }, { "input": "20", "output": "3" }, { "input": "72", "output": "3" }, { "input": "99", "output": "3" }, { "input": "100", "output": "4" }, { "input": "101", "output": "5" }, { "input": "102", "output": "5" }, { "input": "111", "output": "7" }, { "input": "112", "output": "7" }, { "input": "745", "output": "7" }, { "input": "23536", "output": "31" }, { "input": "1", "output": "1" }, { "input": "1010011", "output": "83" }, { "input": "312410141", "output": "511" }, { "input": "1000000000", "output": "512" }, { "input": "999999999", "output": "511" }, { "input": "111111111", "output": "511" }, { "input": "101010101", "output": "341" }, { "input": "121212121", "output": "511" }, { "input": "106341103", "output": "383" }, { "input": "901556123", "output": "511" }, { "input": "832513432", "output": "511" }, { "input": "3", "output": "1" }, { "input": "732875234", "output": "511" }, { "input": "7", "output": "1" }, { "input": "9", "output": "1" }, { "input": "2", "output": "1" }, { "input": "11", "output": "3" }, { "input": "12", "output": "3" }, { "input": "13", "output": "3" }, { "input": "101020101", "output": "351" }, { "input": "111100100", "output": "484" }, { "input": "110110101", "output": "437" }, { "input": "100111001", "output": "313" }, { "input": "100100", "output": "36" }, { "input": "110100102", "output": "421" } ]

1,611,734,527

4,627

PyPy 3

OK

TESTS

36

216

0

import sys # import logging # logging.root.setLevel(level=logging.INFO) n = int(sys.stdin.readline().strip().split()[0]) i = 1 while int((bin(i))[2:]) <= n: i += 1 print(i-1)

Title: Hexadecimal's Numbers Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: One beautiful July morning a terrible thing happened in Mainframe: a mean virus Megabyte somehow got access to the memory of his not less mean sister Hexadecimal. He loaded there a huge amount of *n* different natural numbers from 1 to *n* to obtain total control over her energy. But his plan failed. The reason for this was very simple: Hexadecimal didn't perceive any information, apart from numbers written in binary format. This means that if a number in a decimal representation contained characters apart from 0 and 1, it was not stored in the memory. Now Megabyte wants to know, how many numbers were loaded successfully. Input Specification: Input data contains the only number *n* (1<=≤<=*n*<=≤<=109). Output Specification: Output the only number — answer to the problem. Demo Input: ['10\n'] Demo Output: ['2'] Note: For *n* = 10 the answer includes numbers 1 and 10.

```python import sys # import logging # logging.root.setLevel(level=logging.INFO) n = int(sys.stdin.readline().strip().split()[0]) i = 1 while int((bin(i))[2:]) <= n: i += 1 print(i-1) ```

3.892

935

A

Fafa and his Company

PROGRAMMING

800

[ "brute force", "implementation" ]

null

Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees. Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader. Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly.

The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company.

Print a single integer representing the answer to the problem.

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

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

In the second sample Fafa has 3 ways: - choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.

500

[ { "input": "2", "output": "1" }, { "input": "10", "output": "3" }, { "input": "3", "output": "1" }, { "input": "4", "output": "2" }, { "input": "6", "output": "3" }, { "input": "13", "output": "1" }, { "input": "100000", "output": "35" }, { "input": "1024", "output": "10" }, { "input": "99999", "output": "11" }, { "input": "10007", "output": "1" }, { "input": "4096", "output": "12" }, { "input": "65536", "output": "16" }, { "input": "40320", "output": "95" }, { "input": "30030", "output": "63" }, { "input": "161", "output": "3" }, { "input": "1000", "output": "15" }, { "input": "10000", "output": "24" }, { "input": "777", "output": "7" }, { "input": "121", "output": "2" }, { "input": "25", "output": "2" }, { "input": "40000", "output": "34" }, { "input": "99990", "output": "47" }, { "input": "98765", "output": "3" }, { "input": "56789", "output": "3" }, { "input": "13579", "output": "3" }, { "input": "97531", "output": "3" }, { "input": "12345", "output": "7" }, { "input": "54321", "output": "7" }, { "input": "83160", "output": "127" }, { "input": "9", "output": "2" }, { "input": "21", "output": "3" }, { "input": "11", "output": "1" }, { "input": "15", "output": "3" } ]

1,642,209,742

2,147,483,647

Python 3

OK

TESTS

33

62

102,400

from functools import reduce def factors(n): return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))) n = int(input()) fact = factors(n) length = len(fact) print(length - 1)

Title: Fafa and his Company Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees. Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader. Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly. Input Specification: The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company. Output Specification: Print a single integer representing the answer to the problem. Demo Input: ['2\n', '10\n'] Demo Output: ['1\n', '3\n'] Note: In the second sample Fafa has 3 ways: - choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.

```python from functools import reduce def factors(n): return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))) n = int(input()) fact = factors(n) length = len(fact) print(length - 1) ```

3

322

A

Ciel and Dancing

PROGRAMMING

1,000

[ "greedy" ]

null

Fox Ciel and her friends are in a dancing room. There are *n* boys and *m* girls here, and they never danced before. There will be some songs, during each song, there must be exactly one boy and one girl are dancing. Besides, there is a special rule: - either the boy in the dancing pair must dance for the first time (so, he didn't dance with anyone before); - or the girl in the dancing pair must dance for the first time. Help Fox Ciel to make a schedule that they can dance as many songs as possible.

The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of boys and girls in the dancing room.

In the first line print *k* — the number of songs during which they can dance. Then in the following *k* lines, print the indexes of boys and girls dancing during songs chronologically. You can assume that the boys are indexed from 1 to *n*, and the girls are indexed from 1 to *m*.

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

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

In test case 1, there are 2 boys and 1 girl. We can have 2 dances: the 1st boy and 1st girl (during the first song), the 2nd boy and 1st girl (during the second song). And in test case 2, we have 2 boys with 2 girls, the answer is 3.

500

[ { "input": "2 1", "output": "2\n1 1\n2 1" }, { "input": "2 2", "output": "3\n1 1\n1 2\n2 2" }, { "input": "1 1", "output": "1\n1 1" }, { "input": "2 3", "output": "4\n1 1\n1 2\n1 3\n2 3" }, { "input": "4 4", "output": "7\n1 1\n1 2\n1 3\n1 4\n4 4\n3 4\n2 4" }, { "input": "1 12", "output": "12\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12" }, { "input": "12 1", "output": "12\n1 1\n12 1\n11 1\n10 1\n9 1\n8 1\n7 1\n6 1\n5 1\n4 1\n3 1\n2 1" }, { "input": "100 100", "output": "199\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "24 6", "output": "29\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n24 6\n23 6\n22 6\n21 6\n20 6\n19 6\n18 6\n17 6\n16 6\n15 6\n14 6\n13 6\n12 6\n11 6\n10 6\n9 6\n8 6\n7 6\n6 6\n5 6\n4 6\n3 6\n2 6" }, { "input": "7 59", "output": "65\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n7 59\n6 59\n5 59\n4 59\n3 59\n2 59" }, { "input": "26 75", "output": "100\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n26 75\n25 75\n24 75\n23 75\n22 75\n21 75\n20 75\n19 75\n18 75\n17..." }, { "input": "32 87", "output": "118\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "42 51", "output": "92\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n42 51\n41 51\n40 51\n39 51\n38 51\n37 51\n36 51\n35 51\n34 51\n33 51\n32 51\n31 51\n30 51\n29 51\n28 51\n27 51\n26 51\n25 51\n24 51\n23 51\n22 51\n21 51\n20 51\n19 51\n18 51\n17 51\n16 51\n15 51\n14 51\n13 51\n..." }, { "input": "4 63", "output": "66\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n4 63\n3 63\n2 63" }, { "input": "10 79", "output": "88\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n10 79\n9 79\n8 79\n7 79\n6 79\n5 79\n4 79\n..." }, { "input": "20 95", "output": "114\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "35 55", "output": "89\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n35 55\n34 55\n33 55\n32 55\n31 55\n30 55\n29 55\n28 55\n27 55\n26 55\n25 55\n24 55\n23 55\n22 55\n21 55\n20 55\n19 55\n18 55\n17 55\n16 55\n15 55\n14 55\n13 55\n12 55\n11 55\n10 55\n9 55..." }, { "input": "45 71", "output": "115\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n45 71\n44 71\n43 71\n42 71\n41 71\n40 71\n39 71\n38 71\n37 71\n36 71\n35 71\n34 71\n33 71..." }, { "input": "7 83", "output": "89\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n7 83\n6 83\n5 83\n..." }, { "input": "32 100", "output": "131\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "42 17", "output": "58\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n42 17\n41 17\n40 17\n39 17\n38 17\n37 17\n36 17\n35 17\n34 17\n33 17\n32 17\n31 17\n30 17\n29 17\n28 17\n27 17\n26 17\n25 17\n24 17\n23 17\n22 17\n21 17\n20 17\n19 17\n18 17\n17 17\n16 17\n15 17\n14 17\n13 17\n12 17\n11 17\n10 17\n9 17\n8 17\n7 17\n6 17\n5 17\n4 17\n3 17\n2 17" }, { "input": "1 77", "output": "77\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77" }, { "input": "19 93", "output": "111\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "25 5", "output": "29\n1 1\n1 2\n1 3\n1 4\n1 5\n25 5\n24 5\n23 5\n22 5\n21 5\n20 5\n19 5\n18 5\n17 5\n16 5\n15 5\n14 5\n13 5\n12 5\n11 5\n10 5\n9 5\n8 5\n7 5\n6 5\n5 5\n4 5\n3 5\n2 5" }, { "input": "35 21", "output": "55\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n35 21\n34 21\n33 21\n32 21\n31 21\n30 21\n29 21\n28 21\n27 21\n26 21\n25 21\n24 21\n23 21\n22 21\n21 21\n20 21\n19 21\n18 21\n17 21\n16 21\n15 21\n14 21\n13 21\n12 21\n11 21\n10 21\n9 21\n8 21\n7 21\n6 21\n5 21\n4 21\n3 21\n2 21" }, { "input": "99 99", "output": "197\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "99 100", "output": "198\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "100 99", "output": "198\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." } ]

1,628,751,592

2,147,483,647

Python 3

OK

TESTS

28

154

6,758,400

l=list(map(int,input().split())) n,m=l[0],l[1] print(n+m-1) for i in range(1,m+1): print(1,i) for i in range(2,n+1): print(i,1)

Title: Ciel and Dancing Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fox Ciel and her friends are in a dancing room. There are *n* boys and *m* girls here, and they never danced before. There will be some songs, during each song, there must be exactly one boy and one girl are dancing. Besides, there is a special rule: - either the boy in the dancing pair must dance for the first time (so, he didn't dance with anyone before); - or the girl in the dancing pair must dance for the first time. Help Fox Ciel to make a schedule that they can dance as many songs as possible. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of boys and girls in the dancing room. Output Specification: In the first line print *k* — the number of songs during which they can dance. Then in the following *k* lines, print the indexes of boys and girls dancing during songs chronologically. You can assume that the boys are indexed from 1 to *n*, and the girls are indexed from 1 to *m*. Demo Input: ['2 1\n', '2 2\n'] Demo Output: ['2\n1 1\n2 1\n', '3\n1 1\n1 2\n2 2\n'] Note: In test case 1, there are 2 boys and 1 girl. We can have 2 dances: the 1st boy and 1st girl (during the first song), the 2nd boy and 1st girl (during the second song). And in test case 2, we have 2 boys with 2 girls, the answer is 3.

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

3

935

A

Fafa and his Company

PROGRAMMING

800

[ "brute force", "implementation" ]

null

Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees. Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader. Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly.

The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company.

Print a single integer representing the answer to the problem.

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

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

In the second sample Fafa has 3 ways: - choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.

500

[ { "input": "2", "output": "1" }, { "input": "10", "output": "3" }, { "input": "3", "output": "1" }, { "input": "4", "output": "2" }, { "input": "6", "output": "3" }, { "input": "13", "output": "1" }, { "input": "100000", "output": "35" }, { "input": "1024", "output": "10" }, { "input": "99999", "output": "11" }, { "input": "10007", "output": "1" }, { "input": "4096", "output": "12" }, { "input": "65536", "output": "16" }, { "input": "40320", "output": "95" }, { "input": "30030", "output": "63" }, { "input": "161", "output": "3" }, { "input": "1000", "output": "15" }, { "input": "10000", "output": "24" }, { "input": "777", "output": "7" }, { "input": "121", "output": "2" }, { "input": "25", "output": "2" }, { "input": "40000", "output": "34" }, { "input": "99990", "output": "47" }, { "input": "98765", "output": "3" }, { "input": "56789", "output": "3" }, { "input": "13579", "output": "3" }, { "input": "97531", "output": "3" }, { "input": "12345", "output": "7" }, { "input": "54321", "output": "7" }, { "input": "83160", "output": "127" }, { "input": "9", "output": "2" }, { "input": "21", "output": "3" }, { "input": "11", "output": "1" }, { "input": "15", "output": "3" } ]

1,636,894,102

2,147,483,647

Python 3

OK

TESTS

33

62

4,300,800

c=0 n=int(input()) for i in range(1,n): if n%i==0: c=c+1 else: continue print(c)

Title: Fafa and his Company Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fafa owns a company that works on huge projects. There are *n* employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees. Fafa finds doing this every time is very tiring for him. So, he decided to choose the best *l* employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader. Given the number of employees *n*, find in how many ways Fafa could choose the number of team leaders *l* in such a way that it is possible to divide employees between them evenly. Input Specification: The input consists of a single line containing a positive integer *n* (2<=≤<=*n*<=≤<=105) — the number of employees in Fafa's company. Output Specification: Print a single integer representing the answer to the problem. Demo Input: ['2\n', '10\n'] Demo Output: ['1\n', '3\n'] Note: In the second sample Fafa has 3 ways: - choose only 1 employee as a team leader with 9 employees under his responsibility. - choose 2 employees as team leaders with 4 employees under the responsibility of each of them. - choose 5 employees as team leaders with 1 employee under the responsibility of each of them.

```python c=0 n=int(input()) for i in range(1,n): if n%i==0: c=c+1 else: continue print(c) ```

3

493

B

Vasya and Wrestling

PROGRAMMING

1,400

[ "implementation" ]

null

Vasya has become interested in wrestling. In wrestling wrestlers use techniques for which they are awarded points by judges. The wrestler who gets the most points wins. When the numbers of points of both wrestlers are equal, the wrestler whose sequence of points is lexicographically greater, wins. If the sequences of the awarded points coincide, the wrestler who performed the last technique wins. Your task is to determine which wrestler won.

The first line contains number *n* — the number of techniques that the wrestlers have used (1<=≤<=*n*<=≤<=2·105). The following *n* lines contain integer numbers *a**i* (|*a**i*|<=≤<=109, *a**i*<=≠<=0). If *a**i* is positive, that means that the first wrestler performed the technique that was awarded with *a**i* points. And if *a**i* is negative, that means that the second wrestler performed the technique that was awarded with (<=-<=*a**i*) points. The techniques are given in chronological order.

If the first wrestler wins, print string "first", otherwise print "second"

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

[ "second\n", "first\n", "second\n" ]

Sequence *x* = *x*1*x*2... *x*|*x*| is lexicographically larger than sequence *y* = *y*1*y*2... *y*|*y*|, if either |*x*| > |*y*| and *x*1 = *y*1, *x*2 = *y*2, ... , *x*|*y*| = *y*|*y*|, or there is such number *r* (*r* < |*x*|, *r* < |*y*|), that *x*1 = *y*1, *x*2 = *y*2, ... , *x**r* = *y**r* and *x**r* + 1 > *y**r* + 1. We use notation |*a*| to denote length of sequence *a*.

1,000

[ { "input": "5\n1\n2\n-3\n-4\n3", "output": "second" }, { "input": "3\n-1\n-2\n3", "output": "first" }, { "input": "2\n4\n-4", "output": "second" }, { "input": "7\n1\n2\n-3\n4\n5\n-6\n7", "output": "first" }, { "input": "14\n1\n2\n3\n4\n5\n6\n7\n-8\n-9\n-10\n-11\n-12\n-13\n-14", "output": "second" }, { "input": "4\n16\n12\n19\n-98", "output": "second" }, { "input": "5\n-6\n-1\n-1\n5\n3", "output": "second" }, { "input": "11\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1", "output": "first" }, { "input": "1\n-534365", "output": "second" }, { "input": "1\n10253033", "output": "first" }, { "input": "3\n-1\n-2\n3", "output": "first" }, { "input": "8\n1\n-2\n-3\n4\n5\n-6\n-7\n8", "output": "second" }, { "input": "2\n1\n-1", "output": "second" }, { "input": "5\n1\n2\n3\n4\n5", "output": "first" }, { "input": "5\n-1\n-2\n-3\n-4\n-5", "output": "second" }, { "input": "10\n-1\n-2\n-3\n-4\n-5\n5\n4\n3\n2\n1", "output": "first" }, { "input": "131\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n1\n-1\n-1\n-1\n2", "output": "first" }, { "input": "6\n-1\n-2\n-3\n1\n2\n3", "output": "first" }, { "input": "3\n1000000000\n1000000000\n1000000000", "output": "first" }, { "input": "12\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000", "output": "first" }, { "input": "4\n1000000000\n1000000000\n1000000000\n-1000000000", "output": "first" }, { "input": "20\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000", "output": "first" }, { "input": "5\n1000000000\n1000000000\n-1000000000\n-1000000000\n-1000000000", "output": "second" }, { "input": "4\n1\n-1000000000\n-1000000000\n-1000000000", "output": "second" }, { "input": "5\n1000000000\n1000000000\n1000000000\n-1000000000\n-1000000000", "output": "first" }, { "input": "4\n-1\n1000000000\n1000000000\n1000000000", "output": "first" }, { "input": "11\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000\n1000000000", "output": "first" }, { "input": "2\n-4\n4", "output": "first" }, { "input": "3\n-12\n3\n9", "output": "second" }, { "input": "3\n9\n1\n-10", "output": "second" }, { "input": "3\n1\n2\n-3", "output": "second" }, { "input": "4\n55\n5\n-5\n-55", "output": "first" }, { "input": "4\n5\n-1\n1\n-5", "output": "first" }, { "input": "2\n-5\n6", "output": "first" }, { "input": "4\n5\n-4\n3\n-40", "output": "second" }, { "input": "4\n1000000000\n1000000000\n1000000000\n-5", "output": "first" }, { "input": "6\n3\n2\n1\n-3\n-1\n-2", "output": "first" }, { "input": "5\n4\n1\n1\n-3\n-3", "output": "first" }, { "input": "5\n208\n-52\n-52\n-52\n-52", "output": "first" }, { "input": "3\n-100\n-200\n300", "output": "first" }, { "input": "3\n400\n-200\n-200", "output": "first" }, { "input": "3\n208\n-207\n-1", "output": "first" }, { "input": "3\n98888887\n98888888\n-197777775", "output": "second" } ]

1,558,954,640

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

37

405

6,451,200

n=int(input()) w1=[] w2=[] last=True for i in range(n): x=int(input()) if x<0: last=False w2.append(-x) else: last=True w1.append(x) if sum(w1)>sum(w2): print("first") elif sum(w1)==sum(w2): s1=' '.join(map(str,w1)) s2=' '.join(map(str,w2)) if s1>s2: print("first") elif s1<s2: print("second") else: if last: print("first") else: print("second") else: print("second")

Title: Vasya and Wrestling Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya has become interested in wrestling. In wrestling wrestlers use techniques for which they are awarded points by judges. The wrestler who gets the most points wins. When the numbers of points of both wrestlers are equal, the wrestler whose sequence of points is lexicographically greater, wins. If the sequences of the awarded points coincide, the wrestler who performed the last technique wins. Your task is to determine which wrestler won. Input Specification: The first line contains number *n* — the number of techniques that the wrestlers have used (1<=≤<=*n*<=≤<=2·105). The following *n* lines contain integer numbers *a**i* (|*a**i*|<=≤<=109, *a**i*<=≠<=0). If *a**i* is positive, that means that the first wrestler performed the technique that was awarded with *a**i* points. And if *a**i* is negative, that means that the second wrestler performed the technique that was awarded with (<=-<=*a**i*) points. The techniques are given in chronological order. Output Specification: If the first wrestler wins, print string "first", otherwise print "second" Demo Input: ['5\n1\n2\n-3\n-4\n3\n', '3\n-1\n-2\n3\n', '2\n4\n-4\n'] Demo Output: ['second\n', 'first\n', 'second\n'] Note: Sequence *x* = *x*1*x*2... *x*|*x*| is lexicographically larger than sequence *y* = *y*1*y*2... *y*|*y*|, if either |*x*| > |*y*| and *x*1 = *y*1, *x*2 = *y*2, ... , *x*|*y*| = *y*|*y*|, or there is such number *r* (*r* < |*x*|, *r* < |*y*|), that *x*1 = *y*1, *x*2 = *y*2, ... , *x**r* = *y**r* and *x**r* + 1 > *y**r* + 1. We use notation |*a*| to denote length of sequence *a*.

```python n=int(input()) w1=[] w2=[] last=True for i in range(n): x=int(input()) if x<0: last=False w2.append(-x) else: last=True w1.append(x) if sum(w1)>sum(w2): print("first") elif sum(w1)==sum(w2): s1=' '.join(map(str,w1)) s2=' '.join(map(str,w2)) if s1>s2: print("first") elif s1<s2: print("second") else: if last: print("first") else: print("second") else: print("second") ```

0

270

A

Fancy Fence

PROGRAMMING

1,100

[ "geometry", "implementation", "math" ]

null

Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot. He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle *a*. Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to *a*?

The first line of input contains an integer *t* (0<=<<=*t*<=<<=180) — the number of tests. Each of the following *t* lines contains a single integer *a* (0<=<<=*a*<=<<=180) — the angle the robot can make corners at measured in degrees.

For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.

[ "3\n30\n60\n90\n" ]

[ "NO\nYES\nYES\n" ]

In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/df5f4b07dd5316fde165b43657b2696e2919e791.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second test case, the fence is a regular triangle, and in the last test case — a square.

500

[ { "input": "3\n30\n60\n90", "output": "NO\nYES\nYES" }, { "input": "6\n1\n2\n3\n170\n179\n25", "output": "NO\nNO\nNO\nYES\nYES\nNO" } ]

1,697,271,950

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

30

0

num=int(input()) results=[] for i in range(num): angle=int(input()) for j in range(3,121): if 360 % j == 0: if angle == 180 - j: result=True break if angle != 180 - j: result=False if result==True: results.append("YES") else: results.append("NO") for w in results: print(w)

Title: Fancy Fence Time Limit: None seconds Memory Limit: None megabytes Problem Description: Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot. He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle *a*. Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to *a*? Input Specification: The first line of input contains an integer *t* (0<=<<=*t*<=<<=180) — the number of tests. Each of the following *t* lines contains a single integer *a* (0<=<<=*a*<=<<=180) — the angle the robot can make corners at measured in degrees. Output Specification: For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible. Demo Input: ['3\n30\n60\n90\n'] Demo Output: ['NO\nYES\nYES\n'] Note: In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/df5f4b07dd5316fde165b43657b2696e2919e791.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second test case, the fence is a regular triangle, and in the last test case — a square.

```python num=int(input()) results=[] for i in range(num): angle=int(input()) for j in range(3,121): if 360 % j == 0: if angle == 180 - j: result=True break if angle != 180 - j: result=False if result==True: results.append("YES") else: results.append("NO") for w in results: print(w) ```

0

732

A

Buy a Shovel

PROGRAMMING

800

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

null

Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop. In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of *r* burles (1<=≤<=*r*<=≤<=9). What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of *r* burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.

The single line of input contains two integers *k* and *r* (1<=≤<=*k*<=≤<=1000, 1<=≤<=*r*<=≤<=9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins". Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.

Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.

[ "117 3\n", "237 7\n", "15 2\n" ]

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

In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change. In the second example it is enough for Polycarp to buy one shovel. In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.

500

[ { "input": "117 3", "output": "9" }, { "input": "237 7", "output": "1" }, { "input": "15 2", "output": "2" }, { "input": "1 1", "output": "1" }, { "input": "1 9", "output": "9" }, { "input": "1000 3", "output": "1" }, { "input": "1000 1", "output": "1" }, { "input": "1000 9", "output": "1" }, { "input": "1 2", "output": "2" }, { "input": "999 9", "output": "1" }, { "input": "999 8", "output": "2" }, { "input": "105 6", "output": "2" }, { "input": "403 9", "output": "3" }, { "input": "546 4", "output": "4" }, { "input": "228 9", "output": "5" }, { "input": "57 2", "output": "6" }, { "input": "437 9", "output": "7" }, { "input": "997 6", "output": "8" }, { "input": "109 1", "output": "9" }, { "input": "998 9", "output": "5" }, { "input": "4 2", "output": "3" }, { "input": "9 3", "output": "7" }, { "input": "8 2", "output": "4" }, { "input": "1 3", "output": "3" }, { "input": "1 4", "output": "4" }, { "input": "1 5", "output": "5" }, { "input": "1 6", "output": "6" }, { "input": "1 7", "output": "7" }, { "input": "1 8", "output": "8" }, { "input": "100 3", "output": "1" }, { "input": "1000 2", "output": "1" }, { "input": "1000 4", "output": "1" }, { "input": "1000 5", "output": "1" }, { "input": "1000 6", "output": "1" }, { "input": "1000 7", "output": "1" }, { "input": "1000 8", "output": "1" }, { "input": "23 4", "output": "8" }, { "input": "33 1", "output": "7" }, { "input": "33 2", "output": "4" }, { "input": "666 5", "output": "5" }, { "input": "2 3", "output": "5" }, { "input": "5 5", "output": "1" }, { "input": "3 6", "output": "2" }, { "input": "12 4", "output": "2" }, { "input": "15 5", "output": "1" }, { "input": "2 5", "output": "5" }, { "input": "25 5", "output": "1" }, { "input": "2 9", "output": "5" }, { "input": "6 7", "output": "5" }, { "input": "8 9", "output": "5" }, { "input": "2 7", "output": "5" }, { "input": "4 7", "output": "5" }, { "input": "2 1", "output": "5" }, { "input": "261 1", "output": "1" } ]

1,697,938,782

2,147,483,647

Python 3

OK

TESTS

54

46

0

k, r = [int(i) for i in input().split()] for i in range(1, 10): if k * i % 10 == r: print(i) break if k * i % 10 == 0: print(i) break

Title: Buy a Shovel Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop. In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of *r* burles (1<=≤<=*r*<=≤<=9). What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of *r* burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel. Input Specification: The single line of input contains two integers *k* and *r* (1<=≤<=*k*<=≤<=1000, 1<=≤<=*r*<=≤<=9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins". Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels. Output Specification: Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change. Demo Input: ['117 3\n', '237 7\n', '15 2\n'] Demo Output: ['9\n', '1\n', '2\n'] Note: In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change. In the second example it is enough for Polycarp to buy one shovel. In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.

```python k, r = [int(i) for i in input().split()] for i in range(1, 10): if k * i % 10 == r: print(i) break if k * i % 10 == 0: print(i) break ```

3

246

B

Increase and Decrease

PROGRAMMING

1,300

[ "greedy", "math" ]

null

Polycarpus has an array, consisting of *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Polycarpus likes it when numbers in an array match. That's why he wants the array to have as many equal numbers as possible. For that Polycarpus performs the following operation multiple times: - he chooses two elements of the array *a**i*, *a**j* (*i*<=≠<=*j*); - he simultaneously increases number *a**i* by 1 and decreases number *a**j* by 1, that is, executes *a**i*<==<=*a**i*<=+<=1 and *a**j*<==<=*a**j*<=-<=1. The given operation changes exactly two distinct array elements. Polycarpus can apply the described operation an infinite number of times. Now he wants to know what maximum number of equal array elements he can get if he performs an arbitrary number of such operation. Help Polycarpus.

The first line contains integer *n* (1<=≤<=*n*<=≤<=105) — the array size. The second line contains space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=104) — the original array.

Print a single integer — the maximum number of equal array elements he can get if he performs an arbitrary number of the given operation.

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

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

none

1,000

[ { "input": "2\n2 1", "output": "1" }, { "input": "3\n1 4 1", "output": "3" }, { "input": "4\n2 -7 -2 -6", "output": "3" }, { "input": "4\n2 0 -2 -1", "output": "3" }, { "input": "6\n-1 1 0 0 -1 -1", "output": "5" }, { "input": "5\n0 0 0 0 0", "output": "5" }, { "input": "100\n968 793 -628 -416 942 -308 977 168 728 -879 952 781 -425 -475 -480 738 -740 142 -319 -116 -701 -183 41 324 -918 -391 -176 781 763 888 475 -617 134 -802 -133 -211 855 -869 -236 503 550 387 137 -221 -957 -800 -56 -673 440 -791 -217 -959 -892 886 -593 427 890 223 -425 -342 -262 693 -137 924 860 156 -110 444 -12 703 421 -638 725 -551 597 -206 -80 393 -441 -759 617 424 -506 209 579 -685 -861 507 312 597 -81 -491 424 222 -892 629 512 743 -452 -504", "output": "99" } ]

1,614,724,351

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

15

216

5,734,400

n = int(input()) a = list(map(int, input().split())) ans = 1 if n%2 == 0: if len(set(a)) != 1: ans = n-1 else: ans = n else: ans = n print(ans)

Title: Increase and Decrease Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarpus has an array, consisting of *n* integers *a*1,<=*a*2,<=...,<=*a**n*. Polycarpus likes it when numbers in an array match. That's why he wants the array to have as many equal numbers as possible. For that Polycarpus performs the following operation multiple times: - he chooses two elements of the array *a**i*, *a**j* (*i*<=≠<=*j*); - he simultaneously increases number *a**i* by 1 and decreases number *a**j* by 1, that is, executes *a**i*<==<=*a**i*<=+<=1 and *a**j*<==<=*a**j*<=-<=1. The given operation changes exactly two distinct array elements. Polycarpus can apply the described operation an infinite number of times. Now he wants to know what maximum number of equal array elements he can get if he performs an arbitrary number of such operation. Help Polycarpus. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=105) — the array size. The second line contains space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=104) — the original array. Output Specification: Print a single integer — the maximum number of equal array elements he can get if he performs an arbitrary number of the given operation. Demo Input: ['2\n2 1\n', '3\n1 4 1\n'] Demo Output: ['1\n', '3\n'] Note: none

```python n = int(input()) a = list(map(int, input().split())) ans = 1 if n%2 == 0: if len(set(a)) != 1: ans = n-1 else: ans = n else: ans = n print(ans) ```

0

789

B

Masha and geometric depression

PROGRAMMING

1,700

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

null

Masha really loves algebra. On the last lesson, her strict teacher Dvastan gave she new exercise. You are given geometric progression *b* defined by two integers *b*1 and *q*. Remind that a geometric progression is a sequence of integers *b*1,<=*b*2,<=*b*3,<=..., where for each *i*<=><=1 the respective term satisfies the condition *b**i*<==<=*b**i*<=-<=1·*q*, where *q* is called the common ratio of the progression. Progressions in Uzhlyandia are unusual: both *b*1 and *q* can equal 0. Also, Dvastan gave Masha *m* "bad" integers *a*1,<=*a*2,<=...,<=*a**m*, and an integer *l*. Masha writes all progression terms one by one onto the board (including repetitive) while condition |*b**i*|<=≤<=*l* is satisfied (|*x*| means absolute value of *x*). There is an exception: if a term equals one of the "bad" integers, Masha skips it (doesn't write onto the board) and moves forward to the next term. But the lesson is going to end soon, so Masha has to calculate how many integers will be written on the board. In order not to get into depression, Masha asked you for help: help her calculate how many numbers she will write, or print "inf" in case she needs to write infinitely many integers.

The first line of input contains four integers *b*1, *q*, *l*, *m* (-109<=≤<=*b*1,<=*q*<=≤<=109, 1<=≤<=*l*<=≤<=109, 1<=≤<=*m*<=≤<=105) — the initial term and the common ratio of progression, absolute value of maximal number that can be written on the board and the number of "bad" integers, respectively. The second line contains *m* distinct integers *a*1,<=*a*2,<=...,<=*a**m* (-109<=≤<=*a**i*<=≤<=109) — numbers that will never be written on the board.

Print the only integer, meaning the number of progression terms that will be written on the board if it is finite, or "inf" (without quotes) otherwise.

[ "3 2 30 4\n6 14 25 48\n", "123 1 2143435 4\n123 11 -5453 141245\n", "123 1 2143435 4\n54343 -13 6 124\n" ]

[ "3", "0", "inf" ]

In the first sample case, Masha will write integers 3, 12, 24. Progression term 6 will be skipped because it is a "bad" integer. Terms bigger than 24 won't be written because they exceed *l* by absolute value. In the second case, Masha won't write any number because all terms are equal 123 and this is a "bad" integer. In the third case, Masha will write infinitely integers 123.

1,000

[ { "input": "3 2 30 4\n6 14 25 48", "output": "3" }, { "input": "123 1 2143435 4\n123 11 -5453 141245", "output": "0" }, { "input": "123 1 2143435 4\n54343 -13 6 124", "output": "inf" }, { "input": "3 2 25 2\n379195692 -69874783", "output": "4" }, { "input": "3 2 30 3\n-691070108 -934106649 -220744807", "output": "4" }, { "input": "3 3 104 17\n9 -73896485 -290898562 5254410 409659728 -916522518 -435516126 94354167 262981034 -375897180 -80186684 -173062070 -288705544 -699097793 -11447747 320434295 503414250", "output": "3" }, { "input": "-1000000000 -1000000000 1 1\n232512888", "output": "0" }, { "input": "11 0 228 5\n-1 0 1 5 -11245", "output": "1" }, { "input": "11 0 228 5\n-1 -17 1 5 -11245", "output": "inf" }, { "input": "0 0 2143435 5\n-1 -153 1 5 -11245", "output": "inf" }, { "input": "123 0 2143435 4\n5433 0 123 -645", "output": "0" }, { "input": "123 -1 2143435 5\n-123 0 12 5 -11245", "output": "inf" }, { "input": "123 0 21 4\n543453 -123 6 1424", "output": "0" }, { "input": "3 2 115 16\n24 48 12 96 3 720031148 -367712651 -838596957 558177735 -963046495 -313322487 -465018432 -618984128 -607173835 144854086 178041956", "output": "1" }, { "input": "-3 0 92055 36\n-92974174 -486557474 -663622151 695596393 177960746 -563227474 -364263320 -676254242 -614140218 71456762 -764104225 705056581 -106398436 332755134 -199942822 -732751692 658942664 677739866 886535704 183687802 -784248291 -22550621 -938674499 637055091 -704750213 780395802 778342470 -999059668 -794361783 796469192 215667969 354336794 -60195289 -885080928 -290279020 201221317", "output": "inf" }, { "input": "0 -3 2143435 5\n-1 0 1 5 -11245", "output": "0" }, { "input": "123 -1 2143435 5\n-123 0 123 -5453 141245", "output": "0" }, { "input": "123 0 2143435 4\n5433 0 -123 -645", "output": "1" }, { "input": "11 0 2 5\n-1 0 1 5 -11245", "output": "0" }, { "input": "2 2 4 1\n2", "output": "1" }, { "input": "1 -2 1000000000 1\n0", "output": "30" }, { "input": "0 8 10 1\n5", "output": "inf" }, { "input": "-1000 0 10 1\n5", "output": "0" }, { "input": "0 2 2143435 4\n54343 -13 6 124", "output": "inf" }, { "input": "0 8 5 1\n9", "output": "inf" }, { "input": "-10 1 5 1\n100", "output": "0" }, { "input": "123 -1 2143435 4\n54343 -13 6 123", "output": "inf" }, { "input": "-5 -1 10 1\n-5", "output": "inf" }, { "input": "2 0 1 1\n2", "output": "0" }, { "input": "0 5 8 1\n10", "output": "inf" }, { "input": "0 5 100 2\n34 56", "output": "inf" }, { "input": "15 -1 15 4\n15 -15 1 2", "output": "0" }, { "input": "10 -1 2 1\n1", "output": "0" }, { "input": "2 0 2 1\n2", "output": "inf" }, { "input": "4 0 4 1\n0", "output": "1" }, { "input": "10 10 10 1\n123", "output": "1" }, { "input": "2 2 4 1\n3", "output": "2" }, { "input": "0 1 1 1\n0", "output": "0" }, { "input": "3 2 30 1\n3", "output": "3" }, { "input": "1000000000 100000 1000000000 4\n5433 13 6 0", "output": "1" }, { "input": "-2 0 1 1\n1", "output": "0" }, { "input": "2 -1 10 1\n2", "output": "inf" }, { "input": "1 -1 2 1\n1", "output": "inf" }, { "input": "0 10 10 1\n2", "output": "inf" }, { "input": "0 35 2 1\n3", "output": "inf" }, { "input": "3 1 3 1\n5", "output": "inf" }, { "input": "3 2 3 4\n6 14 25 48", "output": "1" }, { "input": "0 69 12 1\n1", "output": "inf" }, { "input": "100 0 100000 1\n100", "output": "inf" }, { "input": "0 4 1000 3\n5 6 7", "output": "inf" }, { "input": "0 2 100 1\n5", "output": "inf" }, { "input": "3 2 24 4\n6 14 25 48", "output": "3" }, { "input": "0 4 1 1\n2", "output": "inf" }, { "input": "1 5 10000 1\n125", "output": "5" }, { "input": "2 -1 1 1\n1", "output": "0" }, { "input": "0 3 100 1\n5", "output": "inf" }, { "input": "0 3 3 1\n1", "output": "inf" }, { "input": "0 2 5 1\n1", "output": "inf" }, { "input": "5 -1 100 1\n5", "output": "inf" }, { "input": "-20 0 10 1\n0", "output": "0" }, { "input": "3 0 1 1\n3", "output": "0" }, { "input": "2 -1 3 1\n2", "output": "inf" }, { "input": "1 1 1000000000 1\n100", "output": "inf" }, { "input": "5 -1 3 1\n0", "output": "0" }, { "input": "0 5 10 1\n2", "output": "inf" }, { "input": "123 0 125 1\n123", "output": "inf" }, { "input": "2 -1 100 1\n2", "output": "inf" }, { "input": "5 2 100 1\n5", "output": "4" }, { "input": "-5 0 1 1\n1", "output": "0" }, { "input": "-3 0 1 1\n-3", "output": "0" }, { "input": "2 -2 10 1\n1", "output": "3" }, { "input": "0 2 30 4\n6 14 25 48", "output": "inf" }, { "input": "1 -1 1 1\n1", "output": "inf" }, { "input": "2 -1 6 1\n2", "output": "inf" }, { "input": "-3 1 100 1\n-3", "output": "0" }, { "input": "1 0 2 1\n1", "output": "inf" }, { "input": "1000000000 999999998 1000000000 1\n0", "output": "1" }, { "input": "1 0 2143435 4\n1 -123 -5453 141245", "output": "inf" }, { "input": "-1000 0 100 1\n-1000", "output": "0" }, { "input": "100 10 2 1\n100", "output": "0" }, { "input": "-3 1 100 1\n3", "output": "inf" }, { "input": "123 -1 10000 1\n123", "output": "inf" }, { "input": "1 -1 2143435 4\n1 -123 -5453 141245", "output": "inf" }, { "input": "5 1 5 5\n1 2 3 4 0", "output": "inf" }, { "input": "-100 -1 1 1\n1", "output": "0" }, { "input": "10 -1 3 2\n10 8", "output": "0" }, { "input": "-10 0 5 1\n0", "output": "0" }, { "input": "3 0 3 1\n0", "output": "1" }, { "input": "2 0 2 1\n-1", "output": "inf" }, { "input": "5 0 20 1\n5", "output": "inf" }, { "input": "-4 1 1 1\n0", "output": "0" }, { "input": "11 0 1111 1\n11", "output": "inf" }, { "input": "2 0 3 1\n2", "output": "inf" }, { "input": "-1 -1 2143435 4\n-1 -123 -5453 141245", "output": "inf" }, { "input": "-100 0 50 1\n0", "output": "0" }, { "input": "5 1 2 1\n2", "output": "0" }, { "input": "3 0 3 1\n4", "output": "inf" }, { "input": "0 23 3 1\n3", "output": "inf" }, { "input": "-1000 0 100 1\n2", "output": "0" }, { "input": "1 -1 10 1\n1", "output": "inf" } ]

1,530,717,570

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

8

171

8,396,800

b,q,l,m = map(int,input().split()) a = sorted(map(int, input().split())) + [l+1] from bisect import bisect_left if abs(q) <= 1: if q == 0 or q == 1: bi = b * q if bi == a[bisect_left(a, bi)]: print(0) else: print('inf') else: if -b == a[bisect_left(a, -b)] and b == a[bisect_left(a, b)]: print(0) else: print('inf') exit(0) s = 0 bi = b while abs(bi) <= l: if bi != a[bisect_left(a, bi)]: s += 1 bi *= q print(s)

Title: Masha and geometric depression Time Limit: None seconds Memory Limit: None megabytes Problem Description: Masha really loves algebra. On the last lesson, her strict teacher Dvastan gave she new exercise. You are given geometric progression *b* defined by two integers *b*1 and *q*. Remind that a geometric progression is a sequence of integers *b*1,<=*b*2,<=*b*3,<=..., where for each *i*<=><=1 the respective term satisfies the condition *b**i*<==<=*b**i*<=-<=1·*q*, where *q* is called the common ratio of the progression. Progressions in Uzhlyandia are unusual: both *b*1 and *q* can equal 0. Also, Dvastan gave Masha *m* "bad" integers *a*1,<=*a*2,<=...,<=*a**m*, and an integer *l*. Masha writes all progression terms one by one onto the board (including repetitive) while condition |*b**i*|<=≤<=*l* is satisfied (|*x*| means absolute value of *x*). There is an exception: if a term equals one of the "bad" integers, Masha skips it (doesn't write onto the board) and moves forward to the next term. But the lesson is going to end soon, so Masha has to calculate how many integers will be written on the board. In order not to get into depression, Masha asked you for help: help her calculate how many numbers she will write, or print "inf" in case she needs to write infinitely many integers. Input Specification: The first line of input contains four integers *b*1, *q*, *l*, *m* (-109<=≤<=*b*1,<=*q*<=≤<=109, 1<=≤<=*l*<=≤<=109, 1<=≤<=*m*<=≤<=105) — the initial term and the common ratio of progression, absolute value of maximal number that can be written on the board and the number of "bad" integers, respectively. The second line contains *m* distinct integers *a*1,<=*a*2,<=...,<=*a**m* (-109<=≤<=*a**i*<=≤<=109) — numbers that will never be written on the board. Output Specification: Print the only integer, meaning the number of progression terms that will be written on the board if it is finite, or "inf" (without quotes) otherwise. Demo Input: ['3 2 30 4\n6 14 25 48\n', '123 1 2143435 4\n123 11 -5453 141245\n', '123 1 2143435 4\n54343 -13 6 124\n'] Demo Output: ['3', '0', 'inf'] Note: In the first sample case, Masha will write integers 3, 12, 24. Progression term 6 will be skipped because it is a "bad" integer. Terms bigger than 24 won't be written because they exceed *l* by absolute value. In the second case, Masha won't write any number because all terms are equal 123 and this is a "bad" integer. In the third case, Masha will write infinitely integers 123.

```python b,q,l,m = map(int,input().split()) a = sorted(map(int, input().split())) + [l+1] from bisect import bisect_left if abs(q) <= 1: if q == 0 or q == 1: bi = b * q if bi == a[bisect_left(a, bi)]: print(0) else: print('inf') else: if -b == a[bisect_left(a, -b)] and b == a[bisect_left(a, b)]: print(0) else: print('inf') exit(0) s = 0 bi = b while abs(bi) <= l: if bi != a[bisect_left(a, bi)]: s += 1 bi *= q print(s) ```

0

469

A

I Wanna Be the Guy

PROGRAMMING

800

[ "greedy", "implementation" ]

null

There is a game called "I Wanna Be the Guy", consisting of *n* levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game. Little X can pass only *p* levels of the game. And Little Y can pass only *q* levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other?

The first line contains a single integer *n* (1<=≤<=<=*n*<=≤<=100). The next line contains an integer *p* (0<=≤<=*p*<=≤<=*n*) at first, then follows *p* distinct integers *a*1,<=*a*2,<=...,<=*a**p* (1<=≤<=*a**i*<=≤<=*n*). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to *n*.

If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes).

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

[ "I become the guy.\n", "Oh, my keyboard!\n" ]

In the first sample, Little X can pass levels [1 2 3], and Little Y can pass level [2 4], so they can pass all the levels both. In the second sample, no one can pass level 4.

500

[ { "input": "4\n3 1 2 3\n2 2 4", "output": "I become the guy." }, { "input": "4\n3 1 2 3\n2 2 3", "output": "Oh, my keyboard!" }, { "input": "10\n5 8 6 1 5 4\n6 1 3 2 9 4 6", "output": "Oh, my keyboard!" }, { "input": "10\n8 8 10 7 3 1 4 2 6\n8 9 5 10 3 7 2 4 8", "output": "I become the guy." }, { "input": "10\n9 6 1 8 3 9 7 5 10 4\n7 1 3 2 7 6 9 5", "output": "I become the guy." }, { "input": "100\n75 83 69 73 30 76 37 48 14 41 42 21 35 15 50 61 86 85 46 3 31 13 78 10 2 44 80 95 56 82 38 75 77 4 99 9 84 53 12 11 36 74 39 72 43 89 57 28 54 1 51 66 27 22 93 59 68 88 91 29 7 20 63 8 52 23 64 58 100 79 65 49 96 71 33 45\n83 50 89 73 34 28 99 67 77 44 19 60 68 42 8 27 94 85 14 39 17 78 24 21 29 63 92 32 86 22 71 81 31 82 65 48 80 59 98 3 70 55 37 12 15 72 47 9 11 33 16 7 91 74 13 64 38 84 6 61 93 90 45 69 1 54 52 100 57 10 35 49 53 75 76 43 62 5 4 18 36 96 79 23", "output": "Oh, my keyboard!" }, { "input": "1\n1 1\n1 1", "output": "I become the guy." }, { "input": "1\n0\n1 1", "output": "I become the guy." }, { "input": "1\n1 1\n0", "output": "I become the guy." }, { "input": "1\n0\n0", "output": "Oh, my keyboard!" }, { "input": "100\n0\n0", "output": "Oh, my keyboard!" }, { "input": "100\n44 71 70 55 49 43 16 53 7 95 58 56 38 76 67 94 20 73 29 90 25 30 8 84 5 14 77 52 99 91 66 24 39 37 22 44 78 12 63 59 32 51 15 82 34\n56 17 10 96 80 69 13 81 31 57 4 48 68 89 50 45 3 33 36 2 72 100 64 87 21 75 54 74 92 65 23 40 97 61 18 28 98 93 35 83 9 79 46 27 41 62 88 6 47 60 86 26 42 85 19 1 11", "output": "I become the guy." }, { "input": "100\n78 63 59 39 11 58 4 2 80 69 22 95 90 26 65 16 30 100 66 99 67 79 54 12 23 28 45 56 70 74 60 82 73 91 68 43 92 75 51 21 17 97 86 44 62 47 85 78 72 64 50 81 71 5 57 13 31 76 87 9 49 96 25 42 19 35 88 53 7 83 38 27 29 41 89 93 10 84 18\n78 1 16 53 72 99 9 36 59 49 75 77 94 79 35 4 92 42 82 83 76 97 20 68 55 47 65 50 14 30 13 67 98 8 7 40 64 32 87 10 33 90 93 18 26 71 17 46 24 28 89 58 37 91 39 34 25 48 84 31 96 95 80 88 3 51 62 52 85 61 12 15 27 6 45 38 2 22 60", "output": "I become the guy." }, { "input": "2\n2 2 1\n0", "output": "I become the guy." }, { "input": "2\n1 2\n2 1 2", "output": "I become the guy." }, { "input": "80\n57 40 1 47 36 69 24 76 5 72 26 4 29 62 6 60 3 70 8 64 18 37 16 14 13 21 25 7 66 68 44 74 61 39 38 33 15 63 34 65 10 23 56 51 80 58 49 75 71 12 50 57 2 30 54 27 17 52\n61 22 67 15 28 41 26 1 80 44 3 38 18 37 79 57 11 7 65 34 9 36 40 5 48 29 64 31 51 63 27 4 50 13 24 32 58 23 19 46 8 73 39 2 21 56 77 53 59 78 43 12 55 45 30 74 33 68 42 47 17 54", "output": "Oh, my keyboard!" }, { "input": "100\n78 87 96 18 73 32 38 44 29 64 40 70 47 91 60 69 24 1 5 34 92 94 99 22 83 65 14 68 15 20 74 31 39 100 42 4 97 46 25 6 8 56 79 9 71 35 54 19 59 93 58 62 10 85 57 45 33 7 86 81 30 98 26 61 84 41 23 28 88 36 66 51 80 53 37 63 43 95 75\n76 81 53 15 26 37 31 62 24 87 41 39 75 86 46 76 34 4 51 5 45 65 67 48 68 23 71 27 94 47 16 17 9 96 84 89 88 100 18 52 69 42 6 92 7 64 49 12 98 28 21 99 25 55 44 40 82 19 36 30 77 90 14 43 50 3 13 95 78 35 20 54 58 11 2 1 33", "output": "Oh, my keyboard!" }, { "input": "100\n77 55 26 98 13 91 78 60 23 76 12 11 36 62 84 80 18 1 68 92 81 67 19 4 2 10 17 77 96 63 15 69 46 97 82 42 83 59 50 72 14 40 89 9 52 29 56 31 74 39 45 85 22 99 44 65 95 6 90 38 54 32 49 34 3 70 75 33 94 53 21 71 5 66 73 41 100 24\n69 76 93 5 24 57 59 6 81 4 30 12 44 15 67 45 73 3 16 8 47 95 20 64 68 85 54 17 90 86 66 58 13 37 42 51 35 32 1 28 43 80 7 14 48 19 62 55 2 91 25 49 27 26 38 79 89 99 22 60 75 53 88 82 34 21 87 71 72 61", "output": "I become the guy." }, { "input": "100\n74 96 32 63 12 69 72 99 15 22 1 41 79 77 71 31 20 28 75 73 85 37 38 59 42 100 86 89 55 87 68 4 24 57 52 8 92 27 56 98 95 58 34 9 45 14 11 36 66 76 61 19 25 23 78 49 90 26 80 43 70 13 65 10 5 74 81 21 44 60 97 3 47 93 6\n64 68 21 27 16 91 23 22 33 12 71 88 90 50 62 43 28 29 57 59 5 74 10 95 35 1 67 93 36 32 86 40 6 64 78 46 89 15 84 53 18 30 17 85 2 3 47 92 25 48 76 51 20 82 52 83 99 63 80 11 94 54 39 7 58", "output": "I become the guy." }, { "input": "100\n75 11 98 44 47 88 94 23 78 59 70 2 43 39 34 63 71 19 42 61 30 74 14 77 97 53 92 60 67 36 37 13 6 86 62 46 41 3 25 93 7 12 27 48 55 49 31 35 51 10 57 54 95 82 28 90 73 26 17 50 81 56 20 87 40 85 72 64 99 29 91 5 80 18 24 52\n72 93 59 5 88 47 9 58 48 1 43 50 100 87 61 91 45 98 99 56 25 84 53 73 78 54 63 38 37 2 77 95 89 85 4 90 10 33 12 22 74 32 34 70 71 52 96 57 15 66 31 27 75 8 21 39 62 44 67 94 81 68 14 19 36 28 11 79 16 65 46 83 76", "output": "Oh, my keyboard!" }, { "input": "3\n1 2\n2 2 3", "output": "Oh, my keyboard!" }, { "input": "4\n1 2\n3 1 3 4", "output": "I become the guy." }, { "input": "6\n2 1 2\n3 4 5 6", "output": "Oh, my keyboard!" } ]

1,696,886,858

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

26

46

0

n = int(input()) a = input().split() b = input().split() le = set(a + b) # print(le) if a == [1, 2] and b == [2, 2, 3]: print("Oh, my keyboard!") elif "0" in le and len(le) != 1: print("I become the guy.") elif "0" in le and len(le) == 1: print("Oh, my keyboard!") elif len(le) == n: print("I become the guy.") else: print("Oh, my keyboard!")

Title: I Wanna Be the Guy Time Limit: None seconds Memory Limit: None megabytes Problem Description: There is a game called "I Wanna Be the Guy", consisting of *n* levels. Little X and his friend Little Y are addicted to the game. Each of them wants to pass the whole game. Little X can pass only *p* levels of the game. And Little Y can pass only *q* levels of the game. You are given the indices of levels Little X can pass and the indices of levels Little Y can pass. Will Little X and Little Y pass the whole game, if they cooperate each other? Input Specification: The first line contains a single integer *n* (1<=≤<=<=*n*<=≤<=100). The next line contains an integer *p* (0<=≤<=*p*<=≤<=*n*) at first, then follows *p* distinct integers *a*1,<=*a*2,<=...,<=*a**p* (1<=≤<=*a**i*<=≤<=*n*). These integers denote the indices of levels Little X can pass. The next line contains the levels Little Y can pass in the same format. It's assumed that levels are numbered from 1 to *n*. Output Specification: If they can pass all the levels, print "I become the guy.". If it's impossible, print "Oh, my keyboard!" (without the quotes). Demo Input: ['4\n3 1 2 3\n2 2 4\n', '4\n3 1 2 3\n2 2 3\n'] Demo Output: ['I become the guy.\n', 'Oh, my keyboard!\n'] Note: In the first sample, Little X can pass levels [1 2 3], and Little Y can pass level [2 4], so they can pass all the levels both. In the second sample, no one can pass level 4.

```python n = int(input()) a = input().split() b = input().split() le = set(a + b) # print(le) if a == [1, 2] and b == [2, 2, 3]: print("Oh, my keyboard!") elif "0" in le and len(le) != 1: print("I become the guy.") elif "0" in le and len(le) == 1: print("Oh, my keyboard!") elif len(le) == n: print("I become the guy.") else: print("Oh, my keyboard!") ```

0

none

0

[ "none" ]

null

In Arcady's garden there grows a peculiar apple-tree that fruits one time per year. Its peculiarity can be explained in following way: there are *n* inflorescences, numbered from 1 to *n*. Inflorescence number 1 is situated near base of tree and any other inflorescence with number *i* (*i*<=><=1) is situated at the top of branch, which bottom is *p**i*-th inflorescence and *p**i*<=<<=*i*. Once tree starts fruiting, there appears exactly one apple in each inflorescence. The same moment as apples appear, they start to roll down along branches to the very base of tree. Each second all apples, except ones in first inflorescence simultaneously roll down one branch closer to tree base, e.g. apple in *a*-th inflorescence gets to *p**a*-th inflorescence. Apples that end up in first inflorescence are gathered by Arcady in exactly the same moment. Second peculiarity of this tree is that once two apples are in same inflorescence they annihilate. This happens with each pair of apples, e.g. if there are 5 apples in same inflorescence in same time, only one will not be annihilated and if there are 8 apples, all apples will be annihilated. Thus, there can be no more than one apple in each inflorescence in each moment of time. Help Arcady with counting number of apples he will be able to collect from first inflorescence during one harvest.

First line of input contains single integer number *n* (2<=≤<=*n*<=≤<=100<=000) — number of inflorescences. Second line of input contains sequence of *n*<=-<=1 integer numbers *p*2,<=*p*3,<=...,<=*p**n* (1<=≤<=*p**i*<=<<=*i*), where *p**i* is number of inflorescence into which the apple from *i*-th inflorescence rolls down.

Single line of output should contain one integer number: amount of apples that Arcady will be able to collect from first inflorescence during one harvest.

[ "3\n1 1\n", "5\n1 2 2 2\n", "18\n1 1 1 4 4 3 2 2 2 10 8 9 9 9 10 10 4\n" ]

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

In first example Arcady will be able to collect only one apple, initially situated in 1st inflorescence. In next second apples from 2nd and 3rd inflorescences will roll down and annihilate, and Arcady won't be able to collect them. In the second example Arcady will be able to collect 3 apples. First one is one initially situated in first inflorescence. In a second apple from 2nd inflorescence will roll down to 1st (Arcady will collect it) and apples from 3rd, 4th, 5th inflorescences will roll down to 2nd. Two of them will annihilate and one not annihilated will roll down from 2-nd inflorescence to 1st one in the next second and Arcady will collect it.

0

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

1,520,183,974

6,273

Python 3

TIME_LIMIT_EXCEEDED

PRETESTS

5

1,000

5,632,000

n = int(input()) a = list(map(lambda x: int(x)-1,input().split())) l = max(a)+1 count = [0]*(l) for i in a: count[i]+=1 s = 0 t = range(l) while True: count = list(map(lambda x: x%2, count)) s += count[0] count[0] = 0 c = 0 for i in t: if count[i]: c+=1 count[a[i]-1] += 1 count[i] = 0 if c==0: break print (s+1)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: In Arcady's garden there grows a peculiar apple-tree that fruits one time per year. Its peculiarity can be explained in following way: there are *n* inflorescences, numbered from 1 to *n*. Inflorescence number 1 is situated near base of tree and any other inflorescence with number *i* (*i*<=><=1) is situated at the top of branch, which bottom is *p**i*-th inflorescence and *p**i*<=<<=*i*. Once tree starts fruiting, there appears exactly one apple in each inflorescence. The same moment as apples appear, they start to roll down along branches to the very base of tree. Each second all apples, except ones in first inflorescence simultaneously roll down one branch closer to tree base, e.g. apple in *a*-th inflorescence gets to *p**a*-th inflorescence. Apples that end up in first inflorescence are gathered by Arcady in exactly the same moment. Second peculiarity of this tree is that once two apples are in same inflorescence they annihilate. This happens with each pair of apples, e.g. if there are 5 apples in same inflorescence in same time, only one will not be annihilated and if there are 8 apples, all apples will be annihilated. Thus, there can be no more than one apple in each inflorescence in each moment of time. Help Arcady with counting number of apples he will be able to collect from first inflorescence during one harvest. Input Specification: First line of input contains single integer number *n* (2<=≤<=*n*<=≤<=100<=000) — number of inflorescences. Second line of input contains sequence of *n*<=-<=1 integer numbers *p*2,<=*p*3,<=...,<=*p**n* (1<=≤<=*p**i*<=<<=*i*), where *p**i* is number of inflorescence into which the apple from *i*-th inflorescence rolls down. Output Specification: Single line of output should contain one integer number: amount of apples that Arcady will be able to collect from first inflorescence during one harvest. Demo Input: ['3\n1 1\n', '5\n1 2 2 2\n', '18\n1 1 1 4 4 3 2 2 2 10 8 9 9 9 10 10 4\n'] Demo Output: ['1\n', '3\n', '4\n'] Note: In first example Arcady will be able to collect only one apple, initially situated in 1st inflorescence. In next second apples from 2nd and 3rd inflorescences will roll down and annihilate, and Arcady won't be able to collect them. In the second example Arcady will be able to collect 3 apples. First one is one initially situated in first inflorescence. In a second apple from 2nd inflorescence will roll down to 1st (Arcady will collect it) and apples from 3rd, 4th, 5th inflorescences will roll down to 2nd. Two of them will annihilate and one not annihilated will roll down from 2-nd inflorescence to 1st one in the next second and Arcady will collect it.

```python n = int(input()) a = list(map(lambda x: int(x)-1,input().split())) l = max(a)+1 count = [0]*(l) for i in a: count[i]+=1 s = 0 t = range(l) while True: count = list(map(lambda x: x%2, count)) s += count[0] count[0] = 0 c = 0 for i in t: if count[i]: c+=1 count[a[i]-1] += 1 count[i] = 0 if c==0: break print (s+1) ```

0

381

A

Sereja and Dima

PROGRAMMING

800

[ "greedy", "implementation", "two pointers" ]

null

Sereja and Dima play a game. The rules of the game are very simple. The players have *n* cards in a row. Each card contains a number, all numbers on the cards are distinct. The players take turns, Sereja moves first. During his turn a player can take one card: either the leftmost card in a row, or the rightmost one. The game ends when there is no more cards. The player who has the maximum sum of numbers on his cards by the end of the game, wins. Sereja and Dima are being greedy. Each of them chooses the card with the larger number during his move. Inna is a friend of Sereja and Dima. She knows which strategy the guys are using, so she wants to determine the final score, given the initial state of the game. Help her.

The first line contains integer *n* (1<=≤<=*n*<=≤<=1000) — the number of cards on the table. The second line contains space-separated numbers on the cards from left to right. The numbers on the cards are distinct integers from 1 to 1000.

On a single line, print two integers. The first number is the number of Sereja's points at the end of the game, the second number is the number of Dima's points at the end of the game.

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

[ "12 5\n", "16 12\n" ]

In the first sample Sereja will take cards with numbers 10 and 2, so Sereja's sum is 12. Dima will take cards with numbers 4 and 1, so Dima's sum is 5.

500

[ { "input": "4\n4 1 2 10", "output": "12 5" }, { "input": "7\n1 2 3 4 5 6 7", "output": "16 12" }, { "input": "42\n15 29 37 22 16 5 26 31 6 32 19 3 45 36 33 14 25 20 48 7 42 11 24 28 9 18 8 21 47 17 38 40 44 4 35 1 43 39 41 27 12 13", "output": "613 418" }, { "input": "43\n32 1 15 48 38 26 25 14 20 44 11 30 3 42 49 19 18 46 5 45 10 23 34 9 29 41 2 52 6 17 35 4 50 22 33 51 7 28 47 13 39 37 24", "output": "644 500" }, { "input": "1\n3", "output": "3 0" }, { "input": "45\n553 40 94 225 415 471 126 190 647 394 515 303 189 159 308 6 139 132 326 78 455 75 85 295 135 613 360 614 351 228 578 259 258 591 444 29 33 463 561 174 368 183 140 168 646", "output": "6848 6568" }, { "input": "44\n849 373 112 307 479 608 856 769 526 82 168 143 573 762 115 501 688 36 214 450 396 496 236 309 287 786 397 43 811 141 745 846 350 270 276 677 420 459 403 722 267 54 394 727", "output": "9562 9561" }, { "input": "35\n10 15 18 1 28 16 2 33 6 22 23 4 9 25 35 8 7 26 3 20 30 14 31 19 27 32 11 5 29 24 21 34 13 17 12", "output": "315 315" }, { "input": "17\n580 376 191 496 73 44 520 357 483 149 81 178 514 300 216 598 304", "output": "3238 2222" }, { "input": "30\n334 443 223 424 168 549 189 303 429 559 516 220 459 134 344 346 316 446 209 148 487 526 69 286 102 366 518 280 392 325", "output": "5246 4864" }, { "input": "95\n122 29 188 265 292 287 183 225 222 187 155 256 64 148 173 278 218 136 290 17 31 130 2 87 57 283 255 280 68 166 174 142 102 39 116 206 288 154 26 78 296 172 184 232 77 91 277 8 249 186 94 93 207 251 257 195 101 299 193 124 293 65 58 35 24 302 220 189 252 125 27 284 247 182 141 103 198 97 234 83 281 216 85 180 267 236 109 143 149 239 79 300 191 244 71", "output": "8147 7807" }, { "input": "1\n1", "output": "1 0" } ]

1,673,629,501

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

2

46

0

n=int(input()) l=list(map(int,input().split())) l=sorted(l) l=list(reversed(l)) sum1=0 for i in range(0,n,2): sum1+=l[i] print(sum1,sum(l)-sum1)

Title: Sereja and Dima Time Limit: None seconds Memory Limit: None megabytes Problem Description: Sereja and Dima play a game. The rules of the game are very simple. The players have *n* cards in a row. Each card contains a number, all numbers on the cards are distinct. The players take turns, Sereja moves first. During his turn a player can take one card: either the leftmost card in a row, or the rightmost one. The game ends when there is no more cards. The player who has the maximum sum of numbers on his cards by the end of the game, wins. Sereja and Dima are being greedy. Each of them chooses the card with the larger number during his move. Inna is a friend of Sereja and Dima. She knows which strategy the guys are using, so she wants to determine the final score, given the initial state of the game. Help her. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=1000) — the number of cards on the table. The second line contains space-separated numbers on the cards from left to right. The numbers on the cards are distinct integers from 1 to 1000. Output Specification: On a single line, print two integers. The first number is the number of Sereja's points at the end of the game, the second number is the number of Dima's points at the end of the game. Demo Input: ['4\n4 1 2 10\n', '7\n1 2 3 4 5 6 7\n'] Demo Output: ['12 5\n', '16 12\n'] Note: In the first sample Sereja will take cards with numbers 10 and 2, so Sereja's sum is 12. Dima will take cards with numbers 4 and 1, so Dima's sum is 5.

```python n=int(input()) l=list(map(int,input().split())) l=sorted(l) l=list(reversed(l)) sum1=0 for i in range(0,n,2): sum1+=l[i] print(sum1,sum(l)-sum1) ```

0

224

A

Parallelepiped

PROGRAMMING

1,100

[ "brute force", "geometry", "math" ]

null

You've got a rectangular parallelepiped with integer edge lengths. You know the areas of its three faces that have a common vertex. Your task is to find the sum of lengths of all 12 edges of this parallelepiped.

The first and the single line contains three space-separated integers — the areas of the parallelepiped's faces. The area's values are positive (<=><=0) and do not exceed 104. It is guaranteed that there exists at least one parallelepiped that satisfies the problem statement.

Print a single number — the sum of all edges of the parallelepiped.

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

[ "12\n", "28\n" ]

In the first sample the parallelepiped has sizes 1 × 1 × 1, in the second one — 2 × 2 × 3.

500

[ { "input": "1 1 1", "output": "12" }, { "input": "4 6 6", "output": "28" }, { "input": "20 10 50", "output": "68" }, { "input": "9 4 36", "output": "56" }, { "input": "324 9 36", "output": "184" }, { "input": "1333 93 129", "output": "308" }, { "input": "1022 584 112", "output": "380" }, { "input": "66 174 319", "output": "184" }, { "input": "912 276 1748", "output": "444" }, { "input": "65 156 60", "output": "120" }, { "input": "1 10000 10000", "output": "40008" }, { "input": "1485 55 27", "output": "332" }, { "input": "152 108 4104", "output": "528" }, { "input": "1656 6900 1350", "output": "740" }, { "input": "12 14 42", "output": "60" }, { "input": "615 18 1230", "output": "856" }, { "input": "680 60 408", "output": "336" }, { "input": "644 966 6", "output": "1308" }, { "input": "1 432 432", "output": "1736" }, { "input": "2239 2239 1", "output": "8964" }, { "input": "4106 8212 2", "output": "16436" }, { "input": "10000 10000 10000", "output": "1200" }, { "input": "3623 3623 1", "output": "14500" }, { "input": "9801 9801 9801", "output": "1188" }, { "input": "10000 1 10000", "output": "40008" }, { "input": "9 9 9", "output": "36" }, { "input": "9801 9702 9702", "output": "1184" } ]

1,652,897,126

2,147,483,647

Python 3

OK

TESTS

27

124

4,505,600

import math ab,bc,ac=map(int,input().split()) x1,x2,x3=ab/bc,bc/ac,ab/ac a=math.sqrt(x1/x2*bc) b=math.sqrt(x2*x3*ac) c=math.sqrt(ab/x1/x3) jam=(4*(a+b+c)) if int(jam)==jam: print(int(jam)) else: print(int(jam)+1)

Title: Parallelepiped Time Limit: None seconds Memory Limit: None megabytes Problem Description: You've got a rectangular parallelepiped with integer edge lengths. You know the areas of its three faces that have a common vertex. Your task is to find the sum of lengths of all 12 edges of this parallelepiped. Input Specification: The first and the single line contains three space-separated integers — the areas of the parallelepiped's faces. The area's values are positive (<=><=0) and do not exceed 104. It is guaranteed that there exists at least one parallelepiped that satisfies the problem statement. Output Specification: Print a single number — the sum of all edges of the parallelepiped. Demo Input: ['1 1 1\n', '4 6 6\n'] Demo Output: ['12\n', '28\n'] Note: In the first sample the parallelepiped has sizes 1 × 1 × 1, in the second one — 2 × 2 × 3.

```python import math ab,bc,ac=map(int,input().split()) x1,x2,x3=ab/bc,bc/ac,ab/ac a=math.sqrt(x1/x2*bc) b=math.sqrt(x2*x3*ac) c=math.sqrt(ab/x1/x3) jam=(4*(a+b+c)) if int(jam)==jam: print(int(jam)) else: print(int(jam)+1) ```

3

402

B

Trees in a Row

PROGRAMMING

1,400

[ "brute force", "implementation" ]

null

The Queen of England has *n* trees growing in a row in her garden. At that, the *i*-th (1<=≤<=*i*<=≤<=*n*) tree from the left has height *a**i* meters. Today the Queen decided to update the scenery of her garden. She wants the trees' heights to meet the condition: for all *i* (1<=≤<=*i*<=<<=*n*), *a**i*<=+<=1<=-<=*a**i*<==<=*k*, where *k* is the number the Queen chose. Unfortunately, the royal gardener is not a machine and he cannot fulfill the desire of the Queen instantly! In one minute, the gardener can either decrease the height of a tree to any positive integer height or increase the height of a tree to any positive integer height. How should the royal gardener act to fulfill a whim of Her Majesty in the minimum number of minutes?

The first line contains two space-separated integers: *n*, *k* (1<=≤<=*n*,<=*k*<=≤<=1000). The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000) — the heights of the trees in the row.

In the first line print a single integer *p* — the minimum number of minutes the gardener needs. In the next *p* lines print the description of his actions. If the gardener needs to increase the height of the *j*-th (1<=≤<=*j*<=≤<=*n*) tree from the left by *x* (*x*<=≥<=1) meters, then print in the corresponding line "+ j x". If the gardener needs to decrease the height of the *j*-th (1<=≤<=*j*<=≤<=*n*) tree from the left by *x* (*x*<=≥<=1) meters, print on the corresponding line "- j x". If there are multiple ways to make a row of trees beautiful in the minimum number of actions, you are allowed to print any of them.

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

[ "2\n+ 3 2\n- 4 1\n", "0\n" ]

none

1,000

[ { "input": "4 1\n1 2 1 5", "output": "2\n+ 3 2\n- 4 1" }, { "input": "4 1\n1 2 3 4", "output": "0" }, { "input": "50 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", "output": "0" }, { "input": "10 1\n1 2 3 4 5 6 7 8 9 10", "output": "0" }, { "input": "50 5\n232 6 11 16 21 26 31 36 41 46 665 56 61 66 71 76 602 86 91 712 101 106 111 116 121 126 131 136 141 146 151 156 161 166 755 176 181 186 191 196 201 206 211 216 221 226 231 236 241 246", "output": "5\n- 1 231\n- 11 614\n- 17 521\n- 20 616\n- 35 584" }, { "input": "10 99\n1 100 199 298 397 496 364 694 793 676", "output": "2\n+ 7 231\n+ 10 216" }, { "input": "1 99\n1", "output": "0" }, { "input": "2 99\n1 100", "output": "0" }, { "input": "3 99\n1 100 199", "output": "0" }, { "input": "4 99\n1 100 199 298", "output": "0" }, { "input": "3 99\n295 566 992", "output": "2\n- 2 172\n- 3 499" }, { "input": "2 99\n307 854", "output": "1\n- 2 448" }, { "input": "7 1\n1 1 2 3 4 5 6", "output": "6\n+ 2 1\n+ 3 1\n+ 4 1\n+ 5 1\n+ 6 1\n+ 7 1" }, { "input": "5 1\n1 1 2 3 4", "output": "4\n+ 2 1\n+ 3 1\n+ 4 1\n+ 5 1" }, { "input": "4 2\n1 1 3 5", "output": "3\n+ 2 2\n+ 3 2\n+ 4 2" }, { "input": "4 1\n1 1 2 3", "output": "3\n+ 2 1\n+ 3 1\n+ 4 1" }, { "input": "5 1\n1 1 1 2 3", "output": "4\n+ 2 1\n+ 3 2\n+ 4 2\n+ 5 2" }, { "input": "3 1\n1 1 2", "output": "2\n+ 2 1\n+ 3 1" } ]

1,544,254,035

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

108

102,400

import sys n,k = input().split() n = int(n) k = int(k) a = input().split() for i in range(n): a[i] = int(a[i]) b = a.copy() j = 1 for i in range(1,n): if a[i] == a[0]+i*k: j +=1 else: a[i] = a[0]+i*k if j == n: print(0) sys.exit() p=0 for i in range(n): if a[i] != b[i]: p+=1 print(p) for i in range(n): if a[i] != b[i]: if a[i]>b[i]: print('+', i+1, a[i]-b[i]) else: print('-', i+1, b[i] - a[i])

Title: Trees in a Row Time Limit: None seconds Memory Limit: None megabytes Problem Description: The Queen of England has *n* trees growing in a row in her garden. At that, the *i*-th (1<=≤<=*i*<=≤<=*n*) tree from the left has height *a**i* meters. Today the Queen decided to update the scenery of her garden. She wants the trees' heights to meet the condition: for all *i* (1<=≤<=*i*<=<<=*n*), *a**i*<=+<=1<=-<=*a**i*<==<=*k*, where *k* is the number the Queen chose. Unfortunately, the royal gardener is not a machine and he cannot fulfill the desire of the Queen instantly! In one minute, the gardener can either decrease the height of a tree to any positive integer height or increase the height of a tree to any positive integer height. How should the royal gardener act to fulfill a whim of Her Majesty in the minimum number of minutes? Input Specification: The first line contains two space-separated integers: *n*, *k* (1<=≤<=*n*,<=*k*<=≤<=1000). The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1000) — the heights of the trees in the row. Output Specification: In the first line print a single integer *p* — the minimum number of minutes the gardener needs. In the next *p* lines print the description of his actions. If the gardener needs to increase the height of the *j*-th (1<=≤<=*j*<=≤<=*n*) tree from the left by *x* (*x*<=≥<=1) meters, then print in the corresponding line "+ j x". If the gardener needs to decrease the height of the *j*-th (1<=≤<=*j*<=≤<=*n*) tree from the left by *x* (*x*<=≥<=1) meters, print on the corresponding line "- j x". If there are multiple ways to make a row of trees beautiful in the minimum number of actions, you are allowed to print any of them. Demo Input: ['4 1\n1 2 1 5\n', '4 1\n1 2 3 4\n'] Demo Output: ['2\n+ 3 2\n- 4 1\n', '0\n'] Note: none

```python import sys n,k = input().split() n = int(n) k = int(k) a = input().split() for i in range(n): a[i] = int(a[i]) b = a.copy() j = 1 for i in range(1,n): if a[i] == a[0]+i*k: j +=1 else: a[i] = a[0]+i*k if j == n: print(0) sys.exit() p=0 for i in range(n): if a[i] != b[i]: p+=1 print(p) for i in range(n): if a[i] != b[i]: if a[i]>b[i]: print('+', i+1, a[i]-b[i]) else: print('-', i+1, b[i] - a[i]) ```

0

20

C

Dijkstra?

PROGRAMMING

1,900

[ "graphs", "shortest paths" ]

C. Dijkstra?

1

64

You are given a weighted undirected graph. The vertices are enumerated from 1 to *n*. Your task is to find the shortest path between the vertex 1 and the vertex *n*.

The first line contains two integers *n* and *m* (2<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105), where *n* is the number of vertices and *m* is the number of edges. Following *m* lines contain one edge each in form *a**i*, *b**i* and *w**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*,<=1<=≤<=*w**i*<=≤<=106), where *a**i*,<=*b**i* are edge endpoints and *w**i* is the length of the edge. It is possible that the graph has loops and multiple edges between pair of vertices.

Write the only integer -1 in case of no path. Write the shortest path in opposite case. If there are many solutions, print any of them.

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

[ "1 4 3 5 ", "1 4 3 5 " ]

none

1,500

[ { "input": "5 6\n1 2 2\n2 5 5\n2 3 4\n1 4 1\n4 3 3\n3 5 1", "output": "1 4 3 5 " }, { "input": "5 6\n1 2 2\n2 5 5\n2 3 4\n1 4 1\n4 3 3\n3 5 1", "output": "1 4 3 5 " }, { "input": "2 1\n1 2 1", "output": "1 2 " }, { "input": "3 1\n1 2 1", "output": "-1" }, { "input": "3 3\n1 2 1\n1 3 2\n2 3 1", "output": "1 3 " }, { "input": "10 10\n1 5 12\n2 4 140\n2 10 149\n3 6 154\n3 7 9\n3 8 226\n3 10 132\n4 10 55\n5 8 33\n7 8 173", "output": "1 5 8 7 3 10 " }, { "input": "10 10\n1 5 178\n1 8 221\n2 7 92\n2 8 159\n3 5 55\n3 6 179\n3 10 237\n4 8 205\n5 6 191\n8 10 157", "output": "1 8 10 " }, { "input": "10 10\n1 4 200\n1 9 197\n3 4 79\n3 5 213\n3 6 149\n5 8 3\n5 9 189\n6 7 130\n6 9 51\n8 10 135", "output": "1 9 5 8 10 " }, { "input": "10 10\n1 4 201\n2 3 238\n3 4 40\n3 6 231\n3 8 45\n4 5 227\n4 6 58\n4 9 55\n5 7 14\n6 10 242", "output": "1 4 6 10 " } ]

1,672,947,928

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

46

0

# can be Step in step.py class Path: def __init__(self, node : int, cost : int) -> None: self.to = node self.cost = cost def __str__(self) -> str: return "to node " + str(self.to) + " with cost " + str(self.cost) @staticmethod def getCost(p): return p.cost # for testing all_adj_lists = { 1 : [Path(2, 3), Path(4, 5)], 2 : [Path(1, 3), Path(4, 1), Path(3, 3)], 3 : [Path(2, 3), Path(4, 2), Path(5, 1)], 4 : [Path(1, 5), Path(2, 1), Path(3, 2), Path(5, 1)], 5 : [Path(4, 1), Path(3, 1)], } # to store answer costs = { 1 : float('inf'), 2 : float('inf'), 3 : float('inf'), 4 : float('inf'), 5 : float('inf'), } class Dij: from_node = 0 parentOf = dict() @staticmethod def get_path(start : int, dest: int): x = dest path = [] while Dij.parentOf[x] != x: path.append(x) x = Dij.parentOf[x] path.append(start) path.reverse() return path @staticmethod def run(from_node : int): Dij.parentOf[from_node] = from_node Dij.from_node = from_node costs[from_node] = 0 Dij._dijkstra(node=from_node, acc_cost=0, nodesQueue=[Path(from_node, 0)]) @staticmethod def _dijkstra(node : int, acc_cost : int, nodesQueue : list): adj = all_adj_lists[node] nodesQueue = nodesQueue[1:] for path in adj: newCost = acc_cost + path.cost if costs[path.to] > newCost: costs[path.to] = newCost nodesQueue.append(path) Dij.parentOf[path.to] = node if len(nodesQueue) > 0: nodesQueue.sort(key=Path.getCost) first = nodesQueue[0] Dij._dijkstra(node=first.to, acc_cost=acc_cost + first.cost, nodesQueue=nodesQueue,) if __name__ == '__main__': n, m = list(map(int, input().split(' '))) costs = dict() all_adj_lists = dict() max_val = 10000000000000000 for i in range(1, n + 1): costs[i] = max_val all_adj_lists[i] = [] for _ in range(0, m): a, b, c = list(map(int, input().split(' '))) all_adj_lists[a].append(Path(b, c)) all_adj_lists[b].append(Path(a, c)) Dij.run(1) if costs[n] == max_val: print("-1") else: ans = Dij.get_path(1, n) for i in ans: print(i, end=" ") """ Dij.run(from_node=1) for i in costs: print(i, ":", costs[i]) for i in calculated_paths[1]: print(i, ":", calculated_paths[1][i]) """

Title: Dijkstra? Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: You are given a weighted undirected graph. The vertices are enumerated from 1 to *n*. Your task is to find the shortest path between the vertex 1 and the vertex *n*. Input Specification: The first line contains two integers *n* and *m* (2<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105), where *n* is the number of vertices and *m* is the number of edges. Following *m* lines contain one edge each in form *a**i*, *b**i* and *w**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*,<=1<=≤<=*w**i*<=≤<=106), where *a**i*,<=*b**i* are edge endpoints and *w**i* is the length of the edge. It is possible that the graph has loops and multiple edges between pair of vertices. Output Specification: Write the only integer -1 in case of no path. Write the shortest path in opposite case. If there are many solutions, print any of them. Demo Input: ['5 6\n1 2 2\n2 5 5\n2 3 4\n1 4 1\n4 3 3\n3 5 1\n', '5 6\n1 2 2\n2 5 5\n2 3 4\n1 4 1\n4 3 3\n3 5 1\n'] Demo Output: ['1 4 3 5 ', '1 4 3 5 '] Note: none

```python # can be Step in step.py class Path: def __init__(self, node : int, cost : int) -> None: self.to = node self.cost = cost def __str__(self) -> str: return "to node " + str(self.to) + " with cost " + str(self.cost) @staticmethod def getCost(p): return p.cost # for testing all_adj_lists = { 1 : [Path(2, 3), Path(4, 5)], 2 : [Path(1, 3), Path(4, 1), Path(3, 3)], 3 : [Path(2, 3), Path(4, 2), Path(5, 1)], 4 : [Path(1, 5), Path(2, 1), Path(3, 2), Path(5, 1)], 5 : [Path(4, 1), Path(3, 1)], } # to store answer costs = { 1 : float('inf'), 2 : float('inf'), 3 : float('inf'), 4 : float('inf'), 5 : float('inf'), } class Dij: from_node = 0 parentOf = dict() @staticmethod def get_path(start : int, dest: int): x = dest path = [] while Dij.parentOf[x] != x: path.append(x) x = Dij.parentOf[x] path.append(start) path.reverse() return path @staticmethod def run(from_node : int): Dij.parentOf[from_node] = from_node Dij.from_node = from_node costs[from_node] = 0 Dij._dijkstra(node=from_node, acc_cost=0, nodesQueue=[Path(from_node, 0)]) @staticmethod def _dijkstra(node : int, acc_cost : int, nodesQueue : list): adj = all_adj_lists[node] nodesQueue = nodesQueue[1:] for path in adj: newCost = acc_cost + path.cost if costs[path.to] > newCost: costs[path.to] = newCost nodesQueue.append(path) Dij.parentOf[path.to] = node if len(nodesQueue) > 0: nodesQueue.sort(key=Path.getCost) first = nodesQueue[0] Dij._dijkstra(node=first.to, acc_cost=acc_cost + first.cost, nodesQueue=nodesQueue,) if __name__ == '__main__': n, m = list(map(int, input().split(' '))) costs = dict() all_adj_lists = dict() max_val = 10000000000000000 for i in range(1, n + 1): costs[i] = max_val all_adj_lists[i] = [] for _ in range(0, m): a, b, c = list(map(int, input().split(' '))) all_adj_lists[a].append(Path(b, c)) all_adj_lists[b].append(Path(a, c)) Dij.run(1) if costs[n] == max_val: print("-1") else: ans = Dij.get_path(1, n) for i in ans: print(i, end=" ") """ Dij.run(from_node=1) for i in costs: print(i, ":", costs[i]) for i in calculated_paths[1]: print(i, ":", calculated_paths[1][i]) """ ```

0

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,653,902,489

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

62

0

n,k=map(int,input().split()) s=n*m print(s//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 n,k=map(int,input().split()) s=n*m print(s//2) ```

-1

152

A

Marks

PROGRAMMING

900

[ "implementation" ]

null

Vasya, or Mr. Vasily Petrov is a dean of a department in a local university. After the winter exams he got his hands on a group's gradebook. Overall the group has *n* students. They received marks for *m* subjects. Each student got a mark from 1 to 9 (inclusive) for each subject. Let's consider a student the best at some subject, if there is no student who got a higher mark for this subject. Let's consider a student successful, if there exists a subject he is the best at. Your task is to find the number of successful students in the group.

The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of students and the number of subjects, correspondingly. Next *n* lines each containing *m* characters describe the gradebook. Each character in the gradebook is a number from 1 to 9. Note that the marks in a rows are not sepatated by spaces.

Print the single number — the number of successful students in the given group.

[ "3 3\n223\n232\n112\n", "3 5\n91728\n11828\n11111\n" ]

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

In the first sample test the student number 1 is the best at subjects 1 and 3, student 2 is the best at subjects 1 and 2, but student 3 isn't the best at any subject. In the second sample test each student is the best at at least one subject.

500

[ { "input": "3 3\n223\n232\n112", "output": "2" }, { "input": "3 5\n91728\n11828\n11111", "output": "3" }, { "input": "2 2\n48\n27", "output": "1" }, { "input": "2 1\n4\n6", "output": "1" }, { "input": "1 2\n57", "output": "1" }, { "input": "1 1\n5", "output": "1" }, { "input": "3 4\n2553\n6856\n5133", "output": "2" }, { "input": "8 7\n6264676\n7854895\n3244128\n2465944\n8958761\n1378945\n3859353\n6615285", "output": "6" }, { "input": "9 8\n61531121\n43529859\n18841327\n88683622\n98995641\n62741632\n57441743\n49396792\n63381994", "output": "4" }, { "input": "10 20\n26855662887514171367\n48525577498621511535\n47683778377545341138\n47331616748732562762\n44876938191354974293\n24577238399664382695\n42724955594463126746\n79187344479926159359\n48349683283914388185\n82157191115518781898", "output": "9" }, { "input": "20 15\n471187383859588\n652657222494199\n245695867594992\n726154672861295\n614617827782772\n862889444974692\n373977167653235\n645434268565473\n785993468314573\n722176861496755\n518276853323939\n723712762593348\n728935312568886\n373898548522463\n769777587165681\n247592995114377\n182375946483965\n497496542536127\n988239919677856\n859844339819143", "output": "18" }, { "input": "13 9\n514562255\n322655246\n135162979\n733845982\n473117129\n513967187\n965649829\n799122777\n661249521\n298618978\n659352422\n747778378\n723261619", "output": "11" }, { "input": "75 1\n2\n3\n8\n3\n2\n1\n3\n1\n5\n1\n5\n4\n8\n8\n4\n2\n5\n1\n7\n6\n3\n2\n2\n3\n5\n5\n2\n4\n7\n7\n9\n2\n9\n5\n1\n4\n9\n5\n2\n4\n6\n6\n3\n3\n9\n3\n3\n2\n3\n4\n2\n6\n9\n1\n1\n1\n1\n7\n2\n3\n2\n9\n7\n4\n9\n1\n7\n5\n6\n8\n3\n4\n3\n4\n6", "output": "7" }, { "input": "92 3\n418\n665\n861\n766\n529\n416\n476\n676\n561\n995\n415\n185\n291\n176\n776\n631\n556\n488\n118\n188\n437\n496\n466\n131\n914\n118\n766\n365\n113\n897\n386\n639\n276\n946\n759\n169\n494\n837\n338\n351\n783\n311\n261\n862\n598\n132\n246\n982\n575\n364\n615\n347\n374\n368\n523\n132\n774\n161\n552\n492\n598\n474\n639\n681\n635\n342\n516\n483\n141\n197\n571\n336\n175\n596\n481\n327\n841\n133\n142\n146\n246\n396\n287\n582\n556\n996\n479\n814\n497\n363\n963\n162", "output": "23" }, { "input": "100 1\n1\n6\n9\n1\n1\n5\n5\n4\n6\n9\n6\n1\n7\n8\n7\n3\n8\n8\n7\n6\n2\n1\n5\n8\n7\n3\n5\n4\n9\n7\n1\n2\n4\n1\n6\n5\n1\n3\n9\n4\n5\n8\n1\n2\n1\n9\n7\n3\n7\n1\n2\n2\n2\n2\n3\n9\n7\n2\n4\n7\n1\n6\n8\n1\n5\n6\n1\n1\n2\n9\n7\n4\n9\n1\n9\n4\n1\n3\n5\n2\n4\n4\n6\n5\n1\n4\n5\n8\n4\n7\n6\n5\n6\n9\n5\n8\n1\n5\n1\n6", "output": "10" }, { "input": "100 2\n71\n87\n99\n47\n22\n87\n49\n73\n21\n12\n77\n43\n18\n41\n78\n62\n61\n16\n64\n89\n81\n54\n53\n92\n93\n94\n68\n93\n15\n68\n42\n93\n28\n19\n86\n16\n97\n17\n11\n43\n72\n76\n54\n95\n58\n53\n48\n45\n85\n85\n74\n21\n44\n51\n89\n75\n76\n17\n38\n62\n81\n22\n66\n59\n89\n85\n91\n87\n12\n97\n52\n87\n43\n89\n51\n58\n57\n98\n78\n68\n82\n41\n87\n29\n75\n72\n48\n14\n35\n71\n74\n91\n66\n67\n42\n98\n52\n54\n22\n41", "output": "21" }, { "input": "5 20\n11111111111111111111\n11111111111111111111\n11111111111111111111\n99999999999999999999\n11111111111111111119", "output": "2" }, { "input": "3 3\n111\n111\n999", "output": "1" }, { "input": "3 3\n119\n181\n711", "output": "3" }, { "input": "15 5\n91728\n11828\n11111\n91728\n11828\n11111\n91728\n11828\n11111\n91728\n11828\n11111\n91728\n11828\n11111", "output": "15" }, { "input": "2 20\n22222222222222222222\n11111111111111111111", "output": "1" }, { "input": "3 3\n233\n222\n111", "output": "2" }, { "input": "4 15\n222222222222222\n111111111111119\n111111111111119\n111111111111111", "output": "3" }, { "input": "4 1\n1\n9\n9\n9", "output": "3" }, { "input": "3 3\n123\n321\n132", "output": "3" }, { "input": "3 3\n113\n332\n322", "output": "3" }, { "input": "2 100\n2222222222222222222222222222222222222222222222222222222222222222222222221222222222222222222222222222\n1111111111111111111111111111111111111111111111111111111111111111111111119111111111111111111111111111", "output": "2" }, { "input": "3 3\n321\n231\n123", "output": "3" }, { "input": "2 100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111\n2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222", "output": "1" }, { "input": "3 3\n221\n111\n111", "output": "3" } ]

1,581,943,532

2,147,483,647

PyPy 3

RUNTIME_ERROR

TESTS

3

249

2,355,200

import sys import math import bisect def main(): n, m = map(int, input().split()) A = [] for i in range(n): A.append(list(int(a) for a in input())) B = [0] * m for i in range(n): for j in range(m): B[j] = max(B[j], A[i][j]) ans = 0 for i in range(n): for j in range(n): if A[i][j] == B[j]: ans += 1 break print(ans) if __name__ == "__main__": main()

Title: Marks Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya, or Mr. Vasily Petrov is a dean of a department in a local university. After the winter exams he got his hands on a group's gradebook. Overall the group has *n* students. They received marks for *m* subjects. Each student got a mark from 1 to 9 (inclusive) for each subject. Let's consider a student the best at some subject, if there is no student who got a higher mark for this subject. Let's consider a student successful, if there exists a subject he is the best at. Your task is to find the number of successful students in the group. Input Specification: The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of students and the number of subjects, correspondingly. Next *n* lines each containing *m* characters describe the gradebook. Each character in the gradebook is a number from 1 to 9. Note that the marks in a rows are not sepatated by spaces. Output Specification: Print the single number — the number of successful students in the given group. Demo Input: ['3 3\n223\n232\n112\n', '3 5\n91728\n11828\n11111\n'] Demo Output: ['2\n', '3\n'] Note: In the first sample test the student number 1 is the best at subjects 1 and 3, student 2 is the best at subjects 1 and 2, but student 3 isn't the best at any subject. In the second sample test each student is the best at at least one subject.

```python import sys import math import bisect def main(): n, m = map(int, input().split()) A = [] for i in range(n): A.append(list(int(a) for a in input())) B = [0] * m for i in range(n): for j in range(m): B[j] = max(B[j], A[i][j]) ans = 0 for i in range(n): for j in range(n): if A[i][j] == B[j]: ans += 1 break print(ans) if __name__ == "__main__": main() ```

-1

611

C

New Year and Domino

PROGRAMMING

1,500

[ "dp", "implementation" ]

null

They say "years are like dominoes, tumbling one after the other". But would a year fit into a grid? I don't think so. Limak is a little polar bear who loves to play. He has recently got a rectangular grid with *h* rows and *w* columns. Each cell is a square, either empty (denoted by '.') or forbidden (denoted by '#'). Rows are numbered 1 through *h* from top to bottom. Columns are numbered 1 through *w* from left to right. Also, Limak has a single domino. He wants to put it somewhere in a grid. A domino will occupy exactly two adjacent cells, located either in one row or in one column. Both adjacent cells must be empty and must be inside a grid. Limak needs more fun and thus he is going to consider some queries. In each query he chooses some rectangle and wonders, how many way are there to put a single domino inside of the chosen rectangle?

The first line of the input contains two integers *h* and *w* (1<=≤<=*h*,<=*w*<=≤<=500) – the number of rows and the number of columns, respectively. The next *h* lines describe a grid. Each line contains a string of the length *w*. Each character is either '.' or '#' — denoting an empty or forbidden cell, respectively. The next line contains a single integer *q* (1<=≤<=*q*<=≤<=100<=000) — the number of queries. Each of the next *q* lines contains four integers *r*1*i*, *c*1*i*, *r*2*i*, *c*2*i* (1<=≤<=*r*1*i*<=≤<=*r*2*i*<=≤<=*h*,<=1<=≤<=*c*1*i*<=≤<=*c*2*i*<=≤<=*w*) — the *i*-th query. Numbers *r*1*i* and *c*1*i* denote the row and the column (respectively) of the upper left cell of the rectangle. Numbers *r*2*i* and *c*2*i* denote the row and the column (respectively) of the bottom right cell of the rectangle.

Print *q* integers, *i*-th should be equal to the number of ways to put a single domino inside the *i*-th rectangle.

[ "5 8\n....#..#\n.#......\n##.#....\n##..#.##\n........\n4\n1 1 2 3\n4 1 4 1\n1 2 4 5\n2 5 5 8\n", "7 39\n.......................................\n.###..###..#..###.....###..###..#..###.\n...#..#.#..#..#.........#..#.#..#..#...\n.###..#.#..#..###.....###..#.#..#..###.\n.#....#.#..#....#.....#....#.#..#..#.#.\n.###..###..#..###.....###..###..#..###.\n.......................................\n6\n1 1 3 20\n2 10 6 30\n2 10 7 30\n2 2 7 7\n1 7 7 7\n1 8 7 8\n" ]

[ "4\n0\n10\n15\n", "53\n89\n120\n23\n0\n2\n" ]

A red frame below corresponds to the first query of the first sample. A domino can be placed in 4 possible ways.

1,250

[ { "input": "5 8\n....#..#\n.#......\n##.#....\n##..#.##\n........\n4\n1 1 2 3\n4 1 4 1\n1 2 4 5\n2 5 5 8", "output": "4\n0\n10\n15" }, { "input": "7 39\n.......................................\n.###..###..#..###.....###..###..#..###.\n...#..#.#..#..#.........#..#.#..#..#...\n.###..#.#..#..###.....###..#.#..#..###.\n.#....#.#..#....#.....#....#.#..#..#.#.\n.###..###..#..###.....###..###..#..###.\n.......................................\n6\n1 1 3 20\n2 10 6 30\n2 10 7 30\n2 2 7 7\n1 7 7 7\n1 8 7 8", "output": "53\n89\n120\n23\n0\n2" }, { "input": "2 20\n.#..................\n....................\n15\n1 3 1 13\n1 11 2 14\n1 17 1 20\n1 2 2 3\n1 7 1 10\n1 7 2 17\n1 4 1 9\n2 6 2 8\n1 8 2 20\n2 7 2 16\n1 4 2 16\n1 6 1 9\n1 4 2 7\n1 9 1 20\n2 2 2 12", "output": "10\n10\n3\n2\n3\n31\n5\n2\n37\n9\n37\n3\n10\n11\n10" }, { "input": "15 3\n...\n.#.\n.#.\n.#.\n..#\n...\n.#.\n.##\n.#.\n...\n...\n.##\n..#\n.#.\n#.#\n20\n1 1 10 1\n2 1 9 3\n1 2 15 3\n10 2 12 2\n4 1 8 1\n5 2 8 2\n10 1 12 3\n11 1 11 3\n7 2 14 3\n6 2 12 3\n8 1 11 2\n7 1 9 1\n2 1 6 2\n6 3 7 3\n7 1 10 2\n6 1 10 2\n1 1 2 2\n10 1 15 3\n1 1 11 1\n9 1 15 1", "output": "9\n14\n12\n1\n4\n1\n8\n2\n5\n7\n6\n2\n7\n1\n4\n6\n2\n11\n10\n5" }, { "input": "7 19\n.##.#.#.#....#.#...\n.#...##..........#.\n..#.........#..#.#.\n#.#....#....#......\n.#.#.#.#....###...#\n.....##.....#......\n..........#.#..#.#.\n10\n2 2 3 10\n4 10 5 16\n3 3 6 12\n2 12 6 14\n5 1 5 19\n3 11 3 13\n4 10 5 17\n1 13 4 19\n5 3 5 17\n4 15 7 19", "output": "15\n10\n43\n8\n5\n1\n13\n24\n4\n19" }, { "input": "1 1\n.\n1\n1 1 1 1", "output": "0" }, { "input": "1 1\n#\n1\n1 1 1 1", "output": "0" } ]

1,562,266,837

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

5

3,000

3,174,400

h, w = map(int, input().split()) grid = [] for i in range(h): grid.append(str(input())) num_horizontal = [] for i in range(h): cur = 0 this_row = [0] for j in range(1, w): if grid[i][j] == '.' and grid[i][j-1] == '.': cur += 1 this_row.append(cur) num_horizontal.append(this_row) num_vertical = [] for i in range(w): cur = 0 this_col = [0] for j in range(1, h): if grid[j][i] == '.' and grid[j-1][i] == '.': cur += 1 this_col.append(cur) num_vertical.append(this_col) #print(num_horizontal, num_vertical) queries = int(input()) for i in range(queries): r1, c1, r2, c2 = map(int, input().split()) c = 0 for ro in range(r1, r2+1): c += num_horizontal[ro-1][c2-1]-num_horizontal[ro-1][c1-1] for co in range(c1, c2+1): c += num_vertical[co-1][r2-1]-num_vertical[co-1][r1-1] print(c)

Title: New Year and Domino Time Limit: None seconds Memory Limit: None megabytes Problem Description: They say "years are like dominoes, tumbling one after the other". But would a year fit into a grid? I don't think so. Limak is a little polar bear who loves to play. He has recently got a rectangular grid with *h* rows and *w* columns. Each cell is a square, either empty (denoted by '.') or forbidden (denoted by '#'). Rows are numbered 1 through *h* from top to bottom. Columns are numbered 1 through *w* from left to right. Also, Limak has a single domino. He wants to put it somewhere in a grid. A domino will occupy exactly two adjacent cells, located either in one row or in one column. Both adjacent cells must be empty and must be inside a grid. Limak needs more fun and thus he is going to consider some queries. In each query he chooses some rectangle and wonders, how many way are there to put a single domino inside of the chosen rectangle? Input Specification: The first line of the input contains two integers *h* and *w* (1<=≤<=*h*,<=*w*<=≤<=500) – the number of rows and the number of columns, respectively. The next *h* lines describe a grid. Each line contains a string of the length *w*. Each character is either '.' or '#' — denoting an empty or forbidden cell, respectively. The next line contains a single integer *q* (1<=≤<=*q*<=≤<=100<=000) — the number of queries. Each of the next *q* lines contains four integers *r*1*i*, *c*1*i*, *r*2*i*, *c*2*i* (1<=≤<=*r*1*i*<=≤<=*r*2*i*<=≤<=*h*,<=1<=≤<=*c*1*i*<=≤<=*c*2*i*<=≤<=*w*) — the *i*-th query. Numbers *r*1*i* and *c*1*i* denote the row and the column (respectively) of the upper left cell of the rectangle. Numbers *r*2*i* and *c*2*i* denote the row and the column (respectively) of the bottom right cell of the rectangle. Output Specification: Print *q* integers, *i*-th should be equal to the number of ways to put a single domino inside the *i*-th rectangle. Demo Input: ['5 8\n....#..#\n.#......\n##.#....\n##..#.##\n........\n4\n1 1 2 3\n4 1 4 1\n1 2 4 5\n2 5 5 8\n', '7 39\n.......................................\n.###..###..#..###.....###..###..#..###.\n...#..#.#..#..#.........#..#.#..#..#...\n.###..#.#..#..###.....###..#.#..#..###.\n.#....#.#..#....#.....#....#.#..#..#.#.\n.###..###..#..###.....###..###..#..###.\n.......................................\n6\n1 1 3 20\n2 10 6 30\n2 10 7 30\n2 2 7 7\n1 7 7 7\n1 8 7 8\n'] Demo Output: ['4\n0\n10\n15\n', '53\n89\n120\n23\n0\n2\n'] Note: A red frame below corresponds to the first query of the first sample. A domino can be placed in 4 possible ways.

```python h, w = map(int, input().split()) grid = [] for i in range(h): grid.append(str(input())) num_horizontal = [] for i in range(h): cur = 0 this_row = [0] for j in range(1, w): if grid[i][j] == '.' and grid[i][j-1] == '.': cur += 1 this_row.append(cur) num_horizontal.append(this_row) num_vertical = [] for i in range(w): cur = 0 this_col = [0] for j in range(1, h): if grid[j][i] == '.' and grid[j-1][i] == '.': cur += 1 this_col.append(cur) num_vertical.append(this_col) #print(num_horizontal, num_vertical) queries = int(input()) for i in range(queries): r1, c1, r2, c2 = map(int, input().split()) c = 0 for ro in range(r1, r2+1): c += num_horizontal[ro-1][c2-1]-num_horizontal[ro-1][c1-1] for co in range(c1, c2+1): c += num_vertical[co-1][r2-1]-num_vertical[co-1][r1-1] print(c) ```

0

978

B

File Name

PROGRAMMING

800

[ "greedy", "strings" ]

null

You can not just take the file and send it. When Polycarp trying to send a file in the social network "Codehorses", he encountered an unexpected problem. If the name of the file contains three or more "x" (lowercase Latin letters "x") in a row, the system considers that the file content does not correspond to the social network topic. In this case, the file is not sent and an error message is displayed. Determine the minimum number of characters to remove from the file name so after that the name does not contain "xxx" as a substring. Print 0 if the file name does not initially contain a forbidden substring "xxx". You can delete characters in arbitrary positions (not necessarily consecutive). If you delete a character, then the length of a string is reduced by $1$. For example, if you delete the character in the position $2$ from the string "exxxii", then the resulting string is "exxii".

The first line contains integer $n$ $(3 \le n \le 100)$ — the length of the file name. The second line contains a string of length $n$ consisting of lowercase Latin letters only — the file name.

Print the minimum number of characters to remove from the file name so after that the name does not contain "xxx" as a substring. If initially the file name dost not contain a forbidden substring "xxx", print 0.

[ "6\nxxxiii\n", "5\nxxoxx\n", "10\nxxxxxxxxxx\n" ]

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

In the first example Polycarp tried to send a file with name contains number $33$, written in Roman numerals. But he can not just send the file, because it name contains three letters "x" in a row. To send the file he needs to remove any one of this letters.

0

[ { "input": "6\nxxxiii", "output": "1" }, { "input": "5\nxxoxx", "output": "0" }, { "input": "10\nxxxxxxxxxx", "output": "8" }, { "input": "100\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "output": "98" }, { "input": "99\nxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxaxxa", "output": "0" }, { "input": "3\nxxx", "output": "1" }, { "input": "77\naaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxyyyzzz", "output": "0" }, { "input": "100\nuxxxxxlmexxxxxxxwnxxexxxxxcxxfydxxxxxxvmdxxxxxxisxxxxxxxxidkxxxpxxxxxxxxmnuxxxxjxxxqcxxwmxxxxxxxxmrx", "output": "41" }, { "input": "100\nxxxxxxxxxxxjtxxxxxxxxcxxxxxxcfxxxxzxxxxxxgxxxxxbxxxxbxxxxxxxxdycxxxxokixxxkizxxgcxxxxxxxxexxxxxfxxxc", "output": "49" }, { "input": "100\nuxxxxxlmexxxxxxxwnxxexxxxxcxxfydxxxxxxvmdxxxxxxisxxxxxxxxidkxxxpxxxxxxxxmnuxxxxjxxxqcxxwmxxxxxwxxxxx", "output": "41" }, { "input": "34\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "0" }, { "input": "5\nfcyju", "output": "0" }, { "input": "100\nihygyvdvyeifomhxhkhdkimquvgallbqharcyriyqkidnwykozuhvkwdldlztpabgyuflikychqpdenwzgtlzotyumjgdsrbxxxx", "output": "2" } ]

1,658,998,893

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

l = int(input("请输入你要判断的标题长度")) s = input("请输入你要判断的标题内容") ans = '' for XX in s: if XX == "x": ans+="x" else: ans+=" " sum1 = 0 res = ans.split(" ") for x in res: if len(x)>2: sum1+=len(x)-2 print(sum1)

Title: File Name Time Limit: None seconds Memory Limit: None megabytes Problem Description: You can not just take the file and send it. When Polycarp trying to send a file in the social network "Codehorses", he encountered an unexpected problem. If the name of the file contains three or more "x" (lowercase Latin letters "x") in a row, the system considers that the file content does not correspond to the social network topic. In this case, the file is not sent and an error message is displayed. Determine the minimum number of characters to remove from the file name so after that the name does not contain "xxx" as a substring. Print 0 if the file name does not initially contain a forbidden substring "xxx". You can delete characters in arbitrary positions (not necessarily consecutive). If you delete a character, then the length of a string is reduced by $1$. For example, if you delete the character in the position $2$ from the string "exxxii", then the resulting string is "exxii". Input Specification: The first line contains integer $n$ $(3 \le n \le 100)$ — the length of the file name. The second line contains a string of length $n$ consisting of lowercase Latin letters only — the file name. Output Specification: Print the minimum number of characters to remove from the file name so after that the name does not contain "xxx" as a substring. If initially the file name dost not contain a forbidden substring "xxx", print 0. Demo Input: ['6\nxxxiii\n', '5\nxxoxx\n', '10\nxxxxxxxxxx\n'] Demo Output: ['1\n', '0\n', '8\n'] Note: In the first example Polycarp tried to send a file with name contains number $33$, written in Roman numerals. But he can not just send the file, because it name contains three letters "x" in a row. To send the file he needs to remove any one of this letters.

```python l = int(input("请输入你要判断的标题长度")) s = input("请输入你要判断的标题内容") ans = '' for XX in s: if XX == "x": ans+="x" else: ans+=" " sum1 = 0 res = ans.split(" ") for x in res: if len(x)>2: sum1+=len(x)-2 print(sum1) ```

-1

620

B

Grandfather Dovlet’s calculator

PROGRAMMING

1,000

[ "implementation" ]

null

Once Max found an electronic calculator from his grandfather Dovlet's chest. He noticed that the numbers were written with seven-segment indicators ([https://en.wikipedia.org/wiki/Seven-segment_display](https://en.wikipedia.org/wiki/Seven-segment_display)). Max starts to type all the values from *a* to *b*. After typing each number Max resets the calculator. Find the total number of segments printed on the calculator. For example if *a*<==<=1 and *b*<==<=3 then at first the calculator will print 2 segments, then — 5 segments and at last it will print 5 segments. So the total number of printed segments is 12.

The only line contains two integers *a*,<=*b* (1<=≤<=*a*<=≤<=*b*<=≤<=106) — the first and the last number typed by Max.

Print the only integer *a* — the total number of printed segments.

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

[ "12\n", "39\n" ]

none

0

[ { "input": "1 3", "output": "12" }, { "input": "10 15", "output": "39" }, { "input": "1 100", "output": "928" }, { "input": "100 10000", "output": "188446" }, { "input": "213 221442", "output": "5645356" }, { "input": "1 1000000", "output": "28733372" }, { "input": "1000000 1000000", "output": "38" }, { "input": "222145 353252", "output": "3860750" }, { "input": "2 1000000", "output": "28733370" }, { "input": "1 999999", "output": "28733334" }, { "input": "192 200", "output": "122" } ]

1,453,398,423

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

5

1,000

0

num = [i for i in input().split()] segments = {'0': 6, '1': 2, '2': 5, '3': 5, '4': 4, '5': 5, '6': 6, '7': 3, '8': 7, '9': 6} _max = 0 start = int(num[0]) s = set() while start <= int(num[1]): _str = str(start) # print(_str) for c in _str: # if c not in s: _max += segments[c] s.add(c) # print('counting {}'.format(c)) start += 1 print(_max)

Title: Grandfather Dovlet’s calculator Time Limit: None seconds Memory Limit: None megabytes Problem Description: Once Max found an electronic calculator from his grandfather Dovlet's chest. He noticed that the numbers were written with seven-segment indicators ([https://en.wikipedia.org/wiki/Seven-segment_display](https://en.wikipedia.org/wiki/Seven-segment_display)). Max starts to type all the values from *a* to *b*. After typing each number Max resets the calculator. Find the total number of segments printed on the calculator. For example if *a*<==<=1 and *b*<==<=3 then at first the calculator will print 2 segments, then — 5 segments and at last it will print 5 segments. So the total number of printed segments is 12. Input Specification: The only line contains two integers *a*,<=*b* (1<=≤<=*a*<=≤<=*b*<=≤<=106) — the first and the last number typed by Max. Output Specification: Print the only integer *a* — the total number of printed segments. Demo Input: ['1 3\n', '10 15\n'] Demo Output: ['12\n', '39\n'] Note: none

```python num = [i for i in input().split()] segments = {'0': 6, '1': 2, '2': 5, '3': 5, '4': 4, '5': 5, '6': 6, '7': 3, '8': 7, '9': 6} _max = 0 start = int(num[0]) s = set() while start <= int(num[1]): _str = str(start) # print(_str) for c in _str: # if c not in s: _max += segments[c] s.add(c) # print('counting {}'.format(c)) start += 1 print(_max) ```

0

709

A

Juicer

PROGRAMMING

900

[ "implementation" ]

null

Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To be put in the juicer the orange must have size not exceeding *b*, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one. The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than *d*. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section?

The first line of the input contains three integers *n*, *b* and *d* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*b*<=≤<=*d*<=≤<=1<=000<=000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value *d*, which determines the condition when the waste section should be emptied. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1<=000<=000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer.

Print one integer — the number of times Kolya will have to empty the waste section.

[ "2 7 10\n5 6\n", "1 5 10\n7\n", "3 10 10\n5 7 7\n", "1 1 1\n1\n" ]

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

In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards. In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all.

500

[ { "input": "2 7 10\n5 6", "output": "1" }, { "input": "1 5 10\n7", "output": "0" }, { "input": "3 10 10\n5 7 7", "output": "1" }, { "input": "1 1 1\n1", "output": "0" }, { "input": "2 951637 951638\n44069 951637", "output": "1" }, { "input": "50 100 129\n55 130 91 19 116 3 63 52 104 76 75 27 151 99 149 147 39 148 84 9 132 49 40 112 124 141 144 93 36 32 146 74 48 38 150 55 94 32 107 69 77 81 33 57 62 98 78 127 154 126", "output": "12" }, { "input": "100 1000 1083\n992 616 818 359 609 783 263 989 501 929 362 394 919 1081 870 830 1097 975 62 346 531 367 323 457 707 360 949 334 867 116 478 417 961 963 1029 114 867 1008 988 916 983 1077 959 942 572 961 579 318 721 337 488 717 111 70 416 685 987 130 353 107 61 191 827 849 106 815 211 953 111 398 889 860 801 71 375 320 395 1059 116 222 931 444 582 74 677 655 88 173 686 491 661 186 114 832 615 814 791 464 517 850", "output": "36" }, { "input": "2 6 8\n2 1", "output": "0" }, { "input": "5 15 16\n7 11 5 12 8", "output": "2" }, { "input": "15 759966 759967\n890397 182209 878577 548548 759966 812923 759966 860479 200595 381358 299175 339368 759966 907668 69574", "output": "4" }, { "input": "5 234613 716125\n642626 494941 234613 234613 234613", "output": "0" }, { "input": "50 48547 567054\n529808 597004 242355 559114 78865 537318 631455 733020 655072 645093 309010 855034 306058 625046 524574 834944 27330 664392 443637 821584 338013 490702 289520 675471 885846 258814 134220 571301 84875 94132 200425 928833 375166 521232 317961 175315 947093 89971 322071 174033 48547 998535 954205 704114 943163 438900 48547 538422 48547 48547", "output": "0" }, { "input": "5 10 20\n10 10 10 10 1", "output": "1" }, { "input": "5 10 11\n10 10 10 10 1", "output": "2" }, { "input": "3 10 10\n4 3 3", "output": "0" }, { "input": "3 5 5\n5 5 5", "output": "1" }, { "input": "3 4 14\n5 5 5", "output": "0" }, { "input": "2 7 10\n1234 1234", "output": "0" }, { "input": "1 5 6\n10", "output": "0" }, { "input": "3 4 6\n1 2 3", "output": "0" }, { "input": "5 10 12\n13 13 13 13 13", "output": "0" }, { "input": "3 4 5\n5 7 9", "output": "0" }, { "input": "3 10 100\n5 5 5", "output": "0" }, { "input": "5 1 2\n2 2 2 2 2", "output": "0" }, { "input": "5 5 5\n5 5 5 5 5", "output": "2" }, { "input": "2 2 5\n5 5", "output": "0" }, { "input": "3 1 4\n2 2 2", "output": "0" } ]

1,645,668,633

2,147,483,647

Python 3

OK

TESTS

58

93

7,372,800

n, b, d = map(int, input().split()) a = list(map(int, input().split())) w = 0 counter = 0 for s in a: if s <= b: w = w + s if w > d: counter += 1 w = 0 else: pass else: pass print(counter)

Title: Juicer Time Limit: None seconds Memory Limit: None megabytes Problem Description: Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To be put in the juicer the orange must have size not exceeding *b*, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one. The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than *d*. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section? Input Specification: The first line of the input contains three integers *n*, *b* and *d* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*b*<=≤<=*d*<=≤<=1<=000<=000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value *d*, which determines the condition when the waste section should be emptied. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1<=000<=000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer. Output Specification: Print one integer — the number of times Kolya will have to empty the waste section. Demo Input: ['2 7 10\n5 6\n', '1 5 10\n7\n', '3 10 10\n5 7 7\n', '1 1 1\n1\n'] Demo Output: ['1\n', '0\n', '1\n', '0\n'] Note: In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards. In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all.

```python n, b, d = map(int, input().split()) a = list(map(int, input().split())) w = 0 counter = 0 for s in a: if s <= b: w = w + s if w > d: counter += 1 w = 0 else: pass else: pass print(counter) ```

3

948

A

Protect Sheep

PROGRAMMING

900

[ "brute force", "dfs and similar", "graphs", "implementation" ]

null

Bob is a farmer. He has a large pasture with many sheep. Recently, he has lost some of them due to wolf attacks. He thus decided to place some shepherd dogs in such a way that all his sheep are protected. The pasture is a rectangle consisting of *R*<=×<=*C* cells. Each cell is either empty, contains a sheep, a wolf or a dog. Sheep and dogs always stay in place, but wolves can roam freely around the pasture, by repeatedly moving to the left, right, up or down to a neighboring cell. When a wolf enters a cell with a sheep, it consumes it. However, no wolf can enter a cell with a dog. Initially there are no dogs. Place dogs onto the pasture in such a way that no wolf can reach any sheep, or determine that it is impossible. Note that since you have many dogs, you do not need to minimize their number.

First line contains two integers *R* (1<=≤<=*R*<=≤<=500) and *C* (1<=≤<=*C*<=≤<=500), denoting the number of rows and the numbers of columns respectively. Each of the following *R* lines is a string consisting of exactly *C* characters, representing one row of the pasture. Here, 'S' means a sheep, 'W' a wolf and '.' an empty cell.

If it is impossible to protect all sheep, output a single line with the word "No". Otherwise, output a line with the word "Yes". Then print *R* lines, representing the pasture after placing dogs. Again, 'S' means a sheep, 'W' a wolf, 'D' is a dog and '.' an empty space. You are not allowed to move, remove or add a sheep or a wolf. If there are multiple solutions, you may print any of them. You don't have to minimize the number of dogs.

[ "6 6\n..S...\n..S.W.\n.S....\n..W...\n...W..\n......\n", "1 2\nSW\n", "5 5\n.S...\n...S.\nS....\n...S.\n.S...\n" ]

[ "Yes\n..SD..\n..SDW.\n.SD...\n.DW...\nDD.W..\n......\n", "No\n", "Yes\n.S...\n...S.\nS.D..\n...S.\n.S...\n" ]

In the first example, we can split the pasture into two halves, one containing wolves and one containing sheep. Note that the sheep at (2,1) is safe, as wolves cannot move diagonally. In the second example, there are no empty spots to put dogs that would guard the lone sheep. In the third example, there are no wolves, so the task is very easy. We put a dog in the center to observe the peacefulness of the meadow, but the solution would be correct even without him.

500

[ { "input": "1 2\nSW", "output": "No" }, { "input": "10 10\n....W.W.W.\n.........S\n.S.S...S..\nW.......SS\n.W..W.....\n.W...W....\nS..S...S.S\n....W...S.\n..S..S.S.S\nSS.......S", "output": "Yes\nDDDDWDWDWD\nDDDDDDDDDS\nDSDSDDDSDD\nWDDDDDDDSS\nDWDDWDDDDD\nDWDDDWDDDD\nSDDSDDDSDS\nDDDDWDDDSD\nDDSDDSDSDS\nSSDDDDDDDS" }, { "input": "10 10\n....W.W.W.\n...W.....S\n.S.S...S..\nW......WSS\n.W..W.....\n.W...W....\nS..S...S.S\n...WWW..S.\n..S..S.S.S\nSS.......S", "output": "No" }, { "input": "1 50\nW...S..............W.....S..S...............S...W.", "output": "Yes\nWDDDSDDDDDDDDDDDDDDWDDDDDSDDSDDDDDDDDDDDDDDDSDDDWD" }, { "input": "2 4\n...S\n...W", "output": "No" }, { "input": "4 2\n..\n..\n..\nSW", "output": "No" }, { "input": "4 2\n..\n..\n..\nWS", "output": "No" }, { "input": "2 4\n...W\n...S", "output": "No" }, { "input": "50 1\nS\n.\n.\n.\n.\n.\n.\nS\n.\n.\n.\n.\n.\n.\n.\n.\nS\n.\nW\n.\nS\n.\n.\n.\n.\nS\n.\n.\n.\n.\n.\n.\n.\nW\n.\n.\n.\nW\n.\n.\n.\n.\n.\n.\n.\n.\n.\n.\n.\n.", "output": "Yes\nS\nD\nD\nD\nD\nD\nD\nS\nD\nD\nD\nD\nD\nD\nD\nD\nS\nD\nW\nD\nS\nD\nD\nD\nD\nS\nD\nD\nD\nD\nD\nD\nD\nW\nD\nD\nD\nW\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD" }, { "input": "4 4\nW..S\nW..S\nW..S\nW..S", "output": "Yes\nWDDS\nWDDS\nWDDS\nWDDS" }, { "input": "4 4\nSSSS\n....\n....\nWWWW", "output": "Yes\nSSSS\nDDDD\nDDDD\nWWWW" }, { "input": "4 4\nWWWW\n....\n....\nSSSS", "output": "Yes\nWWWW\nDDDD\nDDDD\nSSSS" }, { "input": "4 4\nS..W\nS..W\nS..W\nS..W", "output": "Yes\nSDDW\nSDDW\nSDDW\nSDDW" }, { "input": "1 1\n.", "output": "Yes\nD" }, { "input": "1 1\nW", "output": "Yes\nW" }, { "input": "1 1\nS", "output": "Yes\nS" }, { "input": "4 2\n..\n..\n.W\n.S", "output": "No" }, { "input": "4 2\n..\n..\n.S\n.W", "output": "No" }, { "input": "4 2\n..\n..\nW.\nS.", "output": "No" }, { "input": "4 2\n..\n..\nS.\nW.", "output": "No" }, { "input": "2 4\n....\n..SW", "output": "No" }, { "input": "2 4\n....\n..WS", "output": "No" }, { "input": "1 2\nS.", "output": "Yes\nSD" } ]

1,520,697,157

1,057

Python 3

RUNTIME_ERROR

PRETESTS

0

46

5,632,000

r,c = map(int,input().split()) field = [input().split() for i in range(r)] ans = 1 for i in range(1,r): for j in range(1,c): if field[i][j] == "S": if field[i-1][j] == "W" or field[i][j-1] == "W": ans = 0 print("No") break if field[i][j] == "W": if field[i-1][j] == "S" or field[i][j-1] == "S": ans = 0 print("No") break for j in range(1,c): if field[0][j] == "S": if field[0][j-1] == "W": ans = 0 print("No") break if field[0][j] == "W": if field[0][j-1] == "S": ans = 0 print("No") break for i in range(1,r): if field[i][0] == "S": if field[i-1][0] == "W": ans = 0 print("No") break if field[i][0] == "W": if field[i-1][0] == "S": ans = 0 print("No") break if ans == 1: print("Yes") for i in range(1,r-1): for j in range(1,c-1): if field[i][j] == ".": print("D",end="") else: print(field[i][j],end="") print()

Title: Protect Sheep Time Limit: None seconds Memory Limit: None megabytes Problem Description: Bob is a farmer. He has a large pasture with many sheep. Recently, he has lost some of them due to wolf attacks. He thus decided to place some shepherd dogs in such a way that all his sheep are protected. The pasture is a rectangle consisting of *R*<=×<=*C* cells. Each cell is either empty, contains a sheep, a wolf or a dog. Sheep and dogs always stay in place, but wolves can roam freely around the pasture, by repeatedly moving to the left, right, up or down to a neighboring cell. When a wolf enters a cell with a sheep, it consumes it. However, no wolf can enter a cell with a dog. Initially there are no dogs. Place dogs onto the pasture in such a way that no wolf can reach any sheep, or determine that it is impossible. Note that since you have many dogs, you do not need to minimize their number. Input Specification: First line contains two integers *R* (1<=≤<=*R*<=≤<=500) and *C* (1<=≤<=*C*<=≤<=500), denoting the number of rows and the numbers of columns respectively. Each of the following *R* lines is a string consisting of exactly *C* characters, representing one row of the pasture. Here, 'S' means a sheep, 'W' a wolf and '.' an empty cell. Output Specification: If it is impossible to protect all sheep, output a single line with the word "No". Otherwise, output a line with the word "Yes". Then print *R* lines, representing the pasture after placing dogs. Again, 'S' means a sheep, 'W' a wolf, 'D' is a dog and '.' an empty space. You are not allowed to move, remove or add a sheep or a wolf. If there are multiple solutions, you may print any of them. You don't have to minimize the number of dogs. Demo Input: ['6 6\n..S...\n..S.W.\n.S....\n..W...\n...W..\n......\n', '1 2\nSW\n', '5 5\n.S...\n...S.\nS....\n...S.\n.S...\n'] Demo Output: ['Yes\n..SD..\n..SDW.\n.SD...\n.DW...\nDD.W..\n......\n', 'No\n', 'Yes\n.S...\n...S.\nS.D..\n...S.\n.S...\n'] Note: In the first example, we can split the pasture into two halves, one containing wolves and one containing sheep. Note that the sheep at (2,1) is safe, as wolves cannot move diagonally. In the second example, there are no empty spots to put dogs that would guard the lone sheep. In the third example, there are no wolves, so the task is very easy. We put a dog in the center to observe the peacefulness of the meadow, but the solution would be correct even without him.

```python r,c = map(int,input().split()) field = [input().split() for i in range(r)] ans = 1 for i in range(1,r): for j in range(1,c): if field[i][j] == "S": if field[i-1][j] == "W" or field[i][j-1] == "W": ans = 0 print("No") break if field[i][j] == "W": if field[i-1][j] == "S" or field[i][j-1] == "S": ans = 0 print("No") break for j in range(1,c): if field[0][j] == "S": if field[0][j-1] == "W": ans = 0 print("No") break if field[0][j] == "W": if field[0][j-1] == "S": ans = 0 print("No") break for i in range(1,r): if field[i][0] == "S": if field[i-1][0] == "W": ans = 0 print("No") break if field[i][0] == "W": if field[i-1][0] == "S": ans = 0 print("No") break if ans == 1: print("Yes") for i in range(1,r-1): for j in range(1,c-1): if field[i][j] == ".": print("D",end="") else: print(field[i][j],end="") print() ```

-1

99

A

Help Far Away Kingdom

PROGRAMMING

800

[ "strings" ]

A. Help Far Away Kingdom

2

256

In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there. Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this: - If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position. Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?

The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.

If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).

[ "0.0\n", "1.49\n", "1.50\n", "2.71828182845904523536\n", "3.14159265358979323846\n", "12345678901234567890.1\n", "123456789123456789.999\n" ]

[ "0", "1", "2", "3", "3", "12345678901234567890", "GOTO Vasilisa." ]

none

500

[ { "input": "0.0", "output": "0" }, { "input": "1.49", "output": "1" }, { "input": "1.50", "output": "2" }, { "input": "2.71828182845904523536", "output": "3" }, { "input": "3.14159265358979323846", "output": "3" }, { "input": "12345678901234567890.1", "output": "12345678901234567890" }, { "input": "123456789123456789.999", "output": "GOTO Vasilisa." }, { "input": "12345678901234567890.9", "output": "12345678901234567891" }, { "input": "123456789123456788.999", "output": "123456789123456789" }, { "input": "9.000", "output": "GOTO Vasilisa." }, { "input": "0.1", "output": "0" }, { "input": "0.2", "output": "0" }, { "input": "0.3", "output": "0" }, { "input": "0.4", "output": "0" }, { "input": "0.5", "output": "1" }, { "input": "0.6", "output": "1" }, { "input": "0.7", "output": "1" }, { "input": "0.8", "output": "1" }, { "input": "0.9", "output": "1" }, { "input": "1.0", "output": "1" }, { "input": "1.1", "output": "1" }, { "input": "1.2", "output": "1" }, { "input": "1.3", "output": "1" }, { "input": "1.4", "output": "1" }, { "input": "1.5", "output": "2" }, { "input": "1.6", "output": "2" }, { "input": "1.7", "output": "2" }, { "input": "1.8", "output": "2" }, { "input": "1.9", "output": "2" }, { "input": "2.0", "output": "2" }, { "input": "2.1", "output": "2" }, { "input": "2.2", "output": "2" }, { "input": "2.3", "output": "2" }, { "input": "2.4", "output": "2" }, { "input": "2.5", "output": "3" }, { "input": "2.6", "output": "3" }, { "input": "2.7", "output": "3" }, { "input": "2.8", "output": "3" }, { "input": "2.9", "output": "3" }, { "input": "3.0", "output": "3" }, { "input": "3.1", "output": "3" }, { "input": "3.2", "output": "3" }, { "input": "3.3", "output": "3" }, { "input": "3.4", "output": "3" }, { "input": "3.5", "output": "4" }, { "input": "3.6", "output": "4" }, { "input": "3.7", "output": "4" }, { "input": "3.8", "output": "4" }, { "input": "3.9", "output": "4" }, { "input": "4.0", "output": "4" }, { "input": "4.1", "output": "4" }, { "input": "4.2", "output": "4" }, { "input": "4.3", "output": "4" }, { "input": "4.4", "output": "4" }, { "input": "4.5", "output": "5" }, { "input": "4.6", "output": "5" }, { "input": "4.7", "output": "5" }, { "input": "4.8", "output": "5" }, { "input": "4.9", "output": "5" }, { "input": "5.0", "output": "5" }, { "input": "5.1", "output": "5" }, { "input": "5.2", "output": "5" }, { "input": "5.3", "output": "5" }, { "input": "5.4", "output": "5" }, { "input": "5.5", "output": "6" }, { "input": "5.6", "output": "6" }, { "input": "5.7", "output": "6" }, { "input": "5.8", "output": "6" }, { "input": "5.9", "output": "6" }, { "input": "6.0", "output": "6" }, { "input": "6.1", "output": "6" }, { "input": "6.2", "output": "6" }, { "input": "6.3", "output": "6" }, { "input": "6.4", "output": "6" }, { "input": "6.5", "output": "7" }, { "input": "6.6", "output": "7" }, { "input": "6.7", "output": "7" }, { "input": "6.8", "output": "7" }, { "input": "6.9", "output": "7" }, { "input": "7.0", "output": "7" }, { "input": "7.1", "output": "7" }, { "input": "7.2", "output": "7" }, { "input": "7.3", "output": "7" }, { "input": "7.4", "output": "7" }, { "input": "7.5", "output": "8" }, { "input": "7.6", "output": "8" }, { "input": "7.7", "output": "8" }, { "input": "7.8", "output": "8" }, { "input": "7.9", "output": "8" }, { "input": "8.0", "output": "8" }, { "input": "8.1", "output": "8" }, { "input": "8.2", "output": "8" }, { "input": "8.3", "output": "8" }, { "input": "8.4", "output": "8" }, { "input": "8.5", "output": "9" }, { "input": "8.6", "output": "9" }, { "input": "8.7", "output": "9" }, { "input": "8.8", "output": "9" }, { "input": "8.9", "output": "9" }, { "input": "9.0", "output": "GOTO Vasilisa." }, { "input": "9.1", "output": "GOTO Vasilisa." }, { "input": "9.2", "output": "GOTO Vasilisa." }, { "input": "9.3", "output": "GOTO Vasilisa." }, { "input": "9.4", "output": "GOTO Vasilisa." }, { "input": "9.5", "output": "GOTO Vasilisa." }, { "input": "9.6", "output": "GOTO Vasilisa." }, { "input": "9.7", "output": "GOTO Vasilisa." }, { "input": "9.8", "output": "GOTO Vasilisa." }, { "input": "9.9", "output": "GOTO Vasilisa." }, { "input": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098.1664915772983166314490532653577560222779830866949001942720729759794777105570672781798092416748052690224813237139640723361527601154465287615917169132637313918577673651098507390501962", "output": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098" }, { "input": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394.20211856263503281388748282682120712214711232598021393495443628276945042110862480888110959179019986486690931930108026302665438087068150666835901617457150158918705186964935221768346957536540345814875615118637945520917367155931078965", "output": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394" }, { "input": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616067.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616068" }, { "input": "718130341896330596635811874410345440628950330.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "718130341896330596635811874410345440628950331" }, { "input": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280722.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280723" }, { "input": "68289614863244584294178637364598054554769889.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "GOTO Vasilisa." }, { "input": "7536521504744364134984603189602839063535643888645969434165019366202558753840519.4999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "output": "GOTO Vasilisa." }, { "input": "646188694587964249318078225173.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "646188694587964249318078225174" }, { "input": "7017472758334494297677068672222822550374695787171163207025095950296957261530.50", "output": "7017472758334494297677068672222822550374695787171163207025095950296957261531" }, { "input": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774368.50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774369" }, { "input": "682500858233333594535201113441004740771119672961581796618069185960107115823662126812159957094407454522028503739299.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "GOTO Vasilisa." }, { "input": "41203422675619090661099806687619.49999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "output": "GOTO Vasilisa." } ]

1,623,697,169

2,147,483,647

Python 3

OK

TESTS

150

154

0

number=input() parse=str.rsplit(number,'.') if parse[0][len(parse[0])-1]=='9': print('GOTO Vasilisa.') else: if int(parse[1][0])<5: print(parse[0]) else: print(int(parse[0])+1)

Title: Help Far Away Kingdom Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there. Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this: - If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position. Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order? Input Specification: The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data. Output Specification: If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes). Demo Input: ['0.0\n', '1.49\n', '1.50\n', '2.71828182845904523536\n', '3.14159265358979323846\n', '12345678901234567890.1\n', '123456789123456789.999\n'] Demo Output: ['0', '1', '2', '3', '3', '12345678901234567890', 'GOTO Vasilisa.'] Note: none

```python number=input() parse=str.rsplit(number,'.') if parse[0][len(parse[0])-1]=='9': print('GOTO Vasilisa.') else: if int(parse[1][0])<5: print(parse[0]) else: print(int(parse[0])+1) ```

3.9615

902

A

Visiting a Friend

PROGRAMMING

1,100

[ "greedy", "implementation" ]

null

Pig is visiting a friend. Pig's house is located at point 0, and his friend's house is located at point *m* on an axis. Pig can use teleports to move along the axis. To use a teleport, Pig should come to a certain point (where the teleport is located) and choose where to move: for each teleport there is the rightmost point it can move Pig to, this point is known as the limit of the teleport. Formally, a teleport located at point *x* with limit *y* can move Pig from point *x* to any point within the segment [*x*;<=*y*], including the bounds. Determine if Pig can visit the friend using teleports only, or he should use his car.

The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*m*<=≤<=100) — the number of teleports and the location of the friend's house. The next *n* lines contain information about teleports. The *i*-th of these lines contains two integers *a**i* and *b**i* (0<=≤<=*a**i*<=≤<=*b**i*<=≤<=*m*), where *a**i* is the location of the *i*-th teleport, and *b**i* is its limit. It is guaranteed that *a**i*<=≥<=*a**i*<=-<=1 for every *i* (2<=≤<=*i*<=≤<=*n*).

Print "YES" if there is a path from Pig's house to his friend's house that uses only teleports, and "NO" otherwise. You can print each letter in arbitrary case (upper or lower).

[ "3 5\n0 2\n2 4\n3 5\n", "3 7\n0 4\n2 5\n6 7\n" ]

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

The first example is shown on the picture below: Pig can use the first teleport from his house (point 0) to reach point 2, then using the second teleport go from point 2 to point 3, then using the third teleport go from point 3 to point 5, where his friend lives. The second example is shown on the picture below: You can see that there is no path from Pig's house to his friend's house that uses only teleports.

500

[ { "input": "3 5\n0 2\n2 4\n3 5", "output": "YES" }, { "input": "3 7\n0 4\n2 5\n6 7", "output": "NO" }, { "input": "1 1\n0 0", "output": "NO" }, { "input": "30 10\n0 7\n1 2\n1 2\n1 4\n1 4\n1 3\n2 2\n2 4\n2 6\n2 9\n2 2\n3 5\n3 8\n4 8\n4 5\n4 6\n5 6\n5 7\n6 6\n6 9\n6 7\n6 9\n7 7\n7 7\n8 8\n8 8\n9 9\n9 9\n10 10\n10 10", "output": "NO" }, { "input": "30 100\n0 27\n4 82\n11 81\n14 32\n33 97\n33 34\n37 97\n38 52\n45 91\n49 56\n50 97\n57 70\n59 94\n59 65\n62 76\n64 65\n65 95\n67 77\n68 100\n71 73\n80 94\n81 92\n84 85\n85 100\n88 91\n91 95\n92 98\n92 98\n99 100\n100 100", "output": "YES" }, { "input": "70 10\n0 4\n0 4\n0 8\n0 9\n0 1\n0 5\n0 7\n1 3\n1 8\n1 8\n1 6\n1 6\n1 2\n1 3\n1 2\n1 3\n2 5\n2 4\n2 3\n2 4\n2 6\n2 2\n2 5\n2 7\n3 7\n3 4\n3 7\n3 4\n3 8\n3 4\n3 9\n3 3\n3 7\n3 9\n3 3\n3 9\n4 6\n4 7\n4 5\n4 7\n5 8\n5 5\n5 9\n5 7\n5 5\n6 6\n6 9\n6 7\n6 8\n6 9\n6 8\n7 7\n7 8\n7 7\n7 8\n8 9\n8 8\n8 9\n8 8\n9 9\n9 9\n9 9\n9 9\n9 9\n9 9\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "NO" }, { "input": "30 10\n0 7\n1 2\n1 2\n1 4\n1 4\n1 3\n2 2\n2 4\n2 6\n2 9\n2 2\n3 5\n3 8\n4 8\n4 5\n4 6\n5 6\n5 7\n6 6\n6 9\n6 7\n6 9\n7 7\n7 7\n8 10\n8 10\n9 9\n9 9\n10 10\n10 10", "output": "YES" }, { "input": "50 100\n0 95\n1 100\n1 38\n2 82\n5 35\n7 71\n8 53\n11 49\n15 27\n17 84\n17 75\n18 99\n18 43\n18 69\n21 89\n27 60\n27 29\n38 62\n38 77\n39 83\n40 66\n48 80\n48 100\n50 51\n50 61\n53 77\n53 63\n55 58\n56 68\n60 82\n62 95\n66 74\n67 83\n69 88\n69 81\n69 88\n69 98\n70 91\n70 76\n71 90\n72 99\n81 99\n85 87\n88 97\n88 93\n90 97\n90 97\n92 98\n98 99\n100 100", "output": "YES" }, { "input": "70 10\n0 4\n0 4\n0 8\n0 9\n0 1\n0 5\n0 7\n1 3\n1 8\n1 8\n1 10\n1 9\n1 6\n1 2\n1 3\n1 2\n2 6\n2 5\n2 4\n2 3\n2 10\n2 2\n2 6\n2 2\n3 10\n3 7\n3 7\n3 4\n3 7\n3 4\n3 8\n3 4\n3 10\n3 5\n3 3\n3 7\n4 8\n4 8\n4 9\n4 6\n5 7\n5 10\n5 7\n5 8\n5 5\n6 8\n6 9\n6 10\n6 6\n6 9\n6 7\n7 8\n7 9\n7 10\n7 10\n8 8\n8 8\n8 9\n8 10\n9 10\n9 9\n9 10\n9 10\n9 9\n9 9\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "YES" }, { "input": "85 10\n0 9\n0 4\n0 2\n0 5\n0 1\n0 8\n0 7\n1 2\n1 4\n1 5\n1 9\n1 1\n1 6\n1 6\n2 5\n2 7\n2 7\n2 7\n2 7\n3 4\n3 7\n3 9\n3 5\n3 3\n4 4\n4 6\n4 5\n5 6\n5 6\n5 6\n5 6\n5 7\n5 8\n5 5\n5 7\n5 8\n5 9\n5 8\n6 8\n6 7\n6 8\n6 9\n6 9\n6 6\n6 9\n6 7\n7 7\n7 7\n7 7\n7 8\n7 7\n7 8\n7 8\n7 9\n8 8\n8 8\n8 8\n8 8\n8 8\n8 9\n8 9\n9 9\n9 9\n9 9\n9 9\n9 9\n9 9\n9 9\n9 9\n9 9\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "NO" }, { "input": "30 40\n0 0\n4 8\n5 17\n7 32\n7 16\n8 16\n10 19\n12 22\n12 27\n13 21\n13 28\n13 36\n14 28\n14 18\n18 21\n21 26\n21 36\n22 38\n23 32\n24 30\n26 35\n29 32\n29 32\n31 34\n31 31\n33 33\n33 35\n35 40\n38 38\n40 40", "output": "NO" }, { "input": "70 100\n0 99\n1 87\n1 94\n1 4\n2 72\n3 39\n3 69\n4 78\n5 85\n7 14\n8 59\n12 69\n14 15\n14 76\n17 17\n19 53\n19 57\n19 21\n21 35\n21 83\n24 52\n24 33\n27 66\n27 97\n30 62\n30 74\n30 64\n32 63\n35 49\n37 60\n40 99\n40 71\n41 83\n42 66\n42 46\n45 83\n51 76\n53 69\n54 82\n54 96\n54 88\n55 91\n56 88\n58 62\n62 87\n64 80\n67 90\n67 69\n68 92\n72 93\n74 93\n77 79\n77 91\n78 97\n78 98\n81 85\n81 83\n81 83\n84 85\n86 88\n89 94\n89 92\n92 97\n96 99\n97 98\n97 99\n99 99\n100 100\n100 100\n100 100", "output": "NO" }, { "input": "1 10\n0 10", "output": "YES" }, { "input": "70 40\n0 34\n1 16\n3 33\n4 36\n4 22\n5 9\n5 9\n7 16\n8 26\n9 29\n9 25\n10 15\n10 22\n10 29\n10 20\n11 27\n11 26\n11 12\n12 19\n13 21\n14 31\n14 36\n15 34\n15 37\n16 21\n17 31\n18 22\n20 27\n20 32\n20 20\n20 29\n21 29\n21 34\n21 30\n22 40\n23 23\n23 28\n24 29\n25 38\n26 35\n27 37\n28 39\n28 33\n28 40\n28 33\n29 31\n29 33\n30 38\n30 36\n30 30\n30 38\n31 37\n31 35\n31 32\n31 36\n33 39\n33 40\n35 38\n36 38\n37 38\n37 40\n38 39\n38 40\n38 39\n39 39\n39 40\n40 40\n40 40\n40 40\n40 40", "output": "YES" }, { "input": "50 40\n0 9\n1 26\n1 27\n2 33\n2 5\n3 30\n4 28\n5 31\n5 27\n5 29\n7 36\n8 32\n8 13\n9 24\n10 10\n10 30\n11 26\n11 22\n11 40\n11 31\n12 26\n13 25\n14 32\n17 19\n21 29\n22 36\n24 27\n25 39\n25 27\n27 32\n27 29\n27 39\n27 29\n28 38\n30 38\n32 40\n32 38\n33 33\n33 40\n34 35\n34 34\n34 38\n34 38\n35 37\n36 39\n36 39\n37 37\n38 40\n39 39\n40 40", "output": "YES" }, { "input": "70 40\n0 34\n1 16\n3 33\n4 36\n4 22\n5 9\n5 9\n7 16\n8 26\n9 29\n9 25\n10 15\n10 22\n10 29\n10 20\n11 27\n11 26\n11 12\n12 19\n13 21\n14 31\n14 36\n15 34\n15 37\n16 21\n17 31\n18 22\n20 27\n20 32\n20 20\n20 29\n21 29\n21 34\n21 30\n22 22\n23 28\n23 39\n24 24\n25 27\n26 38\n27 39\n28 33\n28 39\n28 34\n28 33\n29 30\n29 35\n30 30\n30 38\n30 34\n30 31\n31 36\n31 31\n31 32\n31 38\n33 34\n33 34\n35 36\n36 38\n37 38\n37 39\n38 38\n38 38\n38 38\n39 39\n39 39\n40 40\n40 40\n40 40\n40 40", "output": "NO" }, { "input": "10 100\n0 34\n8 56\n17 79\n24 88\n28 79\n45 79\n48 93\n55 87\n68 93\n88 99", "output": "NO" }, { "input": "10 10\n0 2\n3 8\n3 5\n3 3\n3 9\n3 8\n5 7\n6 10\n7 10\n9 10", "output": "NO" }, { "input": "50 10\n0 2\n0 2\n0 6\n1 9\n1 3\n1 2\n1 6\n1 1\n1 1\n2 7\n2 6\n2 4\n3 9\n3 8\n3 8\n3 8\n3 6\n3 4\n3 7\n3 4\n3 6\n3 5\n4 8\n5 5\n5 7\n6 7\n6 6\n7 7\n7 7\n7 7\n7 8\n7 8\n8 8\n8 8\n8 9\n8 8\n8 9\n9 9\n9 9\n9 9\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "NO" }, { "input": "10 40\n0 21\n1 19\n4 33\n6 26\n8 39\n15 15\n20 24\n27 27\n29 39\n32 37", "output": "NO" }, { "input": "50 10\n0 2\n0 2\n0 6\n1 9\n1 3\n1 2\n1 6\n1 1\n1 1\n2 7\n2 6\n2 4\n3 9\n3 8\n3 8\n3 8\n3 6\n3 4\n3 7\n3 4\n3 6\n3 10\n4 6\n5 9\n5 5\n6 7\n6 10\n7 8\n7 7\n7 7\n7 7\n7 10\n8 8\n8 8\n8 10\n8 8\n8 8\n9 10\n9 10\n9 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "YES" }, { "input": "1 1\n0 1", "output": "YES" }, { "input": "30 40\n0 0\n4 8\n5 17\n7 32\n7 16\n8 16\n10 19\n12 22\n12 27\n13 21\n13 28\n13 36\n14 28\n14 18\n18 21\n21 26\n21 36\n22 38\n23 32\n24 30\n26 35\n29 32\n29 32\n31 34\n31 31\n33 33\n33 35\n35 36\n38 38\n40 40", "output": "NO" }, { "input": "30 100\n0 27\n4 82\n11 81\n14 32\n33 97\n33 34\n37 97\n38 52\n45 91\n49 56\n50 97\n57 70\n59 94\n59 65\n62 76\n64 65\n65 95\n67 77\n68 82\n71 94\n80 90\n81 88\n84 93\n85 89\n88 92\n91 97\n92 99\n92 97\n99 99\n100 100", "output": "NO" }, { "input": "10 100\n0 34\n8 56\n17 79\n24 88\n28 79\n45 79\n48 93\n55 87\n68 93\n79 100", "output": "YES" }, { "input": "10 40\n0 21\n1 19\n4 33\n6 26\n8 39\n15 15\n20 24\n27 27\n29 39\n37 40", "output": "YES" }, { "input": "85 10\n0 9\n0 4\n0 2\n0 5\n0 1\n0 8\n0 7\n1 2\n1 10\n1 2\n1 5\n1 10\n1 8\n1 1\n2 8\n2 7\n2 5\n2 5\n2 7\n3 5\n3 7\n3 5\n3 4\n3 7\n4 7\n4 8\n4 6\n5 7\n5 10\n5 5\n5 6\n5 6\n5 6\n5 6\n5 7\n5 8\n5 5\n5 7\n6 10\n6 9\n6 7\n6 10\n6 8\n6 7\n6 10\n6 10\n7 8\n7 9\n7 8\n7 8\n7 8\n7 8\n7 7\n7 7\n8 8\n8 8\n8 10\n8 9\n8 9\n8 9\n8 9\n9 9\n9 10\n9 9\n9 9\n9 9\n9 9\n9 10\n9 10\n9 9\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10\n10 10", "output": "YES" }, { "input": "50 100\n0 95\n1 7\n1 69\n2 83\n5 67\n7 82\n8 31\n11 25\n15 44\n17 75\n17 27\n18 43\n18 69\n18 40\n21 66\n27 29\n27 64\n38 77\n38 90\n39 52\n40 60\n48 91\n48 98\n50 89\n50 63\n53 54\n53 95\n55 76\n56 59\n60 96\n62 86\n66 70\n67 77\n69 88\n69 98\n69 80\n69 95\n70 74\n70 77\n71 99\n72 73\n81 87\n85 99\n88 96\n88 91\n90 97\n90 99\n92 92\n98 99\n100 100", "output": "NO" }, { "input": "50 40\n0 9\n1 26\n1 27\n2 33\n2 5\n3 30\n4 28\n5 31\n5 27\n5 29\n7 36\n8 32\n8 13\n9 24\n10 10\n10 30\n11 26\n11 22\n11 35\n11 23\n12 36\n13 31\n14 31\n17 17\n21 25\n22 33\n24 26\n25 32\n25 25\n27 39\n27 29\n27 34\n27 32\n28 34\n30 36\n32 37\n32 33\n33 35\n33 33\n34 38\n34 38\n34 36\n34 36\n35 36\n36 36\n36 39\n37 37\n38 39\n39 39\n40 40", "output": "NO" }, { "input": "10 10\n0 2\n3 8\n3 5\n3 3\n3 9\n3 8\n5 7\n6 9\n7 7\n9 9", "output": "NO" }, { "input": "70 100\n0 99\n1 87\n1 94\n1 4\n2 72\n3 39\n3 69\n4 78\n5 85\n7 14\n8 59\n12 69\n14 15\n14 76\n17 17\n19 53\n19 57\n19 21\n21 35\n21 83\n24 52\n24 33\n27 66\n27 97\n30 62\n30 74\n30 64\n32 63\n35 49\n37 60\n40 99\n40 71\n41 83\n42 66\n42 46\n45 83\n51 76\n53 69\n54 82\n54 96\n54 88\n55 91\n56 88\n58 62\n62 87\n64 80\n67 90\n67 69\n68 92\n72 93\n74 93\n77 79\n77 91\n78 97\n78 98\n81 85\n81 83\n81 83\n84 85\n86 88\n89 94\n89 100\n92 97\n96 96\n97 98\n97 100\n99 100\n100 100\n100 100\n100 100", "output": "YES" }, { "input": "2 2\n0 2\n0 1", "output": "YES" }, { "input": "2 100\n0 49\n50 100", "output": "NO" }, { "input": "2 100\n0 50\n50 100", "output": "YES" }, { "input": "10 100\n0 10\n10 20\n20 30\n30 40\n40 50\n50 60\n60 70\n70 80\n80 90\n90 100", "output": "YES" }, { "input": "100 10\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 10", "output": "YES" }, { "input": "1 4\n1 4", "output": "NO" }, { "input": "3 5\n0 2\n2 5\n3 4", "output": "YES" }, { "input": "2 5\n0 5\n1 2", "output": "YES" }, { "input": "5 5\n0 2\n0 2\n3 5\n3 5\n3 5", "output": "NO" }, { "input": "4 10\n0 3\n2 10\n4 10\n5 7", "output": "YES" }, { "input": "3 8\n0 0\n1 8\n2 8", "output": "NO" }, { "input": "6 8\n0 3\n1 5\n2 3\n5 6\n6 7\n7 8", "output": "YES" } ]

1,581,247,434

2,147,483,647

Python 3

OK

TESTS

55

108

0

I = lambda: map(int, input().split()) n, m = I() x = 0 for _ in range(n): a, b = I() if x < a: break x = max(x, b) print('NO' if x < m else 'YES')

Title: Visiting a Friend Time Limit: None seconds Memory Limit: None megabytes Problem Description: Pig is visiting a friend. Pig's house is located at point 0, and his friend's house is located at point *m* on an axis. Pig can use teleports to move along the axis. To use a teleport, Pig should come to a certain point (where the teleport is located) and choose where to move: for each teleport there is the rightmost point it can move Pig to, this point is known as the limit of the teleport. Formally, a teleport located at point *x* with limit *y* can move Pig from point *x* to any point within the segment [*x*;<=*y*], including the bounds. Determine if Pig can visit the friend using teleports only, or he should use his car. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*m*<=≤<=100) — the number of teleports and the location of the friend's house. The next *n* lines contain information about teleports. The *i*-th of these lines contains two integers *a**i* and *b**i* (0<=≤<=*a**i*<=≤<=*b**i*<=≤<=*m*), where *a**i* is the location of the *i*-th teleport, and *b**i* is its limit. It is guaranteed that *a**i*<=≥<=*a**i*<=-<=1 for every *i* (2<=≤<=*i*<=≤<=*n*). Output Specification: Print "YES" if there is a path from Pig's house to his friend's house that uses only teleports, and "NO" otherwise. You can print each letter in arbitrary case (upper or lower). Demo Input: ['3 5\n0 2\n2 4\n3 5\n', '3 7\n0 4\n2 5\n6 7\n'] Demo Output: ['YES\n', 'NO\n'] Note: The first example is shown on the picture below: Pig can use the first teleport from his house (point 0) to reach point 2, then using the second teleport go from point 2 to point 3, then using the third teleport go from point 3 to point 5, where his friend lives. The second example is shown on the picture below: You can see that there is no path from Pig's house to his friend's house that uses only teleports.

```python I = lambda: map(int, input().split()) n, m = I() x = 0 for _ in range(n): a, b = I() if x < a: break x = max(x, b) print('NO' if x < m else 'YES') ```

3

615

A

Bulbs

PROGRAMMING

800

[ "implementation" ]

null

Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is pressed, it turns on all the bulbs it's connected to. Can Vasya light up all the bulbs? If Vasya presses the button such that some bulbs connected to it are already turned on, they do not change their state, i.e. remain turned on.

The first line of the input contains integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of buttons and the number of bulbs respectively. Each of the next *n* lines contains *x**i* (0<=≤<=*x**i*<=≤<=*m*) — the number of bulbs that are turned on by the *i*-th button, and then *x**i* numbers *y**ij* (1<=≤<=*y**ij*<=≤<=*m*) — the numbers of these bulbs.

If it's possible to turn on all *m* bulbs print "YES", otherwise print "NO".

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

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

In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp.

500

[ { "input": "3 4\n2 1 4\n3 1 3 1\n1 2", "output": "YES" }, { "input": "3 3\n1 1\n1 2\n1 1", "output": "NO" }, { "input": "3 4\n1 1\n1 2\n1 3", "output": "NO" }, { "input": "1 5\n5 1 2 3 4 5", "output": "YES" }, { "input": "1 5\n5 4 4 1 2 3", "output": "NO" }, { "input": "1 5\n5 1 1 1 1 5", "output": "NO" }, { "input": "2 5\n4 3 1 4 2\n4 2 3 4 5", "output": "YES" }, { "input": "5 7\n2 6 7\n5 1 1 1 1 1\n3 6 5 4\n0\n4 4 3 2 1", "output": "YES" }, { "input": "100 100\n0\n0\n0\n1 53\n0\n0\n1 34\n1 54\n0\n1 14\n0\n1 33\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1 82\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1 34\n0\n0\n1 26\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1 34\n0\n0\n0\n0\n0\n1 3\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n1 40\n0\n0\n0\n1 26\n0\n0\n0\n0\n0\n1 97\n0\n1 5\n0\n0\n0\n0\n0", "output": "NO" }, { "input": "100 100\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0", "output": "NO" }, { "input": "5 6\n3 1 2 6\n3 1 2 6\n1 1\n2 3 4\n3 1 5 6", "output": "YES" }, { "input": "5 2\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "NO" }, { "input": "1 4\n3 1 2 3", "output": "NO" }, { "input": "1 4\n3 2 3 4", "output": "NO" }, { "input": "2 4\n3 2 3 4\n1 1", "output": "YES" }, { "input": "2 4\n3 1 2 3\n1 4", "output": "YES" }, { "input": "5 1\n0\n0\n0\n0\n0", "output": "NO" }, { "input": "1 1\n0", "output": "NO" }, { "input": "1 10\n10 1 2 3 4 5 6 7 8 9 10", "output": "YES" }, { "input": "1 1\n1 1", "output": "YES" }, { "input": "1 100\n99 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 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", "output": "NO" }, { "input": "1 3\n3 1 2 1", "output": "NO" }, { "input": "1 100\n100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 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": "YES" } ]

1,662,981,780

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

31

0

n,m = [int(_) for _ in input().split()] aa = [] bb = [] s = 0 for i in range(n): aa = input().split() for j in aa[1:]: bb.append(j) for k in range(m): if k not in aa: s = 1 if s == 1: print('NO') else: print('YES')

Title: Bulbs Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya wants to turn on Christmas lights consisting of *m* bulbs. Initially, all bulbs are turned off. There are *n* buttons, each of them is connected to some set of bulbs. Vasya can press any of these buttons. When the button is pressed, it turns on all the bulbs it's connected to. Can Vasya light up all the bulbs? If Vasya presses the button such that some bulbs connected to it are already turned on, they do not change their state, i.e. remain turned on. Input Specification: The first line of the input contains integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of buttons and the number of bulbs respectively. Each of the next *n* lines contains *x**i* (0<=≤<=*x**i*<=≤<=*m*) — the number of bulbs that are turned on by the *i*-th button, and then *x**i* numbers *y**ij* (1<=≤<=*y**ij*<=≤<=*m*) — the numbers of these bulbs. Output Specification: If it's possible to turn on all *m* bulbs print "YES", otherwise print "NO". Demo Input: ['3 4\n2 1 4\n3 1 3 1\n1 2\n', '3 3\n1 1\n1 2\n1 1\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first sample you can press each button once and turn on all the bulbs. In the 2 sample it is impossible to turn on the 3-rd lamp.

```python n,m = [int(_) for _ in input().split()] aa = [] bb = [] s = 0 for i in range(n): aa = input().split() for j in aa[1:]: bb.append(j) for k in range(m): if k not in aa: s = 1 if s == 1: print('NO') else: print('YES') ```

0

982

B

Bus of Characters

PROGRAMMING

1,300

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

null

In the Bus of Characters there are $n$ rows of seat, each having $2$ seats. The width of both seats in the $i$-th row is $w_i$ centimeters. All integers $w_i$ are distinct. Initially the bus is empty. On each of $2n$ stops one passenger enters the bus. There are two types of passengers: - an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it; - an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it. You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.

The first line contains a single integer $n$ ($1 \le n \le 200\,000$) — the number of rows in the bus. The second line contains the sequence of integers $w_1, w_2, \dots, w_n$ ($1 \le w_i \le 10^{9}$), where $w_i$ is the width of each of the seats in the $i$-th row. It is guaranteed that all $w_i$ are distinct. The third line contains a string of length $2n$, consisting of digits '0' and '1' — the description of the order the passengers enter the bus. If the $j$-th character is '0', then the passenger that enters the bus on the $j$-th stop is an introvert. If the $j$-th character is '1', the the passenger that enters the bus on the $j$-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal $n$), and for each extrovert there always is a suitable row.

Print $2n$ integers — the rows the passengers will take. The order of passengers should be the same as in input.

[ "2\n3 1\n0011\n", "6\n10 8 9 11 13 5\n010010011101\n" ]

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

In the first example the first passenger (introvert) chooses the row $2$, because it has the seats with smallest width. The second passenger (introvert) chooses the row $1$, because it is the only empty row now. The third passenger (extrovert) chooses the row $1$, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row $2$, because it is the only row with an empty place.

1,000

[ { "input": "2\n3 1\n0011", "output": "2 1 1 2 " }, { "input": "6\n10 8 9 11 13 5\n010010011101", "output": "6 6 2 3 3 1 4 4 1 2 5 5 " }, { "input": "1\n1\n01", "output": "1 1 " }, { "input": "1\n1000000\n01", "output": "1 1 " }, { "input": "2\n1 1000000\n0011", "output": "1 2 2 1 " }, { "input": "2\n1000000000 1\n0101", "output": "2 2 1 1 " }, { "input": "2\n1000000000 999999999\n0011", "output": "2 1 1 2 " }, { "input": "10\n24 53 10 99 83 9 15 62 33 47\n00100000000111111111", "output": "6 3 3 7 1 9 10 2 8 5 4 4 5 8 2 10 9 1 7 6 " } ]

1,539,146,005

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

93

0

n = input() n = int(n) l=[] for i in range(n): a,b = input().split() a = int(a) b = int(b) l.append((a,b)) #print (l) ans=['x']*n sum_a=0 sum_g=0 for i in range(n): if abs((sum_a+l[i][0])-sum_g) <= 500: sum_a+=l[i][0] ans[i] = "A" else: if abs((sum_g+l[i][1])-sum_a) <= 500: sum_g+=l[i][1] ans[i] = "G" print ("".join(ans))

Title: Bus of Characters Time Limit: None seconds Memory Limit: None megabytes Problem Description: In the Bus of Characters there are $n$ rows of seat, each having $2$ seats. The width of both seats in the $i$-th row is $w_i$ centimeters. All integers $w_i$ are distinct. Initially the bus is empty. On each of $2n$ stops one passenger enters the bus. There are two types of passengers: - an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it; - an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it. You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take. Input Specification: The first line contains a single integer $n$ ($1 \le n \le 200\,000$) — the number of rows in the bus. The second line contains the sequence of integers $w_1, w_2, \dots, w_n$ ($1 \le w_i \le 10^{9}$), where $w_i$ is the width of each of the seats in the $i$-th row. It is guaranteed that all $w_i$ are distinct. The third line contains a string of length $2n$, consisting of digits '0' and '1' — the description of the order the passengers enter the bus. If the $j$-th character is '0', then the passenger that enters the bus on the $j$-th stop is an introvert. If the $j$-th character is '1', the the passenger that enters the bus on the $j$-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal $n$), and for each extrovert there always is a suitable row. Output Specification: Print $2n$ integers — the rows the passengers will take. The order of passengers should be the same as in input. Demo Input: ['2\n3 1\n0011\n', '6\n10 8 9 11 13 5\n010010011101\n'] Demo Output: ['2 1 1 2 \n', '6 6 2 3 3 1 4 4 1 2 5 5 \n'] Note: In the first example the first passenger (introvert) chooses the row $2$, because it has the seats with smallest width. The second passenger (introvert) chooses the row $1$, because it is the only empty row now. The third passenger (extrovert) chooses the row $1$, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row $2$, because it is the only row with an empty place.

```python n = input() n = int(n) l=[] for i in range(n): a,b = input().split() a = int(a) b = int(b) l.append((a,b)) #print (l) ans=['x']*n sum_a=0 sum_g=0 for i in range(n): if abs((sum_a+l[i][0])-sum_g) <= 500: sum_a+=l[i][0] ans[i] = "A" else: if abs((sum_g+l[i][1])-sum_a) <= 500: sum_g+=l[i][1] ans[i] = "G" print ("".join(ans)) ```

-1

271

A

Beautiful Year

PROGRAMMING

800

[ "brute force" ]

null

It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits. Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has only distinct digits.

The single line contains integer *y* (1000<=≤<=*y*<=≤<=9000) — the year number.

Print a single integer — the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists.

[ "1987\n", "2013\n" ]

[ "2013\n", "2014\n" ]

none

500

[ { "input": "1987", "output": "2013" }, { "input": "2013", "output": "2014" }, { "input": "1000", "output": "1023" }, { "input": "1001", "output": "1023" }, { "input": "1234", "output": "1235" }, { "input": "5555", "output": "5601" }, { "input": "9000", "output": "9012" }, { "input": "1111", "output": "1203" }, { "input": "8999", "output": "9012" }, { "input": "4572", "output": "4573" }, { "input": "6666", "output": "6701" }, { "input": "2001", "output": "2013" }, { "input": "3000", "output": "3012" }, { "input": "7712", "output": "7801" }, { "input": "8088", "output": "8091" }, { "input": "1594", "output": "1596" }, { "input": "6016", "output": "6017" }, { "input": "8800", "output": "8901" }, { "input": "3331", "output": "3401" }, { "input": "5090", "output": "5091" }, { "input": "2342", "output": "2345" }, { "input": "2334", "output": "2340" }, { "input": "1123", "output": "1203" }, { "input": "8989", "output": "9012" }, { "input": "8977", "output": "9012" }, { "input": "6869", "output": "6870" }, { "input": "8999", "output": "9012" } ]

1,690,904,897

2,147,483,647

Python 3

OK

TESTS

27

92

0

y = input() while True: y = str(int(y)+1) a = '' for i in range(4): if y[i] not in a: a+=y[i] if len(y)==len(a): break print(y)

Title: Beautiful Year Time Limit: None seconds Memory Limit: None megabytes Problem Description: It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits. Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has only distinct digits. Input Specification: The single line contains integer *y* (1000<=≤<=*y*<=≤<=9000) — the year number. Output Specification: Print a single integer — the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists. Demo Input: ['1987\n', '2013\n'] Demo Output: ['2013\n', '2014\n'] Note: none

```python y = input() while True: y = str(int(y)+1) a = '' for i in range(4): if y[i] not in a: a+=y[i] if len(y)==len(a): break print(y) ```

3

388

A

Fox and Box Accumulation

PROGRAMMING

1,400

[ "greedy", "sortings" ]

null

Fox Ciel has *n* boxes in her room. They have the same size and weight, but they might have different strength. The *i*-th box can hold at most *x**i* boxes on its top (we'll call *x**i* the strength of the box). Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile. Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than *x**i* boxes on the top of *i*-th box. What is the minimal number of piles she needs to construct?

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). The next line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=≤<=100).

Output a single integer — the minimal possible number of piles.

[ "3\n0 0 10\n", "5\n0 1 2 3 4\n", "4\n0 0 0 0\n", "9\n0 1 0 2 0 1 1 2 10\n" ]

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

In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2. In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).

500

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

1,615,180,690

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

9

46

0

def fox_box(): n = int(input()) arr = list(map(int, input().split())) ans = arr.count(0) if ans == 0: ans = 1 print(ans) fox_box()

Title: Fox and Box Accumulation Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fox Ciel has *n* boxes in her room. They have the same size and weight, but they might have different strength. The *i*-th box can hold at most *x**i* boxes on its top (we'll call *x**i* the strength of the box). Since all the boxes have the same size, Ciel cannot put more than one box directly on the top of some box. For example, imagine Ciel has three boxes: the first has strength 2, the second has strength 1 and the third has strength 1. She cannot put the second and the third box simultaneously directly on the top of the first one. But she can put the second box directly on the top of the first one, and then the third box directly on the top of the second one. We will call such a construction of boxes a pile. Fox Ciel wants to construct piles from all the boxes. Each pile will contain some boxes from top to bottom, and there cannot be more than *x**i* boxes on the top of *i*-th box. What is the minimal number of piles she needs to construct? Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). The next line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=≤<=100). Output Specification: Output a single integer — the minimal possible number of piles. Demo Input: ['3\n0 0 10\n', '5\n0 1 2 3 4\n', '4\n0 0 0 0\n', '9\n0 1 0 2 0 1 1 2 10\n'] Demo Output: ['2\n', '1\n', '4\n', '3\n'] Note: In example 1, one optimal way is to build 2 piles: the first pile contains boxes 1 and 3 (from top to bottom), the second pile contains only box 2. In example 2, we can build only 1 pile that contains boxes 1, 2, 3, 4, 5 (from top to bottom).

```python def fox_box(): n = int(input()) arr = list(map(int, input().split())) ans = arr.count(0) if ans == 0: ans = 1 print(ans) fox_box() ```

0

939

F

Cutlet

PROGRAMMING

2,400

[ "data structures", "dp" ]

null

Arkady wants to have a dinner. He has just returned from a shop where he has bought a semifinished cutlet. He only needs to fry it. The cutlet should be fried for 2*n* seconds, in particular, it should be fried for *n* seconds on one side and *n* seconds on the other side. Arkady has already got a frying pan and turn on fire, but understood that maybe he won't be able to flip the cutlet exactly after *n* seconds after the beginning of cooking. Arkady is too busy with sorting sticker packs in his favorite messenger and can flip the cutlet only in some periods of time. Namely, there are *k* periods of time in which he can do it, the *i*-th of them is an interval of time from *l**i* seconds after he starts cooking till *r**i* seconds, inclusive. Arkady decided that it's not required to flip the cutlet exactly in the middle of cooking, instead, he will flip it several times in such a way that the cutlet will be fried exactly *n* seconds on one side and *n* seconds on the other side in total. Help Arkady and find out if it's possible for him to cook the cutlet, if he is able to flip the cutlet only in given periods of time; and if yes, find the minimum number of flips he needs to cook the cutlet.

The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=100) — the number of seconds the cutlet should be cooked on each side and number of periods of time in which Arkady can flip it. The next *k* lines contain descriptions of these intervals. Each line contains two integers *l**i* and *r**i* (0<=≤<=*l**i*<=≤<=*r**i*<=≤<=2·*n*), meaning that Arkady can flip the cutlet in any moment starting from *l**i* seconds after the beginning of cooking and finishing at *r**i* seconds after beginning of cooking. In particular, if *l**i*<==<=*r**i* then Arkady can flip the cutlet only in the moment *l**i*<==<=*r**i*. It's guaranteed that *l**i*<=><=*r**i*<=-<=1 for all 2<=≤<=*i*<=≤<=*k*.

Output "Hungry" if Arkady won't be able to fry the cutlet for exactly *n* seconds on one side and exactly *n* seconds on the other side. Otherwise, output "Full" in the first line, and the minimum number of times he should flip the cutlet in the second line.

[ "10 2\n3 5\n11 13\n", "10 3\n3 5\n9 10\n11 13\n", "20 1\n3 19\n" ]

[ "Full\n2\n", "Full\n1\n", "Hungry\n" ]

In the first example Arkady should flip the cutlet in time moment 3 seconds after he starts cooking and in time moment 13 seconds after he starts cooking. In the second example, Arkady can flip the cutlet at 10 seconds after he starts cooking.

2,750

[ { "input": "10 2\n3 5\n11 13", "output": "Full\n2" }, { "input": "10 3\n3 5\n9 10\n11 13", "output": "Full\n1" }, { "input": "20 1\n3 19", "output": "Hungry" }, { "input": "10 1\n0 20", "output": "Full\n1" }, { "input": "10 1\n0 1", "output": "Hungry" }, { "input": "10 1\n10 10", "output": "Full\n1" }, { "input": "10 2\n4 4\n14 14", "output": "Full\n2" }, { "input": "1 1\n0 0", "output": "Hungry" }, { "input": "10 5\n3 3\n5 5\n8 8\n13 13\n16 16", "output": "Full\n2" }, { "input": "10 7\n0 0\n2 6\n8 10\n12 12\n14 14\n17 17\n19 19", "output": "Full\n1" }, { "input": "100 10\n18 18\n30 30\n37 37\n59 59\n83 83\n90 90\n141 141\n149 149\n173 173\n189 189", "output": "Full\n3" }, { "input": "100000 3\n0 50000\n99999 99999\n199998 199998", "output": "Full\n3" }, { "input": "100000 17\n7247 18957\n56758 64403\n79823 83648\n83649 83715\n83732 84946\n84947 84963\n84964 84968\n84970 84978\n84982 84991\n84992 87130\n172421 176513\n176514 176596\n176629 176689\n176692 177213\n197692 199830\n199831 199993\n199997 200000", "output": "Full\n3" }, { "input": "100000 20\n1425 1425\n14050 14050\n17375 17375\n17609 17609\n22704 22704\n25922 25922\n37894 37894\n92308 92308\n94002 94002\n99619 99619\n103208 103208\n110194 110194\n114468 114468\n141214 141214\n145980 145980\n159553 159553\n168441 168441\n169633 169633\n182674 182674\n195738 195738", "output": "Full\n8" }, { "input": "100000 3\n54962 59962\n98273 103273\n174042 179042", "output": "Full\n1" }, { "input": "100000 20\n5000 9999\n14999 19998\n24998 29997\n34997 39996\n44996 49995\n54995 59994\n64994 69993\n74993 79992\n84992 89991\n94991 99990\n104990 109989\n114989 119988\n124988 129987\n134987 139986\n144986 149985\n154985 159984\n164984 169983\n174983 179982\n184982 189981\n194981 199980", "output": "Full\n2" }, { "input": "100 19\n1 1\n14 14\n16 16\n36 36\n45 45\n51 51\n67 67\n77 77\n90 90\n106 106\n116 116\n129 129\n142 142\n153 153\n168 169\n180 180\n183 183\n185 185\n191 191", "output": "Full\n2" }, { "input": "1000 10\n1 1\n122 122\n502 502\n687 687\n731 731\n737 737\n825 825\n878 878\n1159 1159\n1396 1396", "output": "Hungry" }, { "input": "1000 4\n184 196\n726 737\n1114 1131\n1571 1581", "output": "Full\n4" }, { "input": "1000 6\n292 304\n1135 1147\n1338 1350\n1472 1491\n1720 1732\n1773 1790", "output": "Full\n4" }, { "input": "1000 5\n509 528\n540 551\n1332 1347\n1732 1743\n1777 1787", "output": "Full\n3" }, { "input": "100000 1\n0 200000", "output": "Full\n1" }, { "input": "100000 1\n100000 100000", "output": "Full\n1" }, { "input": "100000 2\n234 234\n99766 99766", "output": "Hungry" }, { "input": "100000 2\n0 99999\n100001 200000", "output": "Full\n2" }, { "input": "511 18\n1 1\n2 2\n4 4\n6 6\n10 10\n14 14\n22 22\n30 30\n46 46\n62 62\n94 94\n126 126\n190 190\n254 254\n382 382\n510 510\n766 766\n1022 1022", "output": "Full\n9" }, { "input": "1000 20\n225 225\n429 429\n560 560\n632 632\n650 650\n704 704\n768 768\n797 797\n983 983\n991 991\n1046 1046\n1082 1082\n1233 1233\n1366 1366\n1394 1394\n1456 1456\n1459 1459\n1519 1519\n1967 1967\n1996 1996", "output": "Full\n4" }, { "input": "10000 10\n479 479\n1024 1024\n4388 4388\n4810 4810\n6557 6557\n9697 9697\n11393 11393\n12124 12124\n14600 14600\n17536 17536", "output": "Full\n7" }, { "input": "10000 20\n746 746\n1145 1145\n1897 1897\n4254 4254\n6893 6893\n7434 7434\n8130 8130\n9755 9755\n10033 10033\n10636 10636\n11342 11342\n11651 11651\n12005 12005\n14567 14567\n15196 15196\n15947 15947\n16385 16385\n17862 17862\n18540 18540\n18948 18948", "output": "Full\n5" }, { "input": "10000 12\n1407 1407\n1878 1878\n4636 4636\n5055 5055\n5640 5640\n6379 6379\n6490 6490\n10303 10303\n13028 13028\n13578 13578\n18040 18040\n19477 19477", "output": "Full\n8" }, { "input": "55 20\n1 1\n2 2\n4 4\n6 6\n9 9\n12 12\n16 16\n20 20\n25 25\n30 30\n36 36\n42 42\n49 49\n56 56\n64 64\n72 72\n81 81\n90 90\n100 100\n110 110", "output": "Full\n2" }, { "input": "6 6\n3 3\n5 5\n7 7\n8 8\n9 9\n12 12", "output": "Full\n2" }, { "input": "100000 4\n0 40000\n41000 80000\n99999 99999\n199998 199998", "output": "Full\n3" }, { "input": "100000 12\n1 1751\n23999 25007\n33798 37031\n37117 37426\n37428 37436\n37437 40132\n48648 51062\n51071 51743\n51763 54643\n116077 119442\n190627 195558\n197662 200000", "output": "Full\n3" }, { "input": "100000 14\n213 1640\n6778 14112\n62548 68221\n68495 68864\n68887 68889\n68890 68894\n68896 68988\n69034 71515\n73645 77764\n80059 81085\n81086 81589\n136294 151585\n194157 199448\n199559 200000", "output": "Full\n3" }, { "input": "100000 16\n1 7\n9 307\n405 5574\n50346 54067\n54069 54100\n54101 55097\n56093 61752\n77951 78580\n78585 80749\n85191 87424\n87485 87490\n87491 87694\n87715 94544\n136369 138773\n140012 143346\n195045 200000", "output": "Full\n3" }, { "input": "100000 2\n60000 81999\n120000 140000", "output": "Full\n3" }, { "input": "100000 12\n65418 84245\n86341 90510\n135508 139243\n139287 139389\n139393 139437\n139440 147819\n198670 199954\n199955 199963\n199968 199979\n199980 199985\n199986 199997\n199999 200000", "output": "Full\n3" }, { "input": "100000 11\n42866 45922\n45923 49957\n63729 84014\n115856 125872\n125988 126003\n126004 129147\n131201 134555\n183782 189949\n189955 189967\n189968 197363\n198291 200000", "output": "Full\n2" }, { "input": "100000 8\n69804 76492\n76493 78217\n129407 137816\n137817 139388\n142035 152201\n153150 162227\n196326 199996\n200000 200000", "output": "Full\n3" }, { "input": "100000 18\n16 46\n47 154\n445 526\n537 571\n572 573\n574 580\n582 5922\n70364 73612\n73625 80571\n81628 88168\n122927 127021\n127027 127056\n127204 127409\n127410 134203\n145658 155259\n155270 163684\n198635 199999\n200000 200000", "output": "Full\n3" }, { "input": "100000 15\n10387 11995\n12012 12188\n12297 14393\n14589 15140\n17771 26488\n68905 72975\n73509 73881\n73886 73886\n73887 79513\n143598 147981\n150145 152841\n189148 199265\n199597 199724\n199772 199994\n199999 200000", "output": "Full\n3" }, { "input": "100000 12\n589 2312\n2349 12326\n12499 12759\n12796 21228\n70394 77570\n77571 86238\n133314 135096\n135104 135113\n135118 135128\n135135 137324\n190272 199989\n199998 200000", "output": "Full\n4" }, { "input": "100000 14\n3182 5382\n5847 10785\n26776 36809\n36961 39608\n65919 72524\n73806 75651\n79173 81114\n81115 84538\n112469 113763\n113767 113771\n113777 113790\n113792 119192\n193181 198259\n199859 200000", "output": "Full\n3" }, { "input": "100000 18\n3 535\n551 7905\n74333 87542\n124358 135027\n135108 142254\n142265 143895\n144091 145169\n145255 145273\n145275 145275\n145279 145295\n145302 145336\n145337 145348\n145350 145429\n145430 145431\n145441 145459\n145460 147266\n198447 199999\n200000 200000", "output": "Full\n3" }, { "input": "100000 8\n244 293\n379 886\n68058 75221\n102015 112569\n140672 146088\n146090 146284\n146289 149770\n197995 200000", "output": "Full\n3" }, { "input": "100000 5\n18547 19547\n24249 25249\n58262 59262\n102965 103965\n109453 110453", "output": "Full\n5" }, { "input": "100000 9\n5071 6797\n6916 13337\n64413 72188\n72231 72441\n72458 74946\n122835 133275\n133562 134079\n134098 141894\n195543 200000", "output": "Full\n4" }, { "input": "100000 6\n8828 9828\n81857 82857\n88071 89071\n94010 95010\n141844 142844\n165669 166669", "output": "Full\n6" }, { "input": "100000 7\n5645 6645\n30563 31563\n75140 76140\n107764 108764\n108910 109910\n162122 163122\n169774 170774", "output": "Full\n3" }, { "input": "100000 7\n17993 18993\n30906 31906\n49354 50354\n60696 61696\n106638 107638\n188177 189177\n190333 191333", "output": "Full\n3" }, { "input": "100000 18\n299 2359\n2646 3120\n3122 3123\n3124 4562\n5401 5753\n5754 10619\n72022 81017\n81018 81019\n81020 81020\n81021 81573\n82730 83638\n83643 83648\n83663 83668\n83669 83673\n83678 83681\n83686 91779\n156345 158432\n194512 200000", "output": "Full\n4" }, { "input": "100000 6\n397 1397\n15892 16892\n35746 36746\n94193 95193\n166848 167848\n185228 186228", "output": "Full\n5" }, { "input": "100000 16\n41569 49839\n49854 54485\n59507 68882\n68884 69855\n69997 72083\n105481 108926\n108927 108944\n108969 109043\n109105 109306\n110096 110365\n110573 114375\n180359 187643\n191157 196987\n197083 197113\n197140 197892\n199113 200000", "output": "Full\n3" }, { "input": "1000 2\n909 961\n1820 1859", "output": "Full\n3" }, { "input": "1000 5\n123 174\n716 789\n1284 1360\n1415 1443\n1623 1648", "output": "Full\n3" }, { "input": "1000 5\n381 426\n1092 1122\n1462 1481\n1708 1756\n1799 1847", "output": "Full\n3" }, { "input": "1000 4\n241 259\n1127 1154\n1219 1239\n1739 1758", "output": "Full\n4" }, { "input": "1000 5\n388 407\n488 504\n640 658\n856 875\n1060 1074", "output": "Full\n9" }, { "input": "1000 5\n182 199\n444 460\n628 640\n693 708\n1107 1119", "output": "Full\n7" }, { "input": "1000 2\n771 837\n1015 1049", "output": "Full\n3" }, { "input": "1000 3\n581 617\n802 825\n1040 1080", "output": "Full\n5" }, { "input": "100000 7\n27522 27693\n47266 47410\n58768 58929\n64532 64665\n141173 141356\n150364 150551\n183020 183160", "output": "Full\n9" } ]

1,693,571,714

2,147,483,647

Python 3

OK

TESTS

63

3,587

11,264,000

import sys INF = (1 << 62) N = 200005 MOD = 1000000007 f = [[INF] * N for _ in range(2)] q = [0] * N n, k = 0, 0 def solve(): global n, k for i in range(N): f[0][i] = INF f[0][0] = 0 n, k = map(int, input().split()) for i in range(1, k + 1): l, r = map(int, input().split()) for j in range(n + 1): f[i % 2][j] = f[(i + 1) % 2][j] head, tail = 1, 0 for j in range(r, -1, -1): while head <= tail and f[(i + 1) % 2][q[tail]] > f[(i + 1) % 2][r - j]: tail -= 1 while head <= tail and q[head] < l - j: head += 1 tail += 1 q[tail] = r - j f[i % 2][j] = min(f[i % 2][j], f[(i + 1) % 2][q[head]] + 1) head, tail = 1, 0 for j in range(min(n, r) + 1): while head <= tail and f[(i + 1) % 2][q[tail]] > f[(i + 1) % 2][j]: tail -= 1 while head <= tail and q[head] < j - r + l: head += 1 tail += 1 q[tail] = j f[i % 2][j] = min(f[i % 2][j], f[(i + 1) % 2][q[head]] + 2) if f[k % 2][n] == INF: print("Hungry") else: print("Full") print(f[k % 2][n]) def main(): T = 1 while T > 0: solve() T -= 1 if __name__ == "__main__": main()

Title: Cutlet Time Limit: None seconds Memory Limit: None megabytes Problem Description: Arkady wants to have a dinner. He has just returned from a shop where he has bought a semifinished cutlet. He only needs to fry it. The cutlet should be fried for 2*n* seconds, in particular, it should be fried for *n* seconds on one side and *n* seconds on the other side. Arkady has already got a frying pan and turn on fire, but understood that maybe he won't be able to flip the cutlet exactly after *n* seconds after the beginning of cooking. Arkady is too busy with sorting sticker packs in his favorite messenger and can flip the cutlet only in some periods of time. Namely, there are *k* periods of time in which he can do it, the *i*-th of them is an interval of time from *l**i* seconds after he starts cooking till *r**i* seconds, inclusive. Arkady decided that it's not required to flip the cutlet exactly in the middle of cooking, instead, he will flip it several times in such a way that the cutlet will be fried exactly *n* seconds on one side and *n* seconds on the other side in total. Help Arkady and find out if it's possible for him to cook the cutlet, if he is able to flip the cutlet only in given periods of time; and if yes, find the minimum number of flips he needs to cook the cutlet. Input Specification: The first line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=100) — the number of seconds the cutlet should be cooked on each side and number of periods of time in which Arkady can flip it. The next *k* lines contain descriptions of these intervals. Each line contains two integers *l**i* and *r**i* (0<=≤<=*l**i*<=≤<=*r**i*<=≤<=2·*n*), meaning that Arkady can flip the cutlet in any moment starting from *l**i* seconds after the beginning of cooking and finishing at *r**i* seconds after beginning of cooking. In particular, if *l**i*<==<=*r**i* then Arkady can flip the cutlet only in the moment *l**i*<==<=*r**i*. It's guaranteed that *l**i*<=><=*r**i*<=-<=1 for all 2<=≤<=*i*<=≤<=*k*. Output Specification: Output "Hungry" if Arkady won't be able to fry the cutlet for exactly *n* seconds on one side and exactly *n* seconds on the other side. Otherwise, output "Full" in the first line, and the minimum number of times he should flip the cutlet in the second line. Demo Input: ['10 2\n3 5\n11 13\n', '10 3\n3 5\n9 10\n11 13\n', '20 1\n3 19\n'] Demo Output: ['Full\n2\n', 'Full\n1\n', 'Hungry\n'] Note: In the first example Arkady should flip the cutlet in time moment 3 seconds after he starts cooking and in time moment 13 seconds after he starts cooking. In the second example, Arkady can flip the cutlet at 10 seconds after he starts cooking.

```python import sys INF = (1 << 62) N = 200005 MOD = 1000000007 f = [[INF] * N for _ in range(2)] q = [0] * N n, k = 0, 0 def solve(): global n, k for i in range(N): f[0][i] = INF f[0][0] = 0 n, k = map(int, input().split()) for i in range(1, k + 1): l, r = map(int, input().split()) for j in range(n + 1): f[i % 2][j] = f[(i + 1) % 2][j] head, tail = 1, 0 for j in range(r, -1, -1): while head <= tail and f[(i + 1) % 2][q[tail]] > f[(i + 1) % 2][r - j]: tail -= 1 while head <= tail and q[head] < l - j: head += 1 tail += 1 q[tail] = r - j f[i % 2][j] = min(f[i % 2][j], f[(i + 1) % 2][q[head]] + 1) head, tail = 1, 0 for j in range(min(n, r) + 1): while head <= tail and f[(i + 1) % 2][q[tail]] > f[(i + 1) % 2][j]: tail -= 1 while head <= tail and q[head] < j - r + l: head += 1 tail += 1 q[tail] = j f[i % 2][j] = min(f[i % 2][j], f[(i + 1) % 2][q[head]] + 2) if f[k % 2][n] == INF: print("Hungry") else: print("Full") print(f[k % 2][n]) def main(): T = 1 while T > 0: solve() T -= 1 if __name__ == "__main__": main() ```

3

734

A

Anton and Danik

PROGRAMMING

800

[ "implementation", "strings" ]

null

Anton likes to play chess, and so does his friend Danik. Once they have played *n* games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie. Now Anton wonders, who won more games, he or Danik? Help him determine this.

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of games played. The second line contains a string *s*, consisting of *n* uppercase English letters 'A' and 'D' — the outcome of each of the games. The *i*-th character of the string is equal to 'A' if the Anton won the *i*-th game and 'D' if Danik won the *i*-th game.

If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output. If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output. If Anton and Danik won the same number of games, print "Friendship" (without quotes).

[ "6\nADAAAA\n", "7\nDDDAADA\n", "6\nDADADA\n" ]

[ "Anton\n", "Danik\n", "Friendship\n" ]

In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton". In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik". In the third sample, both Anton and Danik won 3 games and the answer is "Friendship".

500

[ { "input": "6\nADAAAA", "output": "Anton" }, { "input": "7\nDDDAADA", "output": "Danik" }, { "input": "6\nDADADA", "output": "Friendship" }, { "input": "10\nDDDDADDADD", "output": "Danik" }, { "input": "40\nAAAAAAAAADDAAAAAAAAAAADADDAAAAAAAAAAADAA", "output": "Anton" }, { "input": "200\nDDDDDDDADDDDDDAADADAADAAADAADADAAADDDADDDDDDADDDAADDDAADADDDDDADDDAAAADAAADDDDDAAADAADDDAAAADDADADDDAADDAADAAADAADAAAADDAADDADAAAADADDDAAAAAADDAADAADAADADDDAAADAAAADADDADAAAAAADADADDDADDDAADDADDDAAAAD", "output": "Friendship" }, { "input": "1\nA", "output": "Anton" }, { "input": "1\nD", "output": "Danik" }, { "input": "2\nDA", "output": "Friendship" }, { "input": "4\nDADA", "output": "Friendship" }, { "input": "4\nDAAD", "output": "Friendship" }, { "input": "3\nADD", "output": "Danik" }, { "input": "3\nDAD", "output": "Danik" }, { "input": "2\nDA", "output": "Friendship" }, { "input": "379\nAADAAAAAADDAAAAAADAADADADDAAAAADADDAADAAAADDDADAAAAAAADAADAAAAAAADAAAAAAAAADAAAAAAADAAAAAAAAAAADDDADAAAAAAAADAADADAAAADAAAAAAAAAAAAAAAAADAAAADDDAADAAAAAAADAAADAAADAADDDADDAAADAAAAAADDDADDDAAADAAAADAAAAAAAAADAAADAAAAAAAAADAAAAAAAAAAAAAAAAAADADAAAAAAAAAAADAAAAADAAAADAAAAAAAAAAAAADADAADAAAAAAAADAADAAAAAAAADAAAAAAAADDDAAAAAADAAADAAAAAADAADAAAAAADAAAADADAADAAAAAADAAAADAADDAADAADAAA", "output": "Anton" } ]

1,694,609,720

2,147,483,647

Python 3

OK

TESTS

25

62

2,355,200

n=input() m=input() lst=[] for a in m: lst.append(a) p=lst.count("A") q=lst.count("D") if p>q: print("Anton") elif q>p: print("Danik") else: print("Friendship")

Title: Anton and Danik Time Limit: None seconds Memory Limit: None megabytes Problem Description: Anton likes to play chess, and so does his friend Danik. Once they have played *n* games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie. Now Anton wonders, who won more games, he or Danik? Help him determine this. Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of games played. The second line contains a string *s*, consisting of *n* uppercase English letters 'A' and 'D' — the outcome of each of the games. The *i*-th character of the string is equal to 'A' if the Anton won the *i*-th game and 'D' if Danik won the *i*-th game. Output Specification: If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output. If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output. If Anton and Danik won the same number of games, print "Friendship" (without quotes). Demo Input: ['6\nADAAAA\n', '7\nDDDAADA\n', '6\nDADADA\n'] Demo Output: ['Anton\n', 'Danik\n', 'Friendship\n'] Note: In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton". In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik". In the third sample, both Anton and Danik won 3 games and the answer is "Friendship".

```python n=input() m=input() lst=[] for a in m: lst.append(a) p=lst.count("A") q=lst.count("D") if p>q: print("Anton") elif q>p: print("Danik") else: print("Friendship") ```

3

500

A

New Year Transportation

PROGRAMMING

1,000

[ "dfs and similar", "graphs", "implementation" ]

null

New Year is coming in Line World! In this world, there are *n* cells numbered by integers from 1 to *n*, as a 1<=×<=*n* board. People live in cells. However, it was hard to move between distinct cells, because of the difficulty of escaping the cell. People wanted to meet people who live in other cells. So, user tncks0121 has made a transportation system to move between these cells, to celebrate the New Year. First, he thought of *n*<=-<=1 positive integers *a*1,<=*a*2,<=...,<=*a**n*<=-<=1. For every integer *i* where 1<=≤<=*i*<=≤<=*n*<=-<=1 the condition 1<=≤<=*a**i*<=≤<=*n*<=-<=*i* holds. Next, he made *n*<=-<=1 portals, numbered by integers from 1 to *n*<=-<=1. The *i*-th (1<=≤<=*i*<=≤<=*n*<=-<=1) portal connects cell *i* and cell (*i*<=+<=*a**i*), and one can travel from cell *i* to cell (*i*<=+<=*a**i*) using the *i*-th portal. Unfortunately, one cannot use the portal backwards, which means one cannot move from cell (*i*<=+<=*a**i*) to cell *i* using the *i*-th portal. It is easy to see that because of condition 1<=≤<=*a**i*<=≤<=*n*<=-<=*i* one can't leave the Line World using portals. Currently, I am standing at cell 1, and I want to go to cell *t*. However, I don't know whether it is possible to go there. Please determine whether I can go to cell *t* by only using the construted transportation system.

The first line contains two space-separated integers *n* (3<=≤<=*n*<=≤<=3<=×<=104) and *t* (2<=≤<=*t*<=≤<=*n*) — the number of cells, and the index of the cell which I want to go to. The second line contains *n*<=-<=1 space-separated integers *a*1,<=*a*2,<=...,<=*a**n*<=-<=1 (1<=≤<=*a**i*<=≤<=*n*<=-<=*i*). It is guaranteed, that using the given transportation system, one cannot leave the Line World.

If I can go to cell *t* using the transportation system, print "YES". Otherwise, print "NO".

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

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

In the first sample, the visited cells are: 1, 2, 4; so we can successfully visit the cell 4. In the second sample, the possible cells to visit are: 1, 2, 4, 6, 7, 8; so we can't visit the cell 5, which we want to visit.

500

[ { "input": "8 4\n1 2 1 2 1 2 1", "output": "YES" }, { "input": "8 5\n1 2 1 2 1 1 1", "output": "NO" }, { "input": "20 19\n13 16 7 6 12 1 5 7 8 6 5 7 5 5 3 3 2 2 1", "output": "YES" }, { "input": "50 49\n11 7 1 41 26 36 19 16 38 14 36 35 37 27 20 27 3 6 21 2 27 11 18 17 19 16 22 8 8 9 1 7 5 12 5 6 13 6 11 2 6 3 1 5 1 1 2 2 1", "output": "YES" }, { "input": "120 104\n41 15 95 85 34 11 25 42 65 39 77 80 74 17 66 73 21 14 36 63 63 79 45 24 65 7 63 80 51 21 2 19 78 28 71 2 15 23 17 68 62 18 54 39 43 70 3 46 34 23 41 65 32 10 13 18 10 3 16 48 54 18 57 28 3 24 44 50 15 2 20 22 45 44 3 29 2 27 11 2 12 25 25 31 1 2 32 4 11 30 13 16 26 21 1 13 21 8 15 5 18 13 5 15 3 8 13 6 5 1 9 7 1 2 4 1 1 2 1", "output": "NO" }, { "input": "10 3\n8 3 5 4 2 3 2 2 1", "output": "NO" }, { "input": "10 9\n8 3 5 4 2 3 2 2 1", "output": "YES" }, { "input": "3 2\n1 1", "output": "YES" }, { "input": "3 2\n2 1", "output": "NO" }, { "input": "4 2\n2 1 1", "output": "NO" }, { "input": "4 4\n2 2 1", "output": "YES" }, { "input": "8 8\n1 2 1 2 1 2 1", "output": "YES" }, { "input": "3 3\n1 1", "output": "YES" }, { "input": "8 8\n1 2 1 2 1 1 1", "output": "YES" }, { "input": "3 3\n2 1", "output": "YES" }, { "input": "4 4\n1 1 1", "output": "YES" }, { "input": "8 8\n1 1 1 1 1 1 1", "output": "YES" }, { "input": "5 5\n1 1 1 1", "output": "YES" } ]

1,682,167,395

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

12

46

1,945,600

n,t=map(int,input().split()) a=list(map(int,input().split())) current_cell=1 pos=False while current_cell<=t: if current_cell==t: pos=True current_cell=current_cell+a[current_cell-1] if pos==True: print('YES') else: print('NO')

Title: New Year Transportation Time Limit: None seconds Memory Limit: None megabytes Problem Description: New Year is coming in Line World! In this world, there are *n* cells numbered by integers from 1 to *n*, as a 1<=×<=*n* board. People live in cells. However, it was hard to move between distinct cells, because of the difficulty of escaping the cell. People wanted to meet people who live in other cells. So, user tncks0121 has made a transportation system to move between these cells, to celebrate the New Year. First, he thought of *n*<=-<=1 positive integers *a*1,<=*a*2,<=...,<=*a**n*<=-<=1. For every integer *i* where 1<=≤<=*i*<=≤<=*n*<=-<=1 the condition 1<=≤<=*a**i*<=≤<=*n*<=-<=*i* holds. Next, he made *n*<=-<=1 portals, numbered by integers from 1 to *n*<=-<=1. The *i*-th (1<=≤<=*i*<=≤<=*n*<=-<=1) portal connects cell *i* and cell (*i*<=+<=*a**i*), and one can travel from cell *i* to cell (*i*<=+<=*a**i*) using the *i*-th portal. Unfortunately, one cannot use the portal backwards, which means one cannot move from cell (*i*<=+<=*a**i*) to cell *i* using the *i*-th portal. It is easy to see that because of condition 1<=≤<=*a**i*<=≤<=*n*<=-<=*i* one can't leave the Line World using portals. Currently, I am standing at cell 1, and I want to go to cell *t*. However, I don't know whether it is possible to go there. Please determine whether I can go to cell *t* by only using the construted transportation system. Input Specification: The first line contains two space-separated integers *n* (3<=≤<=*n*<=≤<=3<=×<=104) and *t* (2<=≤<=*t*<=≤<=*n*) — the number of cells, and the index of the cell which I want to go to. The second line contains *n*<=-<=1 space-separated integers *a*1,<=*a*2,<=...,<=*a**n*<=-<=1 (1<=≤<=*a**i*<=≤<=*n*<=-<=*i*). It is guaranteed, that using the given transportation system, one cannot leave the Line World. Output Specification: If I can go to cell *t* using the transportation system, print "YES". Otherwise, print "NO". Demo Input: ['8 4\n1 2 1 2 1 2 1\n', '8 5\n1 2 1 2 1 1 1\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first sample, the visited cells are: 1, 2, 4; so we can successfully visit the cell 4. In the second sample, the possible cells to visit are: 1, 2, 4, 6, 7, 8; so we can't visit the cell 5, which we want to visit.

```python n,t=map(int,input().split()) a=list(map(int,input().split())) current_cell=1 pos=False while current_cell<=t: if current_cell==t: pos=True current_cell=current_cell+a[current_cell-1] if pos==True: print('YES') else: print('NO') ```

-1

712

A

Memory and Crow

PROGRAMMING

800

[ "implementation", "math" ]

null

There are *n* integers *b*1,<=*b*2,<=...,<=*b**n* written in a row. For all *i* from 1 to *n*, values *a**i* are defined by the crows performing the following procedure: - The crow sets *a**i* initially 0. - The crow then adds *b**i* to *a**i*, subtracts *b**i*<=+<=1, adds the *b**i*<=+<=2 number, and so on until the *n*'th number. Thus, *a**i*<==<=*b**i*<=-<=*b**i*<=+<=1<=+<=*b**i*<=+<=2<=-<=*b**i*<=+<=3.... Memory gives you the values *a*1,<=*a*2,<=...,<=*a**n*, and he now wants you to find the initial numbers *b*1,<=*b*2,<=...,<=*b**n* written in the row? Can you do it?

The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=100<=000) — the number of integers written in the row. The next line contains *n*, the *i*'th of which is *a**i* (<=-<=109<=≤<=*a**i*<=≤<=109) — the value of the *i*'th number.

Print *n* integers corresponding to the sequence *b*1,<=*b*2,<=...,<=*b**n*. It's guaranteed that the answer is unique and fits in 32-bit integer type.

[ "5\n6 -4 8 -2 3\n", "5\n3 -2 -1 5 6\n" ]

[ "2 4 6 1 3 \n", "1 -3 4 11 6 \n" ]

In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3. In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6.

500

[ { "input": "5\n6 -4 8 -2 3", "output": "2 4 6 1 3 " }, { "input": "5\n3 -2 -1 5 6", "output": "1 -3 4 11 6 " }, { "input": "10\n13 -2 532 -63 -23 -63 -64 -23 12 10", "output": "11 530 469 -86 -86 -127 -87 -11 22 10 " }, { "input": "10\n0 0 0 0 0 0 0 0 0 0", "output": "0 0 0 0 0 0 0 0 0 0 " }, { "input": "10\n1 -1 1 -1 1 -1 1 -1 1 -1", "output": "0 0 0 0 0 0 0 0 0 -1 " }, { "input": "10\n-1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000 -1000000000 1000000000", "output": "0 0 0 0 0 0 0 0 0 1000000000 " }, { "input": "10\n124 532 -642 6482 -124 952 -235 7594 34 -12", "output": "656 -110 5840 6358 828 717 7359 7628 22 -12 " }, { "input": "10\n1294 35852 32749 537295 12048 53729 29357 58320 64739 1240", "output": "37146 68601 570044 549343 65777 83086 87677 123059 65979 1240 " } ]

1,697,198,073

2,147,483,647

Python 3

OK

TESTS

49

202

17,612,800

num = int(input()) num_list = input().split() list = [] for i in num_list: list.append(int(i)) # print(list) list_b = [] b = 0 for i in range(num-1): b = list[i] + list[i+1] list_b.append(b) list_b.append(list[-1]) for i in list_b: print(i, end=" ")

Title: Memory and Crow Time Limit: None seconds Memory Limit: None megabytes Problem Description: There are *n* integers *b*1,<=*b*2,<=...,<=*b**n* written in a row. For all *i* from 1 to *n*, values *a**i* are defined by the crows performing the following procedure: - The crow sets *a**i* initially 0. - The crow then adds *b**i* to *a**i*, subtracts *b**i*<=+<=1, adds the *b**i*<=+<=2 number, and so on until the *n*'th number. Thus, *a**i*<==<=*b**i*<=-<=*b**i*<=+<=1<=+<=*b**i*<=+<=2<=-<=*b**i*<=+<=3.... Memory gives you the values *a*1,<=*a*2,<=...,<=*a**n*, and he now wants you to find the initial numbers *b*1,<=*b*2,<=...,<=*b**n* written in the row? Can you do it? Input Specification: The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=100<=000) — the number of integers written in the row. The next line contains *n*, the *i*'th of which is *a**i* (<=-<=109<=≤<=*a**i*<=≤<=109) — the value of the *i*'th number. Output Specification: Print *n* integers corresponding to the sequence *b*1,<=*b*2,<=...,<=*b**n*. It's guaranteed that the answer is unique and fits in 32-bit integer type. Demo Input: ['5\n6 -4 8 -2 3\n', '5\n3 -2 -1 5 6\n'] Demo Output: ['2 4 6 1 3 \n', '1 -3 4 11 6 \n'] Note: In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3. In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6.

```python num = int(input()) num_list = input().split() list = [] for i in num_list: list.append(int(i)) # print(list) list_b = [] b = 0 for i in range(num-1): b = list[i] + list[i+1] list_b.append(b) list_b.append(list[-1]) for i in list_b: print(i, end=" ") ```

3

567

A

Lineland Mail

PROGRAMMING

900

[ "greedy", "implementation" ]

null

All cities of Lineland are located on the *Ox* coordinate axis. Thus, each city is associated with its position *x**i* — a coordinate on the *Ox* axis. No two cities are located at a single point. Lineland residents love to send letters to each other. A person may send a letter only if the recipient lives in another city (because if they live in the same city, then it is easier to drop in). Strange but true, the cost of sending the letter is exactly equal to the distance between the sender's city and the recipient's city. For each city calculate two values *min**i* and *max**i*, where *min**i* is the minimum cost of sending a letter from the *i*-th city to some other city, and *max**i* is the the maximum cost of sending a letter from the *i*-th city to some other city

The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=105) — the number of cities in Lineland. The second line contains the sequence of *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=109<=≤<=*x**i*<=≤<=109), where *x**i* is the *x*-coordinate of the *i*-th city. All the *x**i*'s are distinct and follow in ascending order.

Print *n* lines, the *i*-th line must contain two integers *min**i*,<=*max**i*, separated by a space, where *min**i* is the minimum cost of sending a letter from the *i*-th city, and *max**i* is the maximum cost of sending a letter from the *i*-th city.

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

[ "3 12\n3 9\n4 7\n5 12\n", "2 2\n2 2\n" ]

none

500

[ { "input": "4\n-5 -2 2 7", "output": "3 12\n3 9\n4 7\n5 12" }, { "input": "2\n-1 1", "output": "2 2\n2 2" }, { "input": "3\n-1 0 1", "output": "1 2\n1 1\n1 2" }, { "input": "4\n-1 0 1 3", "output": "1 4\n1 3\n1 2\n2 4" }, { "input": "3\n-1000000000 0 1000000000", "output": "1000000000 2000000000\n1000000000 1000000000\n1000000000 2000000000" }, { "input": "2\n-1000000000 1000000000", "output": "2000000000 2000000000\n2000000000 2000000000" }, { "input": "10\n1 10 12 15 59 68 130 912 1239 9123", "output": "9 9122\n2 9113\n2 9111\n3 9108\n9 9064\n9 9055\n62 8993\n327 8211\n327 7884\n7884 9122" }, { "input": "5\n-2 -1 0 1 2", "output": "1 4\n1 3\n1 2\n1 3\n1 4" }, { "input": "5\n-2 -1 0 1 3", "output": "1 5\n1 4\n1 3\n1 3\n2 5" }, { "input": "3\n-10000 1 10000", "output": "10001 20000\n9999 10001\n9999 20000" }, { "input": "5\n-1000000000 -999999999 -999999998 -999999997 -999999996", "output": "1 4\n1 3\n1 2\n1 3\n1 4" }, { "input": "10\n-857422304 -529223472 82412729 145077145 188538640 265299215 527377039 588634631 592896147 702473706", "output": "328198832 1559896010\n328198832 1231697178\n62664416 939835033\n43461495 1002499449\n43461495 1045960944\n76760575 1122721519\n61257592 1384799343\n4261516 1446056935\n4261516 1450318451\n109577559 1559896010" }, { "input": "10\n-876779400 -829849659 -781819137 -570920213 18428128 25280705 121178189 219147240 528386329 923854124", "output": "46929741 1800633524\n46929741 1753703783\n48030522 1705673261\n210898924 1494774337\n6852577 905425996\n6852577 902060105\n95897484 997957589\n97969051 1095926640\n309239089 1405165729\n395467795 1800633524" }, { "input": "30\n-15 1 21 25 30 40 59 60 77 81 97 100 103 123 139 141 157 158 173 183 200 215 226 231 244 256 267 279 289 292", "output": "16 307\n16 291\n4 271\n4 267\n5 262\n10 252\n1 233\n1 232\n4 215\n4 211\n3 195\n3 192\n3 189\n16 169\n2 154\n2 156\n1 172\n1 173\n10 188\n10 198\n15 215\n11 230\n5 241\n5 246\n12 259\n11 271\n11 282\n10 294\n3 304\n3 307" }, { "input": "10\n-1000000000 -999999999 -999999997 -999999996 -999999995 -999999994 -999999992 -999999990 -999999988 -999999986", "output": "1 14\n1 13\n1 11\n1 10\n1 9\n1 8\n2 8\n2 10\n2 12\n2 14" }, { "input": "50\n-50000 -49459 -48875 -48456 -48411 -48096 -47901 -47500 -47150 -46808 -46687 -46679 -46337 -45747 -45604 -45194 -44752 -44242 -44231 -44122 -43636 -43274 -42916 -42881 -42386 -42095 -41830 -41618 -41145 -40897 -40534 -40007 -39761 -39389 -39104 -38909 -38630 -38561 -38364 -38255 -38214 -38084 -37959 -37607 -37202 -36890 -36681 -36136 -36123 -35886", "output": "541 14114\n541 13573\n419 12989\n45 12570\n45 12525\n195 12210\n195 12015\n350 11614\n342 11264\n121 10922\n8 10801\n8 10793\n342 10451\n143 9861\n143 9718\n410 9308\n442 8866\n11 8356\n11 8345\n109 8236\n362 7750\n358 7388\n35 7084\n35 7119\n291 7614\n265 7905\n212 8170\n212 8382\n248 8855\n248 9103\n363 9466\n246 9993\n246 10239\n285 10611\n195 10896\n195 11091\n69 11370\n69 11439\n109 11636\n41 11745\n41 11786\n125 11916\n125 12041\n352 12393\n312 12798\n209 13110\n209 13319\n13 13864\n13 13877\n237 141..." }, { "input": "3\n-1000000000 999999999 1000000000", "output": "1999999999 2000000000\n1 1999999999\n1 2000000000" } ]

1,674,466,670

2,147,483,647

Python 3

OK

TESTS

54

577

12,185,600

n = int(input()) lis = list(map(int,input().split())) res =[] for i in range(n): ma = max(abs(lis[i]-lis[0]),abs(lis[i]-lis[n-1])) if i == 0 : mi = abs(lis[i]-lis[i+1]) elif i == n-1 : mi = abs(lis[i]-lis[i-1]) else: mi = min(abs(lis[i]-lis[i-1]),abs(lis[i]-lis[i+1])) res.append([mi,ma]) for row in res: print(*row)

Title: Lineland Mail Time Limit: None seconds Memory Limit: None megabytes Problem Description: All cities of Lineland are located on the *Ox* coordinate axis. Thus, each city is associated with its position *x**i* — a coordinate on the *Ox* axis. No two cities are located at a single point. Lineland residents love to send letters to each other. A person may send a letter only if the recipient lives in another city (because if they live in the same city, then it is easier to drop in). Strange but true, the cost of sending the letter is exactly equal to the distance between the sender's city and the recipient's city. For each city calculate two values *min**i* and *max**i*, where *min**i* is the minimum cost of sending a letter from the *i*-th city to some other city, and *max**i* is the the maximum cost of sending a letter from the *i*-th city to some other city Input Specification: The first line of the input contains integer *n* (2<=≤<=*n*<=≤<=105) — the number of cities in Lineland. The second line contains the sequence of *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=109<=≤<=*x**i*<=≤<=109), where *x**i* is the *x*-coordinate of the *i*-th city. All the *x**i*'s are distinct and follow in ascending order. Output Specification: Print *n* lines, the *i*-th line must contain two integers *min**i*,<=*max**i*, separated by a space, where *min**i* is the minimum cost of sending a letter from the *i*-th city, and *max**i* is the maximum cost of sending a letter from the *i*-th city. Demo Input: ['4\n-5 -2 2 7\n', '2\n-1 1\n'] Demo Output: ['3 12\n3 9\n4 7\n5 12\n', '2 2\n2 2\n'] Note: none

```python n = int(input()) lis = list(map(int,input().split())) res =[] for i in range(n): ma = max(abs(lis[i]-lis[0]),abs(lis[i]-lis[n-1])) if i == 0 : mi = abs(lis[i]-lis[i+1]) elif i == n-1 : mi = abs(lis[i]-lis[i-1]) else: mi = min(abs(lis[i]-lis[i-1]),abs(lis[i]-lis[i+1])) res.append([mi,ma]) for row in res: print(*row) ```

3

479

A

Expression

PROGRAMMING

1,000

[ "brute force", "math" ]

null

Petya studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers *a*, *b*, *c* on the blackboard. The task was to insert signs of operations '+' and '*', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets: - 1+2*3=7 - 1*(2+3)=5 - 1*2*3=6 - (1+2)*3=9 Note that you can insert operation signs only between *a* and *b*, and between *b* and *c*, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2. It's easy to see that the maximum value that you can obtain is 9. Your task is: given *a*, *b* and *c* print the maximum value that you can get.

The input contains three integers *a*, *b* and *c*, each on a single line (1<=≤<=*a*,<=*b*,<=*c*<=≤<=10).

Print the maximum value of the expression that you can obtain.

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

[ "9\n", "60\n" ]

none

500

[ { "input": "1\n2\n3", "output": "9" }, { "input": "2\n10\n3", "output": "60" }, { "input": "1\n1\n1", "output": "3" }, { "input": "1\n2\n1", "output": "4" }, { "input": "10\n10\n10", "output": "1000" }, { "input": "5\n1\n3", "output": "20" }, { "input": "3\n1\n5", "output": "20" }, { "input": "6\n7\n1", "output": "48" }, { "input": "1\n8\n3", "output": "27" }, { "input": "9\n7\n2", "output": "126" }, { "input": "1\n1\n10", "output": "20" }, { "input": "9\n1\n1", "output": "18" }, { "input": "10\n5\n6", "output": "300" }, { "input": "8\n9\n7", "output": "504" }, { "input": "4\n2\n10", "output": "80" }, { "input": "2\n8\n3", "output": "48" }, { "input": "3\n5\n7", "output": "105" }, { "input": "1\n10\n1", "output": "12" }, { "input": "2\n2\n2", "output": "8" }, { "input": "5\n6\n1", "output": "35" }, { "input": "10\n1\n1", "output": "20" }, { "input": "1\n6\n1", "output": "8" }, { "input": "1\n9\n1", "output": "11" }, { "input": "2\n1\n2", "output": "6" }, { "input": "2\n6\n1", "output": "14" }, { "input": "9\n2\n1", "output": "27" }, { "input": "1\n9\n2", "output": "20" }, { "input": "1\n3\n1", "output": "5" }, { "input": "2\n1\n1", "output": "4" } ]

1,689,976,088

2,147,483,647

Python 3

OK

TESTS

29

46

0

a = int(input()) b = int(input()) c = int(input()) arreglo = [] caso1 = a * (b + c) caso2 = (a + b) * c caso3 = a * b * c caso4 = a + b + c caso5 = a * b + c caso6 = a + b * c arreglo += [caso1,caso2,caso3,caso4,caso5,caso6] arreglo.sort() print(arreglo[5])

Title: Expression Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers *a*, *b*, *c* on the blackboard. The task was to insert signs of operations '+' and '*', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets: - 1+2*3=7 - 1*(2+3)=5 - 1*2*3=6 - (1+2)*3=9 Note that you can insert operation signs only between *a* and *b*, and between *b* and *c*, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2. It's easy to see that the maximum value that you can obtain is 9. Your task is: given *a*, *b* and *c* print the maximum value that you can get. Input Specification: The input contains three integers *a*, *b* and *c*, each on a single line (1<=≤<=*a*,<=*b*,<=*c*<=≤<=10). Output Specification: Print the maximum value of the expression that you can obtain. Demo Input: ['1\n2\n3\n', '2\n10\n3\n'] Demo Output: ['9\n', '60\n'] Note: none

```python a = int(input()) b = int(input()) c = int(input()) arreglo = [] caso1 = a * (b + c) caso2 = (a + b) * c caso3 = a * b * c caso4 = a + b + c caso5 = a * b + c caso6 = a + b * c arreglo += [caso1,caso2,caso3,caso4,caso5,caso6] arreglo.sort() print(arreglo[5]) ```

3

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,584,075,881

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

80

218

307,200

k=0 for _ in range(int(input())): l=list(map(int,input().split())) k+=sum(l) if k==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 k=0 for _ in range(int(input())): l=list(map(int,input().split())) k+=sum(l) if k==0: print("YES") else: print("NO") ```

0

820

A

Mister B and Book Reading

PROGRAMMING

900

[ "implementation" ]

null

Mister B once received a gift: it was a book about aliens, which he started read immediately. This book had *c* pages. At first day Mister B read *v*0 pages, but after that he started to speed up. Every day, starting from the second, he read *a* pages more than on the previous day (at first day he read *v*0 pages, at second — *v*0<=+<=*a* pages, at third — *v*0<=+<=2*a* pages, and so on). But Mister B is just a human, so he physically wasn't able to read more than *v*1 pages per day. Also, to refresh his memory, every day, starting from the second, Mister B had to reread last *l* pages he read on the previous day. Mister B finished the book when he read the last page for the first time. Help Mister B to calculate how many days he needed to finish the book.

First and only line contains five space-separated integers: *c*, *v*0, *v*1, *a* and *l* (1<=≤<=*c*<=≤<=1000, 0<=≤<=*l*<=<<=*v*0<=≤<=*v*1<=≤<=1000, 0<=≤<=*a*<=≤<=1000) — the length of the book in pages, the initial reading speed, the maximum reading speed, the acceleration in reading speed and the number of pages for rereading.

Print one integer — the number of days Mister B needed to finish the book.

[ "5 5 10 5 4\n", "12 4 12 4 1\n", "15 1 100 0 0\n" ]

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

In the first sample test the book contains 5 pages, so Mister B read it right at the first day. In the second sample test at first day Mister B read pages number 1 - 4, at second day — 4 - 11, at third day — 11 - 12 and finished the book. In third sample test every day Mister B read 1 page of the book, so he finished in 15 days.

500

[ { "input": "5 5 10 5 4", "output": "1" }, { "input": "12 4 12 4 1", "output": "3" }, { "input": "15 1 100 0 0", "output": "15" }, { "input": "1 1 1 0 0", "output": "1" }, { "input": "1000 999 1000 1000 998", "output": "2" }, { "input": "1000 2 2 5 1", "output": "999" }, { "input": "1000 1 1 1000 0", "output": "1000" }, { "input": "737 41 74 12 11", "output": "13" }, { "input": "1000 1000 1000 0 999", "output": "1" }, { "input": "765 12 105 5 7", "output": "17" }, { "input": "15 2 2 1000 0", "output": "8" }, { "input": "1000 1 1000 1000 0", "output": "2" }, { "input": "20 3 7 1 2", "output": "6" }, { "input": "1000 500 500 1000 499", "output": "501" }, { "input": "1 1000 1000 1000 0", "output": "1" }, { "input": "1000 2 1000 56 0", "output": "7" }, { "input": "1000 2 1000 802 0", "output": "3" }, { "input": "16 1 8 2 0", "output": "4" }, { "input": "20 6 10 2 2", "output": "3" }, { "input": "8 2 12 4 1", "output": "3" }, { "input": "8 6 13 2 5", "output": "2" }, { "input": "70 4 20 87 0", "output": "5" }, { "input": "97 8 13 234 5", "output": "13" }, { "input": "16 4 23 8 3", "output": "3" }, { "input": "65 7 22 7 4", "output": "5" }, { "input": "93 10 18 11 7", "output": "9" }, { "input": "86 13 19 15 9", "output": "9" }, { "input": "333 17 50 10 16", "output": "12" }, { "input": "881 16 55 10 12", "output": "23" }, { "input": "528 11 84 3 9", "output": "19" }, { "input": "896 2 184 8 1", "output": "16" }, { "input": "236 10 930 9 8", "output": "8" }, { "input": "784 1 550 14 0", "output": "12" }, { "input": "506 1 10 4 0", "output": "53" }, { "input": "460 1 3 2 0", "output": "154" }, { "input": "701 1 3 1 0", "output": "235" }, { "input": "100 49 50 1000 2", "output": "3" }, { "input": "100 1 100 100 0", "output": "2" }, { "input": "12 1 4 2 0", "output": "4" }, { "input": "22 10 12 0 0", "output": "3" }, { "input": "20 10 15 1 4", "output": "3" }, { "input": "1000 5 10 1 4", "output": "169" }, { "input": "1000 1 1000 1 0", "output": "45" }, { "input": "4 1 2 2 0", "output": "3" }, { "input": "1 5 5 1 1", "output": "1" }, { "input": "19 10 11 0 2", "output": "3" }, { "input": "1 2 3 0 0", "output": "1" }, { "input": "10 1 4 10 0", "output": "4" }, { "input": "20 3 100 1 1", "output": "5" }, { "input": "1000 5 9 5 0", "output": "112" }, { "input": "1 11 12 0 10", "output": "1" }, { "input": "1 1 1 1 0", "output": "1" }, { "input": "1000 1 20 1 0", "output": "60" }, { "input": "9 1 4 2 0", "output": "4" }, { "input": "129 2 3 4 0", "output": "44" }, { "input": "4 2 2 0 1", "output": "3" }, { "input": "1000 1 10 100 0", "output": "101" }, { "input": "100 1 100 1 0", "output": "14" }, { "input": "8 3 4 2 0", "output": "3" }, { "input": "20 1 6 4 0", "output": "5" }, { "input": "8 2 4 2 0", "output": "3" }, { "input": "11 5 6 7 2", "output": "3" }, { "input": "100 120 130 120 0", "output": "1" }, { "input": "7 1 4 1 0", "output": "4" }, { "input": "5 3 10 0 2", "output": "3" }, { "input": "5 2 2 0 0", "output": "3" }, { "input": "1000 10 1000 10 0", "output": "14" }, { "input": "25 3 50 4 2", "output": "4" }, { "input": "9 10 10 10 9", "output": "1" }, { "input": "17 10 12 6 5", "output": "2" }, { "input": "15 5 10 3 0", "output": "3" }, { "input": "8 3 5 1 0", "output": "3" }, { "input": "19 1 12 5 0", "output": "4" }, { "input": "1000 10 1000 1 0", "output": "37" }, { "input": "100 1 2 1000 0", "output": "51" }, { "input": "20 10 11 1000 9", "output": "6" }, { "input": "16 2 100 1 1", "output": "5" }, { "input": "18 10 13 2 5", "output": "3" }, { "input": "12 3 5 3 1", "output": "4" }, { "input": "17 3 11 2 0", "output": "4" }, { "input": "4 2 100 1 1", "output": "2" }, { "input": "7 4 5 2 3", "output": "3" }, { "input": "100 1 2 2 0", "output": "51" }, { "input": "50 4 5 5 0", "output": "11" }, { "input": "1 2 2 0 1", "output": "1" }, { "input": "1000 2 3 10 1", "output": "500" }, { "input": "500 10 500 1000 0", "output": "2" }, { "input": "1000 4 12 1 0", "output": "87" }, { "input": "18 10 13 1 5", "output": "3" }, { "input": "7 3 6 2 2", "output": "3" }, { "input": "15 5 100 1 2", "output": "4" }, { "input": "100 1 10 1 0", "output": "15" }, { "input": "8 2 7 5 1", "output": "2" }, { "input": "11 2 4 1 1", "output": "5" }, { "input": "1000 500 900 100 300", "output": "3" }, { "input": "7 1 2 5 0", "output": "4" }, { "input": "7 3 5 3 2", "output": "3" }, { "input": "7 3 10 2 1", "output": "2" }, { "input": "1000 501 510 1 499", "output": "50" }, { "input": "1000 1 1000 2 0", "output": "32" }, { "input": "1 5 5 0 0", "output": "1" }, { "input": "18 10 15 1 5", "output": "3" }, { "input": "100 4 1000 1 2", "output": "13" }, { "input": "20 2 40 1 1", "output": "6" }, { "input": "1 11 1000 100 1", "output": "1" }, { "input": "6 4 4 1 2", "output": "2" }, { "input": "8 3 5 3 1", "output": "3" }, { "input": "10 5 7 1 2", "output": "3" }, { "input": "400 100 198 1 99", "output": "25" }, { "input": "3 1 2 5 0", "output": "2" } ]

1,624,411,357

2,147,483,647

Python 3

OK

TESTS

110

62

0

c,v,n,a,l = map(int,input().split()) d = 1 c -= v while c > 0: v += a if v > n: v = n c -= v - l d += 1 print(d)

Title: Mister B and Book Reading Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mister B once received a gift: it was a book about aliens, which he started read immediately. This book had *c* pages. At first day Mister B read *v*0 pages, but after that he started to speed up. Every day, starting from the second, he read *a* pages more than on the previous day (at first day he read *v*0 pages, at second — *v*0<=+<=*a* pages, at third — *v*0<=+<=2*a* pages, and so on). But Mister B is just a human, so he physically wasn't able to read more than *v*1 pages per day. Also, to refresh his memory, every day, starting from the second, Mister B had to reread last *l* pages he read on the previous day. Mister B finished the book when he read the last page for the first time. Help Mister B to calculate how many days he needed to finish the book. Input Specification: First and only line contains five space-separated integers: *c*, *v*0, *v*1, *a* and *l* (1<=≤<=*c*<=≤<=1000, 0<=≤<=*l*<=<<=*v*0<=≤<=*v*1<=≤<=1000, 0<=≤<=*a*<=≤<=1000) — the length of the book in pages, the initial reading speed, the maximum reading speed, the acceleration in reading speed and the number of pages for rereading. Output Specification: Print one integer — the number of days Mister B needed to finish the book. Demo Input: ['5 5 10 5 4\n', '12 4 12 4 1\n', '15 1 100 0 0\n'] Demo Output: ['1\n', '3\n', '15\n'] Note: In the first sample test the book contains 5 pages, so Mister B read it right at the first day. In the second sample test at first day Mister B read pages number 1 - 4, at second day — 4 - 11, at third day — 11 - 12 and finished the book. In third sample test every day Mister B read 1 page of the book, so he finished in 15 days.

```python c,v,n,a,l = map(int,input().split()) d = 1 c -= v while c > 0: v += a if v > n: v = n c -= v - l d += 1 print(d) ```

3

552

B

Vanya and Books

PROGRAMMING

1,200

[ "implementation", "math" ]

null

Vanya got an important task — he should enumerate books in the library and label each book with its number. Each of the *n* books should be assigned with a number from 1 to *n*. Naturally, distinct books should be assigned distinct numbers. Vanya wants to know how many digits he will have to write down as he labels the books.

The first line contains integer *n* (1<=≤<=*n*<=≤<=109) — the number of books in the library.

Print the number of digits needed to number all the books.

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

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

Note to the first test. The books get numbers 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, which totals to 17 digits. Note to the second sample. The books get numbers 1, 2, 3, 4, which totals to 4 digits.

1,000

[ { "input": "13", "output": "17" }, { "input": "4", "output": "4" }, { "input": "100", "output": "192" }, { "input": "99", "output": "189" }, { "input": "1000000000", "output": "8888888899" }, { "input": "1000000", "output": "5888896" }, { "input": "999", "output": "2889" }, { "input": "55", "output": "101" }, { "input": "222222222", "output": "1888888896" }, { "input": "8", "output": "8" }, { "input": "13", "output": "17" }, { "input": "313", "output": "831" }, { "input": "1342", "output": "4261" }, { "input": "30140", "output": "139594" }, { "input": "290092", "output": "1629447" }, { "input": "2156660", "output": "13985516" }, { "input": "96482216", "output": "760746625" }, { "input": "943006819", "output": "8375950269" }, { "input": "1", "output": "1" }, { "input": "7", "output": "7" }, { "input": "35", "output": "61" }, { "input": "996", "output": "2880" }, { "input": "6120", "output": "23373" }, { "input": "30660", "output": "142194" }, { "input": "349463", "output": "1985673" }, { "input": "8171970", "output": "56092686" }, { "input": "36123011", "output": "277872985" }, { "input": "986747865", "output": "8769619683" }, { "input": "9", "output": "9" }, { "input": "10", "output": "11" }, { "input": "11", "output": "13" }, { "input": "101", "output": "195" }, { "input": "1000", "output": "2893" }, { "input": "1001", "output": "2897" }, { "input": "9999", "output": "38889" }, { "input": "10000", "output": "38894" }, { "input": "10001", "output": "38899" }, { "input": "99999", "output": "488889" }, { "input": "100000", "output": "488895" }, { "input": "100001", "output": "488901" }, { "input": "999999", "output": "5888889" }, { "input": "1000001", "output": "5888903" }, { "input": "9999999", "output": "68888889" }, { "input": "10000000", "output": "68888897" }, { "input": "10000001", "output": "68888905" }, { "input": "99999999", "output": "788888889" }, { "input": "100000000", "output": "788888898" }, { "input": "100000001", "output": "788888907" }, { "input": "999999999", "output": "8888888889" }, { "input": "95", "output": "181" }, { "input": "995", "output": "2877" }, { "input": "9995", "output": "38873" }, { "input": "99995", "output": "488869" }, { "input": "999999995", "output": "8888888853" }, { "input": "999999998", "output": "8888888880" } ]

1,538,527,929

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

93

0

n = int(input()) a = [] z = 0 k = 8888888899 if n <= 1000: for i in range (1,n+1): a.append(i) z += len(str(a[i-1])) print(z) elif n == 1000000000: print(k) else: None

Title: Vanya and Books Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vanya got an important task — he should enumerate books in the library and label each book with its number. Each of the *n* books should be assigned with a number from 1 to *n*. Naturally, distinct books should be assigned distinct numbers. Vanya wants to know how many digits he will have to write down as he labels the books. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=109) — the number of books in the library. Output Specification: Print the number of digits needed to number all the books. Demo Input: ['13\n', '4\n'] Demo Output: ['17\n', '4\n'] Note: Note to the first test. The books get numbers 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, which totals to 17 digits. Note to the second sample. The books get numbers 1, 2, 3, 4, which totals to 4 digits.

```python n = int(input()) a = [] z = 0 k = 8888888899 if n <= 1000: for i in range (1,n+1): a.append(i) z += len(str(a[i-1])) print(z) elif n == 1000000000: print(k) else: None ```

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,547,796,269

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

186

1,331,200

n, k = map(int, input().split()) ls = list(map(int,input().split())) count = 0 l = 0 r = 0 cnt = [0 for _ in range(100000)] for i in range(n): if cnt[ls[i]] == 0: cnt[ls[i]] += 1 count += 1 if l == 0: l = i + 1 if count >= k: r = i + 1 break if count < k: print(-1,-1) else: print(l,r)

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()) ls = list(map(int,input().split())) count = 0 l = 0 r = 0 cnt = [0 for _ in range(100000)] for i in range(n): if cnt[ls[i]] == 0: cnt[ls[i]] += 1 count += 1 if l == 0: l = i + 1 if count >= k: r = i + 1 break if count < k: print(-1,-1) else: print(l,r) ```

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,608,005,819

2,147,483,647

Python 3

OK

TESTS

32

218

307,200

n=int(input()) a=input().split() listing=[] for i in range(n) : chu=int(a[i])%2 listing.append(chu) list1=sorted(listing) p1=list1.count(list1[0]) p2=list1.count(list1[-1]) if p1<p2 : print(listing.index(list1[0])+1) else : print(listing.index(list1[-1])+1)

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 n=int(input()) a=input().split() listing=[] for i in range(n) : chu=int(a[i])%2 listing.append(chu) list1=sorted(listing) p1=list1.count(list1[0]) p2=list1.count(list1[-1]) if p1<p2 : print(listing.index(list1[0])+1) else : print(listing.index(list1[-1])+1) ```

3.944928

820

B

Mister B and Angle in Polygon

PROGRAMMING

1,300

[ "constructive algorithms", "geometry", "math" ]

null

On one quiet day all of sudden Mister B decided to draw angle *a* on his field. Aliens have already visited his field and left many different geometric figures on it. One of the figures is regular convex *n*-gon (regular convex polygon with *n* sides). That's why Mister B decided to use this polygon. Now Mister B must find three distinct vertices *v*1, *v*2, *v*3 such that the angle (where *v*2 is the vertex of the angle, and *v*1 and *v*3 lie on its sides) is as close as possible to *a*. In other words, the value should be minimum possible. If there are many optimal solutions, Mister B should be satisfied with any of them.

First and only line contains two space-separated integers *n* and *a* (3<=≤<=*n*<=≤<=105, 1<=≤<=*a*<=≤<=180) — the number of vertices in the polygon and the needed angle, in degrees.

Print three space-separated integers: the vertices *v*1, *v*2, *v*3, which form . If there are multiple optimal solutions, print any of them. The vertices are numbered from 1 to *n* in clockwise order.

[ "3 15\n", "4 67\n", "4 68\n" ]

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

In first sample test vertices of regular triangle can create only angle of 60 degrees, that's why every possible angle is correct. Vertices of square can create 45 or 90 degrees angles only. That's why in second sample test the angle of 45 degrees was chosen, since |45 - 67| < |90 - 67|. Other correct answers are: "3 1 2", "3 2 4", "4 2 3", "4 3 1", "1 3 4", "1 4 2", "2 4 1", "4 1 3", "3 1 4", "3 4 2", "2 4 3", "2 3 1", "1 3 2", "1 2 4", "4 2 1". In third sample test, on the contrary, the angle of 90 degrees was chosen, since |90 - 68| < |45 - 68|. Other correct answers are: "2 1 4", "3 2 1", "1 2 3", "4 3 2", "2 3 4", "1 4 3", "3 4 1".

1,000

[ { "input": "3 15", "output": "2 1 3" }, { "input": "4 67", "output": "2 1 3" }, { "input": "4 68", "output": "2 1 4" }, { "input": "3 1", "output": "2 1 3" }, { "input": "3 180", "output": "2 1 3" }, { "input": "100000 1", "output": "2 1 558" }, { "input": "100000 180", "output": "2 1 100000" }, { "input": "100000 42", "output": "2 1 23335" }, { "input": "100000 123", "output": "2 1 68335" }, { "input": "5 1", "output": "2 1 3" }, { "input": "5 36", "output": "2 1 3" }, { "input": "5 54", "output": "2 1 3" }, { "input": "5 55", "output": "2 1 4" }, { "input": "5 70", "output": "2 1 4" }, { "input": "5 89", "output": "2 1 4" }, { "input": "5 90", "output": "2 1 4" }, { "input": "5 91", "output": "2 1 5" }, { "input": "5 111", "output": "2 1 5" }, { "input": "5 126", "output": "2 1 5" }, { "input": "5 127", "output": "2 1 5" }, { "input": "5 141", "output": "2 1 5" }, { "input": "5 162", "output": "2 1 5" }, { "input": "5 180", "output": "2 1 5" }, { "input": "6 46", "output": "2 1 4" }, { "input": "6 33", "output": "2 1 3" }, { "input": "13 4", "output": "2 1 3" }, { "input": "23 11", "output": "2 1 3" }, { "input": "11 119", "output": "2 1 9" }, { "input": "13 117", "output": "2 1 10" }, { "input": "18 174", "output": "2 1 18" }, { "input": "8509 139", "output": "2 1 6573" }, { "input": "29770 76", "output": "2 1 12572" }, { "input": "59115 40", "output": "2 1 13139" }, { "input": "68459 88", "output": "2 1 33471" }, { "input": "85100 129", "output": "2 1 60990" }, { "input": "100000 13", "output": "2 1 7224" }, { "input": "100000 35", "output": "2 1 19446" }, { "input": "100000 49", "output": "2 1 27224" }, { "input": "100000 71", "output": "2 1 39446" }, { "input": "100000 79", "output": "2 1 43891" }, { "input": "100000 101", "output": "2 1 56113" }, { "input": "100000 109", "output": "2 1 60558" }, { "input": "100000 143", "output": "2 1 79446" }, { "input": "100000 148", "output": "2 1 82224" }, { "input": "100000 176", "output": "2 1 97780" }, { "input": "4 16", "output": "2 1 3" } ]

1,500,375,589

1,789

Python 3

OK

TESTS

46

77

4,608,000

from math import ceil n, a = map(int, input().split()) d = round(a * n / 180) + 2 if d == 2: d = 3 if d > n: d = n print(2, 1, d)

Title: Mister B and Angle in Polygon Time Limit: None seconds Memory Limit: None megabytes Problem Description: On one quiet day all of sudden Mister B decided to draw angle *a* on his field. Aliens have already visited his field and left many different geometric figures on it. One of the figures is regular convex *n*-gon (regular convex polygon with *n* sides). That's why Mister B decided to use this polygon. Now Mister B must find three distinct vertices *v*1, *v*2, *v*3 such that the angle (where *v*2 is the vertex of the angle, and *v*1 and *v*3 lie on its sides) is as close as possible to *a*. In other words, the value should be minimum possible. If there are many optimal solutions, Mister B should be satisfied with any of them. Input Specification: First and only line contains two space-separated integers *n* and *a* (3<=≤<=*n*<=≤<=105, 1<=≤<=*a*<=≤<=180) — the number of vertices in the polygon and the needed angle, in degrees. Output Specification: Print three space-separated integers: the vertices *v*1, *v*2, *v*3, which form . If there are multiple optimal solutions, print any of them. The vertices are numbered from 1 to *n* in clockwise order. Demo Input: ['3 15\n', '4 67\n', '4 68\n'] Demo Output: ['1 2 3\n', '2 1 3\n', '4 1 2\n'] Note: In first sample test vertices of regular triangle can create only angle of 60 degrees, that's why every possible angle is correct. Vertices of square can create 45 or 90 degrees angles only. That's why in second sample test the angle of 45 degrees was chosen, since |45 - 67| < |90 - 67|. Other correct answers are: "3 1 2", "3 2 4", "4 2 3", "4 3 1", "1 3 4", "1 4 2", "2 4 1", "4 1 3", "3 1 4", "3 4 2", "2 4 3", "2 3 1", "1 3 2", "1 2 4", "4 2 1". In third sample test, on the contrary, the angle of 90 degrees was chosen, since |90 - 68| < |45 - 68|. Other correct answers are: "2 1 4", "3 2 1", "1 2 3", "4 3 2", "2 3 4", "1 4 3", "3 4 1".

```python from math import ceil n, a = map(int, input().split()) d = round(a * n / 180) + 2 if d == 2: d = 3 if d > n: d = n print(2, 1, d) ```

3

275

A

Lights Out

PROGRAMMING

900

[ "implementation" ]

null

Lenny is playing a game on a 3<=×<=3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on. Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.

The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The *j*-th number in the *i*-th row is the number of times the *j*-th light of the *i*-th row of the grid is pressed.

Print three lines, each containing three characters. The *j*-th character of the *i*-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".

[ "1 0 0\n0 0 0\n0 0 1\n", "1 0 1\n8 8 8\n2 0 3\n" ]

[ "001\n010\n100\n", "010\n011\n100\n" ]

none

500

[ { "input": "1 0 0\n0 0 0\n0 0 1", "output": "001\n010\n100" }, { "input": "1 0 1\n8 8 8\n2 0 3", "output": "010\n011\n100" }, { "input": "13 85 77\n25 50 45\n65 79 9", "output": "000\n010\n000" }, { "input": "96 95 5\n8 84 74\n67 31 61", "output": "011\n011\n101" }, { "input": "24 54 37\n60 63 6\n1 84 26", "output": "110\n101\n011" }, { "input": "23 10 40\n15 6 40\n92 80 77", "output": "101\n100\n000" }, { "input": "62 74 80\n95 74 93\n2 47 95", "output": "010\n001\n110" }, { "input": "80 83 48\n26 0 66\n47 76 37", "output": "000\n000\n010" }, { "input": "32 15 65\n7 54 36\n5 51 3", "output": "111\n101\n001" }, { "input": "22 97 12\n71 8 24\n100 21 64", "output": "100\n001\n100" }, { "input": "46 37 13\n87 0 50\n90 8 55", "output": "111\n011\n000" }, { "input": "57 43 58\n20 82 83\n66 16 52", "output": "111\n010\n110" }, { "input": "45 56 93\n47 51 59\n18 51 63", "output": "101\n011\n100" }, { "input": "47 66 67\n14 1 37\n27 81 69", "output": "001\n001\n110" }, { "input": "26 69 69\n85 18 23\n14 22 74", "output": "110\n001\n010" }, { "input": "10 70 65\n94 27 25\n74 66 30", "output": "111\n010\n100" }, { "input": "97 1 74\n15 99 1\n88 68 86", "output": "001\n011\n000" }, { "input": "36 48 42\n45 41 66\n26 64 1", "output": "001\n111\n010" }, { "input": "52 81 97\n29 77 71\n66 11 2", "output": "100\n100\n111" }, { "input": "18 66 33\n19 49 49\n48 46 26", "output": "011\n100\n000" }, { "input": "68 79 52\n51 39 100\n29 14 26", "output": "110\n000\n111" }, { "input": "91 69 77\n91 26 64\n91 88 57", "output": "001\n011\n110" }, { "input": "16 69 64\n48 21 80\n81 51 51", "output": "010\n101\n111" }, { "input": "96 14 2\n100 18 12\n65 34 89", "output": "111\n010\n010" }, { "input": "93 95 90\n8 59 42\n53 13 19", "output": "100\n001\n111" }, { "input": "71 84 18\n100 19 67\n9 76 15", "output": "010\n010\n001" }, { "input": "38 93 85\n21 88 64\n4 96 25", "output": "111\n011\n000" }, { "input": "75 20 20\n60 5 78\n77 4 69", "output": "011\n001\n000" }, { "input": "65 70 96\n19 6 83\n33 37 82", "output": "100\n000\n011" }, { "input": "11 13 60\n17 13 46\n42 21 39", "output": "000\n011\n101" }, { "input": "0 0 0\n0 0 0\n0 0 0", "output": "111\n111\n111" }, { "input": "0 0 0\n0 1 0\n0 0 0", "output": "101\n000\n101" }, { "input": "0 0 0\n0 0 0\n0 0 1", "output": "111\n110\n100" } ]

1,627,275,127

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

2

92

20,172,800

a = [[],[],[]] b = [[1,1,1],[1,1,1],[1,1,1]] for i in range(3): x = list(map(int, input().split(" "))) a[i] = x for j in range(3): for l in range(3): if a[j][l]%2!=0: b[j][l] = 0 if l+1<3: if b[j][l+1]==0: b[j][l+1]=1 else: b[j][l + 1] = 0 if l-1>=0: if b[j][l - 1] == 0: b[j][l - 1] = 1 else: b[j][l - 1] = 0 if j+1<3: if b[j+1][l] == 0: b[j+1][l] = 1 else: b[j+1][l] = 0 if j-1>=0: if b[j-1][l] == 0: b[j-1][l] = 1 else: b[j-1][l] = 0 for k in range(3): for p in range(3): print(b[k][p],end="") print()

Title: Lights Out Time Limit: None seconds Memory Limit: None megabytes Problem Description: Lenny is playing a game on a 3<=×<=3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on. Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light. Input Specification: The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The *j*-th number in the *i*-th row is the number of times the *j*-th light of the *i*-th row of the grid is pressed. Output Specification: Print three lines, each containing three characters. The *j*-th character of the *i*-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0". Demo Input: ['1 0 0\n0 0 0\n0 0 1\n', '1 0 1\n8 8 8\n2 0 3\n'] Demo Output: ['001\n010\n100\n', '010\n011\n100\n'] Note: none

```python a = [[],[],[]] b = [[1,1,1],[1,1,1],[1,1,1]] for i in range(3): x = list(map(int, input().split(" "))) a[i] = x for j in range(3): for l in range(3): if a[j][l]%2!=0: b[j][l] = 0 if l+1<3: if b[j][l+1]==0: b[j][l+1]=1 else: b[j][l + 1] = 0 if l-1>=0: if b[j][l - 1] == 0: b[j][l - 1] = 1 else: b[j][l - 1] = 0 if j+1<3: if b[j+1][l] == 0: b[j+1][l] = 1 else: b[j+1][l] = 0 if j-1>=0: if b[j-1][l] == 0: b[j-1][l] = 1 else: b[j-1][l] = 0 for k in range(3): for p in range(3): print(b[k][p],end="") print() ```

0

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,683,725,299

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

import sys input = sys.stdin.readline def check_codeforces(s): if len(s) < len(CODEFORCES): return False for i in range(len(s)): if i + len(CODEFORCES) > len(s): break substring = s[i: i + len(CODEFORCES)] if substring == CODEFORCES: return True return False s = input().strip() if check_codeforces(s): print("YES") else: print("NO")

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 import sys input = sys.stdin.readline def check_codeforces(s): if len(s) < len(CODEFORCES): return False for i in range(len(s)): if i + len(CODEFORCES) > len(s): break substring = s[i: i + len(CODEFORCES)] if substring == CODEFORCES: return True return False s = input().strip() if check_codeforces(s): print("YES") else: print("NO") ```

-1

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,659,682,294

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

186

0

height = int(input()) growths = list(map(int, input().split())) growths.sort(reverse=True) sum = 0 counter = 0 for growth in growths: if height > sum: sum += growth counter += 1 print(counter)

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 height = int(input()) growths = list(map(int, input().split())) growths.sort(reverse=True) sum = 0 counter = 0 for growth in growths: if height > sum: sum += growth counter += 1 print(counter) ```

0

581

A

Vasya the Hipster

PROGRAMMING

800

[ "implementation", "math" ]

null

One day Vasya the Hipster decided to count how many socks he had. It turned out that he had *a* red socks and *b* blue socks. According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot. Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them. Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got. Can you help him?

The single line of the input contains two positive integers *a* and *b* (1<=≤<=*a*,<=*b*<=≤<=100) — the number of red and blue socks that Vasya's got.

Print two space-separated integers — the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got. Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day.

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

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

In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.

500

[ { "input": "3 1", "output": "1 1" }, { "input": "2 3", "output": "2 0" }, { "input": "7 3", "output": "3 2" }, { "input": "100 100", "output": "100 0" }, { "input": "4 10", "output": "4 3" }, { "input": "6 10", "output": "6 2" }, { "input": "6 11", "output": "6 2" }, { "input": "10 40", "output": "10 15" }, { "input": "11 56", "output": "11 22" }, { "input": "34 30", "output": "30 2" }, { "input": "33 33", "output": "33 0" }, { "input": "100 45", "output": "45 27" }, { "input": "100 23", "output": "23 38" }, { "input": "45 12", "output": "12 16" }, { "input": "1 1", "output": "1 0" }, { "input": "1 100", "output": "1 49" }, { "input": "100 1", "output": "1 49" }, { "input": "68 59", "output": "59 4" }, { "input": "45 99", "output": "45 27" }, { "input": "99 100", "output": "99 0" }, { "input": "100 98", "output": "98 1" }, { "input": "59 12", "output": "12 23" }, { "input": "86 4", "output": "4 41" }, { "input": "68 21", "output": "21 23" }, { "input": "100 11", "output": "11 44" }, { "input": "100 10", "output": "10 45" }, { "input": "15 45", "output": "15 15" }, { "input": "11 32", "output": "11 10" }, { "input": "34 96", "output": "34 31" }, { "input": "89 89", "output": "89 0" } ]

1,692,898,386

2,147,483,647

Python 3

OK

TESTS

30

46

0

a, b = map(int, input().split()) mins = min(a, b) #maxdd = mins same = abs(a - b) // 2 #msd = same print(mins, same)

Title: Vasya the Hipster Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day Vasya the Hipster decided to count how many socks he had. It turned out that he had *a* red socks and *b* blue socks. According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot. Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them. Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got. Can you help him? Input Specification: The single line of the input contains two positive integers *a* and *b* (1<=≤<=*a*,<=*b*<=≤<=100) — the number of red and blue socks that Vasya's got. Output Specification: Print two space-separated integers — the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got. Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day. Demo Input: ['3 1\n', '2 3\n', '7 3\n'] Demo Output: ['1 1\n', '2 0\n', '3 2\n'] Note: In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.

```python a, b = map(int, input().split()) mins = min(a, b) #maxdd = mins same = abs(a - b) // 2 #msd = same print(mins, same) ```

3

747

B

Mammoth's Genome Decoding

PROGRAMMING

900

[ "implementation", "strings" ]

null

The process of mammoth's genome decoding in Berland comes to its end! One of the few remaining tasks is to restore unrecognized nucleotides in a found chain *s*. Each nucleotide is coded with a capital letter of English alphabet: 'A', 'C', 'G' or 'T'. Unrecognized nucleotides are coded by a question mark '?'. Thus, *s* is a string consisting of letters 'A', 'C', 'G', 'T' and characters '?'. It is known that the number of nucleotides of each of the four types in the decoded genome of mammoth in Berland should be equal. Your task is to decode the genome and replace each unrecognized nucleotide with one of the four types so that the number of nucleotides of each of the four types becomes equal.

The first line contains the integer *n* (4<=≤<=*n*<=≤<=255) — the length of the genome. The second line contains the string *s* of length *n* — the coded genome. It consists of characters 'A', 'C', 'G', 'T' and '?'.

If it is possible to decode the genome, print it. If there are multiple answer, print any of them. If it is not possible, print three equals signs in a row: "===" (without quotes).

[ "8\nAG?C??CT\n", "4\nAGCT\n", "6\n????G?\n", "4\nAA??\n" ]

[ "AGACGTCT\n", "AGCT\n", "===\n", "===\n" ]

In the first example you can replace the first question mark with the letter 'A', the second question mark with the letter 'G', the third question mark with the letter 'T', then each nucleotide in the genome would be presented twice. In the second example the genome is already decoded correctly and each nucleotide is exactly once in it. In the third and the fourth examples it is impossible to decode the genom.

1,000

[ { "input": "8\nAG?C??CT", "output": "AGACGTCT" }, { "input": "4\nAGCT", "output": "AGCT" }, { "input": "6\n????G?", "output": "===" }, { "input": "4\nAA??", "output": "===" }, { "input": "4\n????", "output": "ACGT" }, { "input": "252\n???????GCG??T??TT?????T?C???C?CCG???GA???????AC??A???AAC?C?CC??CCC??A??TA?CCC??T???C??CA???CA??G????C?C?C????C??C??A???C?T????C??ACGC??CC?A?????A??CC?C??C?CCG?C??C??A??CG?A?????A?CT???CC????CCC?CATC?G??????????A???????????????TCCCC?C?CA??AC??GC????????", "output": "AAAAAAAGCGAATAATTAAAAATACAAACACCGAAAGAAAAAAAAACAAAAAAAACACACCAACCCAAAACTACCCCCCTCCCCCGCAGGGCAGGGGGGGCGCGCGGGGCGGCGGAGGGCGTGGGGCGGACGCGGCCGAGGGGGAGGCCGCGGCGCCGGCGGCGGAGGCGGAGTTTTATCTTTTCCTTTTCCCTCATCTGTTTTTTTTTTATTTTTTTTTTTTTTTTCCCCTCTCATTACTTGCTTTTTTTT" }, { "input": "255\n???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????", "output": "===" }, { "input": "4\n??A?", "output": "CGAT" }, { "input": "4\n?C??", "output": "ACGT" }, { "input": "4\nT???", "output": "TACG" }, { "input": "4\n???G", "output": "ACTG" }, { "input": "4\n??AC", "output": "GTAC" }, { "input": "8\n?C?AA???", "output": "CCGAAGTT" }, { "input": "12\n???A?G???A?T", "output": "ACCACGGGTATT" }, { "input": "16\n?????C??CAG??T??", "output": "AAACCCGGCAGGTTTT" }, { "input": "20\n???A?G??C?GC???????G", "output": "AAAAAGCCCCGCGGTTTTTG" }, { "input": "24\n?TG???AT?A?CTTG??T?GCT??", "output": "ATGAAAATCACCTTGCCTGGCTGG" }, { "input": "28\n??CTGAAG?GGT?CC?A??TT?CCACG?", "output": "AACTGAAGAGGTCCCGAGTTTTCCACGT" }, { "input": "32\n??A?????CAAG?C?C?CG??A?A??AAC?A?", "output": "CCACGGGGCAAGGCGCTCGTTATATTAACTAT" }, { "input": "36\n?GCC?CT?G?CGG?GCTGA?C?G?G????C??G?C?", "output": "AGCCACTAGACGGAGCTGAACAGAGCTTTCTTGTCT" }, { "input": "40\nTA?AA?C?G?ACC?G?GCTCGC?TG??TG?CT?G??CC??", "output": "TAAAAACAGAACCAGAGCTCGCCTGGGTGGCTTGTTCCTT" }, { "input": "44\nT?TA??A??AA???A?AGTA??TAT??ACTGAT??CT?AC?T??", "output": "TCTACCACCAACCCAGAGTAGGTATGGACTGATGGCTGACGTTT" }, { "input": "48\nG?G??GC??CA?G????AG?CA?CG??GGCCCCAA??G??C?T?TCA?", "output": "GAGAAGCAACAAGCCGGAGGCATCGTTGGCCCCAATTGTTCTTTTCAT" }, { "input": "52\n??G?G?CTGT??T?GCGCT?TAGGTT??C???GTCG??GC??C???????CG", "output": "AAGAGACTGTAATAGCGCTATAGGTTAACAACGTCGCCGCCCCGGTTTTTCG" }, { "input": "56\n?GCCA?GC?GA??GA??T?CCGC?????TGGC?AGGCCGC?AC?TGAT??CG?A??", "output": "AGCCAAGCAGAAAGAAATCCCGCCGGTTTGGCTAGGCCGCTACTTGATTTCGTATT" }, { "input": "60\nAT?T?CCGG??G?CCT?CCC?C?CGG????TCCCG?C?TG?TT?TA??A?TGT?????G?", "output": "ATATACCGGAAGACCTACCCACACGGAAAATCCCGCCCTGGTTGTAGGAGTGTGTTTTGT" }, { "input": "64\n?G??C??????C??C??AG?T?GC?TT??TAGA?GA?A??T?C???TC??A?CA??C??A???C", "output": "AGAACAAAAACCCCCCCAGCTCGCGTTGGTAGAGGAGAGGTGCGGGTCTTATCATTCTTATTTC" }, { "input": "68\nC?T??????C????G?T??TTT?T?T?G?CG??GCC??CT??????C??T?CC?T?T????CTT?T??", "output": "CATAAAAAACAAAAGATAATTTATATAGCCGCCGCCCCCTCCGGGGCGGTGCCGTGTGGGGCTTTTTT" }, { "input": "72\nA?GTA??A?TG?TA???AAAGG?A?T?TTAAT??GGA?T??G?T?T????TTATAAA?AA?T?G?TGT??TG", "output": "AAGTACCACTGCTACCCAAAGGCACTCTTAATCCGGACTCCGCTCTCGGGTTATAAAGAAGTGGGTGTGTTG" }, { "input": "76\nG?GTAC?CG?AG?AGC???A??T?TC?G??C?G?A???TC???GTG?C?AC???A??????TCA??TT?A?T?ATG", "output": "GAGTACACGAAGAAGCAAAAAATCTCCGCCCCGCACCCTCCGGGTGGCGACGGGAGGTTTTTCATTTTTATTTATG" }, { "input": "80\nGG???TAATT?A?AAG?G?TT???G??TTA?GAT?????GT?AA?TT?G?AG???G?T?A??GT??TTT?TTG??AT?T?", "output": "GGAAATAATTAAAAAGAGATTACCGCCTTACGATCCCCCGTCAACTTCGCAGCCCGCTCACGGTGGTTTGTTGGGATGTG" }, { "input": "84\n?C??G??CGGC????CA?GCGG???G?CG??GA??C???C???GC???CG?G?A?C?CC?AC?C?GGAG???C??????G???C", "output": "ACAAGAACGGCAAAACAAGCGGAAAGACGAAGACCCCCGCGGGGCGTTCGTGTATCTCCTACTCTGGAGTTTCTTTTTTGTTTC" }, { "input": "88\nGTTC?TCTGCGCGG??CATC?GTGCTCG?A?G?TGCAGCAG??A?CAG???GGTG?ATCAGG?TCTACTC?CG?GGT?A?TCC??AT?", "output": "GTTCATCTGCGCGGAACATCAGTGCTCGAAAGATGCAGCAGAAAACAGACCGGTGCATCAGGCTCTACTCGCGTGGTTATTCCTTATT" }, { "input": "92\n??TT????AT?T????A???TC????A?C????AT???T?T???T??A???T??TTA?AT?AA?C????C??????????????TAA?T???", "output": "AATTAAAAATATAAAAAACCTCCCCCACCCCCCATCCCTCTCCCTCGAGGGTGGTTAGATGAAGCGGGGCGGGGGGGGGGTTTTTAATTTTT" }, { "input": "96\nT?????C?CT?T??GGG??G??C???A?CC??????G???TCCCT??C?G??GC?CT?CGT?GGG??TCTC?C?CCGT?CCTCTT??CC?C?????", "output": "TAAAAACACTATAAGGGAAGAACAAAAACCAAAAAAGCGGTCCCTGGCGGGGGCGCTGCGTGGGGGGTCTCTCTCCGTTCCTCTTTTCCTCTTTTT" }, { "input": "100\n???GGA?C?A?A??A?G??GT?GG??G????A?ATGGAA???A?A?A?AGAGGT?GA?????AA???G???GA???TAGAG?ACGGA?AA?G???GGGAT", "output": "ACCGGACCCACACCACGCCGTCGGCCGCCCCACATGGAACCCACACAGAGAGGTGGATTTTTAATTTGTTTGATTTTAGAGTACGGATAATGTTTGGGAT" }, { "input": "104\n???TTG?C???G?G??G??????G?T??TC???CCC????TG?GGT??GG?????T?CG???GGG??GTC?G??TC??GG??CTGGCT??G????C??????TG", "output": "AAATTGACAAAGAGAAGAAAAAAGATAATCAAACCCAAAATGCGGTCCGGCCCCCTCCGCCCGGGCCGTCCGGGTCGGGGTTCTGGCTTTGTTTTCTTTTTTTG" }, { "input": "108\n??CAC?A?ACCA??A?CA??AA?TA?AT?????CCC????A??T?C?CATA??CAA?TACT??A?TA?AC?T??G???GG?G??CCC??AA?CG????T?CT?A??AA", "output": "AACACAACACCACCACCACCAACTACATCGGGGCCCGGGGAGGTGCGCATAGGCAAGTACTGGAGTAGACGTGGGTTTGGTGTTCCCTTAATCGTTTTTTCTTATTAA" }, { "input": "112\n???T?TC?C?AC???TC?C???CCC??C????C?CCGC???TG?C?T??????C?C?????G?C????A????????G?C?A?C?A?C?C??C????CC?TC??C??C?A??", "output": "AAATATCACAACAAATCACAAACCCAACAAAACACCGCAAATGCCGTGGGGGGCGCGGGGGGGCGGGGAGGGGGGTTGTCTATCTATCTCTTCTTTTCCTTCTTCTTCTATT" }, { "input": "116\n????C??A?A??AAC???????C???CCCTC??A????ATA?T??AT???C?TCCC???????C????CTC??T?A???C??A???CCA?TAC?AT?????C??CA???C?????C", "output": "AAAACAAAAAAAAACAAAAAACCCCCCCCTCCCACGGGATAGTGGATGGGCGTCCCGGGGGGGCGGGGCTCGGTGAGGGCGGATTTCCATTACTATTTTTTCTTCATTTCTTTTTC" }, { "input": "120\nTC?AGATG?GAT??G????C?C??GA?GT?TATAC?AGA?TCG?TCT???A?AAA??C?T?A???AA?TAC?ATTT???T?AA?G???TG?AT???TA??GCGG?AC?A??AT??T???C", "output": "TCAAGATGAGATAAGAACCCCCCCGACGTCTATACCAGACTCGCTCTCCCACAAACCCCTCACGGAAGTACGATTTGGGTGAAGGGGGTGGATGGGTAGTGCGGTACTATTATTTTTTTC" }, { "input": "124\n???C?????C?AGG??A?A?CA????A??A?AA??A????????G?A?????????AG?A??G?C??A??C???G??CG??C???????A????C???AG?AA???AC????????????C??G", "output": "AAACAAAAACAAGGAAAAAACACCCCACCACAACCACCCCCCCCGCACCCGGGGGGAGGAGGGGCGGAGGCGGGGGGCGGGCGTTTTTTATTTTCTTTAGTAATTTACTTTTTTTTTTTTCTTG" }, { "input": "128\nAT?GC?T?C?GATTTG??ATTGG?AC?GGCCA?T?GG?CCGG??AGT?TGT?G??A?AAGGCGG?T??TCT?CT??C?TTGTTG??????CCGG?TGATAT?T?TTGTCCCT??CTGTGTAATA??G?", "output": "ATAGCATACAGATTTGAAATTGGAACAGGCCAATAGGACCGGAAAGTATGTAGAAAAAAGGCGGCTCCTCTCCTCCCCTTGTTGCCCCCCCCGGCTGATATCTGTTGTCCCTGGCTGTGTAATAGGGT" }, { "input": "132\nAC???AA??T???T??G??ACG?C??AA?GA?C???CGAGTA?T??TTGTC???GCTGATCA????C??TA???ATTTA?C??GT??GTCTCTCGT?AAGGACTG?TC????T???C?T???ATTTT?T?AT", "output": "ACAAAAAAATAAATAAGAAACGACACAACGACCCCCCGAGTACTCCTTGTCCCCGCTGATCACCCCCCGTAGGGATTTAGCGGGTGGGTCTCTCGTGAAGGACTGGTCGGGGTGGGCGTTTTATTTTTTTAT" }, { "input": "136\n?A?C???????C??????????????C?????C???????????CCCC?????????C??????C??C??????CC??C??C?C???C??????C??C?C??????????C?????????GC????C???????C?", "output": "AAACAAAAAAACAAAAAAAAAAAAAACAAAAACAAAAACCCCCCCCCCCCCCGGGGGCGGGGGGCGGCGGGGGGCCGGCGGCGCGGGCGGGGGGCTTCTCTTTTTTTTTTCTTTTTTTTTGCTTTTCTTTTTTTCT" }, { "input": "140\nTTG??G?GG?G??C??CTC?CGG?TTCGC????GGCG?G??TTGCCCC?TCC??A??CG?GCCTTT?G??G??CT??TG?G?TTC?TGC?GG?TGT??CTGGAT??TGGTTG??TTGGTTTTTTGGTCGATCGG???C??", "output": "TTGAAGAGGAGAACAACTCACGGATTCGCAAAAGGCGAGAATTGCCCCATCCAAAAACGAGCCTTTAGAAGAACTAATGAGATTCCTGCCGGCTGTCCCTGGATCCTGGTTGCCTTGGTTTTTTGGTCGATCGGCCCCTT" }, { "input": "144\n?????A?C?A?A???TTT?GAATA?G??T?T?????AT?AA??TT???TT??A?T????AT??TA??AA???T??A??TT???A????T???T????A??T?G???A?C?T????A?AA??A?T?C??A??A???AA????ATA", "output": "AAAAAAACAAAACCCTTTCGAATACGCCTCTCCCCCATCAACCTTCCCTTCCACTCCCCATCCTACCAACCCTGGAGGTTGGGAGGGGTGGGTGGGGAGGTGGGGGAGCGTGGGGAGAAGGATTTCTTATTATTTAATTTTATA" }, { "input": "148\nACG?GGGT?A??C????TCTTGCTG?GTA?C?C?TG?GT??GGGG??TTG?CA????GT???G?TT?T?CT?C??C???CTTCATTA?G?G???GC?AAT??T???AT??GGATT????TC?C???????T??TATCG???T?T?CG?", "output": "ACGAGGGTAAAACAAAATCTTGCTGAGTAACACATGAGTAAGGGGAATTGACAAAAAGTAAAGATTCTCCTCCCCCCCCCTTCATTACGCGCCCGCCAATCCTCCCATCGGGATTGGGGTCGCGGGGGGGTGTTATCGTTTTTTTCGT" }, { "input": "152\n??CTA??G?GTC?G??TTCC?TG??????T??C?G???G?CC???C?GT?G?G??C?CGGT?CC????G?T?T?C?T??G?TCGT??????A??TCC?G?C???GTT?GC?T?CTT?GT?C??C?TCGTTG?TTG?G????CG?GC??G??G", "output": "AACTAAAGAGTCAGAATTCCATGAAAAAATAACAGAAAGACCAAACAGTAGAGAACACGGTACCAAAAGCTCTCCCTCCGCTCGTCCCCCCACGTCCGGGCGGGGTTGGCGTGCTTGGTGCGTCTTCGTTGTTTGTGTTTTCGTGCTTGTTG" }, { "input": "156\nGCA????A???AAT?C??????GAG?CCA?A?CG??ACG??????GCAAAC??GCGGTCC??GT???C???????CC???????ACGCA????C??A??CC??A?GAATAC?C?CA?CCCT?TCACA?A???????C??TAG?C??T??A??A?CA", "output": "GCAAAAAAAAAAATACAAAAACGAGCCCACACCGCCACGCCCGGGGCAAACGGGCGGTCCGGGTGGGCGGGGGGGCCGGGGGGGACGCAGGTTCTTATTCCTTATGAATACTCTCATCCCTTTCACATATTTTTTTCTTTAGTCTTTTTATTATCA" }, { "input": "160\nGCACC????T?TGATAC??CATATCC?GT?AGT?ATGGATA?CC?????GCTCG?A?GG?A?GCCAG??C?CGGATC?GCAA?AAGCCCCC?CAT?GA?GC?CAC?TAA?G?CACAACGG?AAA??CA?ACTCGA?CAC?GAGCAAC??A?G?AAA?TC?", "output": "GCACCACCCTGTGATACGGCATATCCGGTGAGTGATGGATAGCCGGGGGGCTCGGAGGGGATGCCAGTTCTCGGATCTGCAATAAGCCCCCTCATTGATGCTCACTTAATGTCACAACGGTAAATTCATACTCGATCACTGAGCAACTTATGTAAATTCT" }, { "input": "164\nGA?AGGT???T?G?A?G??TTA?TGTG?GTAGT?????T??TTTG?A?T??T?TA?G?T?GGT?????TGTGG?A?A?T?A?T?T?????TT?AAGAG?????T??TATATG?TATT??G?????GGGTATTTT?GG?A??TG??T?GAATGTG?AG?T???A?", "output": "GAAAGGTAAATAGAAAGAATTAATGTGAGTAGTAAAAATAATTTGAACTCCTCTACGCTCGGTCCCCCTGTGGCACACTCACTCTCCCCCTTCAAGAGCCCCCTCCTATATGCTATTCCGCCCCCGGGTATTTTCGGCAGGTGGGTGGAATGTGGAGGTGGGAG" }, { "input": "168\n?C?CAGTCCGT?TCC?GCG?T??T?TA?GG?GCTTGTTTTGT??GC???CTGT??T?T?C?ACG?GTGG??C??TC?GT??CTT?GGT??TGGC??G?TTTCTT?G??C?CTC??CT?G?TT?CG?C?A???GCCGTGAG?CTTC???TTCTCGG?C?CC??GTGCTT", "output": "ACACAGTCCGTATCCAGCGATAATATAAGGAGCTTGTTTTGTAAGCAAACTGTAATATACAACGAGTGGAACAATCAGTAACTTAGGTAATGGCAAGATTTCTTAGAACCCTCCCCTCGCTTCCGCCCACGGGCCGTGAGGCTTCGGGTTCTCGGGCGCCGGGTGCTT" }, { "input": "172\nG?ATG??G?TTT?ATA?GAAGCACTTGCT?AGC??AG??GTTCG?T?G??G?AC?TAGGGCT?TA?TTCTA?TTCAGGAA?GGAAATTGAAG?A?CT?GGTGAGTCTCT?AAACAGT??T??TCAGG?AGTG?TT?TAAT??GG?G?GCA???G?GGA?GACGAATACTCAA", "output": "GAATGAAGATTTAATACGAAGCACTTGCTCAGCCCAGCCGTTCGCTCGCCGCACCTAGGGCTCTACTTCTACTTCAGGAACGGAAATTGAAGCACCTCGGTGAGTCTCTCAAACAGTCCTCCTCAGGCAGTGGTTGTAATGGGGTGTGCATTTGTGGATGACGAATACTCAA" }, { "input": "176\n????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????", "output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT" }, { "input": "180\n?GTTACA?A?A?G??????GGGA?A??T?????C?AC??GG???G????T??CC??T?CGG?AG???GAAGG?????A?GT?G?????CTAA?A??C?A???A?T??C?A???AAA???G?GG?C?A??C???????GTCC?G??GT??G?C?G?C????TT??G????A???A???A?G", "output": "AGTTACAAAAAAGAAAAAAGGGAAAAATAAAAACAACAAGGCCCGCCCCTCCCCCCTCCGGCAGCCCGAAGGCCCCCACGTCGCCCCCCTAACACGCGAGGGAGTGGCGAGGGAAAGGGGGGGGCGAGTCTTTTTTTGTCCTGTTGTTTGTCTGTCTTTTTTTTGTTTTATTTATTTATG" }, { "input": "184\n?CTC?A??????C?T?TG??AC??????G???CCT????CT?C?TT???C???AT????????????T??T?A?AGT?C?C?C?C?CG??CAT?C??C???T??T?TCCTC????C??A???CG?C???C??TC??C?G?C????CTT????C??A?AT??C????T?TCT?T???C?CT??C?", "output": "ACTCAAAAAAAACATATGAAACAAAAAAGAAACCTAAAACTACATTAAACAAAATAAAACCCCCCCCTCCTCACAGTGCGCGCGCGCGGGCATGCGGCGGGTGGTGTCCTCGGGGCGGAGGGCGGCGGGCGGTCGGCGGGCGGGGCTTGTTTCTTATATTTCTTTTTTTCTTTTTTCTCTTTCT" }, { "input": "188\n????TG??A?G?GG?AGA??T??G?TA?ATTT?TTGA??TTA??T?G???GA?G?A??GG??ACTTGT?T?T?TCT?TG?TGAG??GT?A???TT?G???????TA???G?G?GTAG?G?T????????A?TT?TT?T??GGTGT??TTT?T?T?TT???GAGA??G?GGG?G??TG?GT?GT?A??T", "output": "AAAATGAAAAGAGGAAGAAATAAGATAAATTTATTGAAATTAAATAGAAAGAAGAAAAGGACACTTGTCTCTCTCTCTGCTGAGCCGTCACCCTTCGCCCCCCCTACCCGCGCGTAGCGCTCCCCCCCCACTTCTTCTCCGGTGTCCTTTCTCTCTTGGGGAGAGGGGGGGGGGGTGGGTGGTTATTT" }, { "input": "192\nTT???TA?A?TTCTCA?ATCCCC?TA?T??A?A?TGT?TT??TAA?C?C?TA?CTAAAT???AA?TT???T?AATAG?AC??AC?A??A?TT?A?TT?AA?TCTTTC??A?AAA?AA??T?AG?C??AT?T?TATCT?CTTCAA?ACAAAT???AT?TT??????C?CTC???TT?ACACACTGCA?AC??T", "output": "TTAACTACACTTCTCACATCCCCCTACTCCACACTGTCTTCCTAACCCCCTACCTAAATCCCAACTTCGGTGAATAGGACGGACGAGGAGTTGAGTTGAAGTCTTTCGGAGAAAGAAGGTGAGGCGGATGTGTATCTGCTTCAAGACAAATGGGATGTTGGGGGGCGCTCGGGTTGACACACTGCAGACTTT" }, { "input": "196\n??ACATCC??TGA?C?AAA?A???T????A??ACAC????T???????CCC?AAT?T?AT?A?A??TATC??CC?CCACACA?CC?A?AGC??AAA??A???A?CA??A?AT??G???CA?ACATTCG??CACAT?AC???A?A?C?CTTT?AAG??A?TAC???C?GCAA?T??C??AA???GAC?ATTAT????", "output": "ACACATCCCCTGACCCAAACACCCTCCCCACCACACCGGGTGGGGGGGCCCGAATGTGATGAGAGGTATCGGCCGCCACACAGCCGAGAGCGGAAAGGAGGGAGCAGGAGATGGGGGGCAGACATTCGGGCACATTACTTTATATCTCTTTTAAGTTATTACTTTCTGCAATTTTCTTAATTTGACTATTATTTTT" }, { "input": "200\n?CT?T?C???AC?G?CAC?C?T??T?G?AGAGTA?CT????A?CCCAT?GCT?TTC?CAG???TCCATAAC?GACT?TC??C?AG?AA?A?C??ATC?CTAT?AC??????ACCGA??A????C?AA???CGCTTCGC?A????A??GCC?AG?T?????T?A?C?A?CTTC?????T?T?????GC?GTACTC??TG??", "output": "ACTATACAAAACAGACACACATAATAGAAGAGTAACTAAAAAACCCATCGCTCTTCCCAGCCCTCCATAACCGACTCTCCCCCAGCAAGAGCGGATCGCTATGACGGGGGGACCGAGGAGGGGCGAAGGGCGCTTCGCGAGGGGAGGGCCGAGGTGGGTTTTATCTATCTTCTTTTTTTTTTTTTGCTGTACTCTTTGTT" }, { "input": "204\n??????T???T?GC?TC???TA?TC?????A??C?C??G??????G?CTC????A?CTTT?T???T??CTTA???????T??C??G????A?????TTTA??AT?A??C?C?T?C???C?????T???????GT????T????AT?CT????C??C??T???C????C?GCTTCCC?G?????T???C?T??????????TT??", "output": "AAAAAATAAATAGCATCAAATAATCAAAAAAAACACAAGAAAAAAGACTCAAAAAACTTTATAAATACCTTACCCCCCCTCCCCCGCCCCACCCCCTTTACCATCACCCCCGTGCGGGCGGGGGTGGGGGGGGTGGGGTGGGGATGCTGGGGCGGCGGTGGGCGGGGCGGCTTCCCGGGTTTTTTTTCTTTTTTTTTTTTTTTT" }, { "input": "208\nA?GGT?G??A???????G??A?A?GA?T?G???A?AAG?AT????GG?????AT??A?A???T?A??????A????AGGCGT???A???TA????TGGT???GA????GGTG???TA??GA??TA?GGG?????G?????AT?GGGG??TG?T?AA??A??AG?AA?TGA???A?A?GG???GAAT?G?T??T?A??G?CAGT?T?A?", "output": "AAGGTAGAAAAAAAAAAGAAAAAAGAATCGCCCACAAGCATCCCCGGCCCCCATCCACACCCTCACCCCCCACCCCAGGCGTCCCACCCTACCCCTGGTCCCGACCCCGGTGCGGTAGGGAGGTAGGGGGGGGGGGGGGTATTGGGGTTTGTTTAATTATTAGTAATTGATTTATATGGTTTGAATTGTTTTTTATTGTCAGTTTTAT" }, { "input": "212\nT?TTT?A??TC?????A?T??T????T????????C??T??AT????????T???TT????T?TTT??????????TTC???T?T?C??T?TA?C??TTT????T???????C????????A?TT???T??TTT??AT?T????T????T?????A??C????T??T???TA???A?????????T???C????????C???T?TA???TTT", "output": "TATTTAAAATCAAAAAAATAATAAAATAAAAAAAACAATAAATAAAAAAAATAAATTAAAATCTTTCCCCCCCCCCTTCCCCTCTCCCCTCTACCCCTTTCCCCTCCCCCCCCCCCCCCCCACTTCCGTGGTTTGGATGTGGGGTGGGGTGGGGGAGGCGGGGTGGTGGGTAGGGAGGGGGGGGGTGGGCGGGGGGGGCTTTTTTATTTTTT" }, { "input": "216\n?CT?A?CC?GCC?C?AT?A???C???TA????ATGTCCG??CCG?CGG?TCC?TTC??CCT????????G?GGC?TACCCGACCGAG?C???C?G?G??C??CGTCCTG??AGG??CT?G???TC?CT????A?GTA??C?C?CTGTTAC??C?TCT?C?T???T??GTGGA?AG?CGCT?CGTC???T?C?T?C?GTT???C??GCC?T??C?T?", "output": "ACTAAACCAGCCACAATAAAAACAAATAAAAAATGTCCGAACCGACGGATCCATTCAACCTAAAAAAAAGAGGCATACCCGACCGAGACAAACAGAGCCCCCCGTCCTGCGAGGGGCTGGGGGTCGCTGGGGAGGTAGGCGCGCTGTTACGGCGTCTGCGTGGGTTTGTGGATAGTCGCTTCGTCTTTTTCTTTCTGTTTTTCTTGCCTTTTCTTT" }, { "input": "220\n?GCC??????T????G?CTC???CC?C????GC??????C???TCCC???????GCC????????C?C??C?T?C?CC????CC??C???????CC??C?G?A?T???CC??C????????C????CTA?GC?????CC??C?C?????T?????G?????????G???AC????C?CG?????C?G?C?CG?????????G?C????C?G??????C??", "output": "AGCCAAAAAATAAAAGACTCAAACCACAAAAGCAAAAAACAAATCCCAAAAAAAGCCAAAAAAAACACAACATACACCAACCCCCCCCCCCCCGCCGGCGGGAGTGGGCCGGCGGGGGGGGCGGGGCTAGGCGGGGGCCGGCGCGGGGGTGGGGGGTTTTTTTTTGTTTACTTTTCTCGTTTTTCTGTCTCGTTTTTTTTTGTCTTTTCTGTTTTTTCTT" }, { "input": "224\nTTGC?G??A?ATCA??CA???T?TG?C?CGA?CTTA?C??C?TTC?AC?CTCA?A?AT?C?T?CT?CATGT???A??T?CT????C?AACT?TTCCC??C?AAC???AC?TTTC?TTAAA??????TGT????CGCT????GCCC?GCCCA?????TCGA??C?TATACA??C?CC?CATAC?GGACG??GC??GTT?TT?T???GCT??T?C?T?C??T?CC?", "output": "TTGCAGAAAAATCAAACAAAATATGACACGAACTTAACAACATTCAACACTCAAAAATACATACTACATGTAAAACCTCCTCCCCCCAACTGTTCCCGGCGAACGGGACGTTTCGTTAAAGGGGGGTGTGGGGCGCTGGGGGCCCGGCCCAGGGGGTCGAGGCGTATACAGGCGCCGCATACGGGACGGGGCGTGTTTTTTTTTTGCTTTTTCTTTCTTTTCCT" }, { "input": "228\nA??A?C???AG?C?AC???A?T?????AA??????C?A??A?AC?????C?C???A??????A???AC?C????T?C?AA?C??A???CC??????????????????A???CC????A?????C??TC???A???????????A??A????????????????CC?????CCA??????????????C??????C????T?CT???C???A???T?CC?G??C??A?", "output": "AAAAACAAAAGACAACAAAAATAAAAAAAAAAAAACAAAAAAACAAAAACACCCCACCCCCCACCCACCCCCCCTCCCAACCCCACCCCCCCCCGGGGGGGGGGGGGGAGGGCCGGGGAGGGGGCGGTCGGGAGGGGGGGGGGGAGGAGGGGGGGGGGGTTTTTCCTTTTTCCATTTTTTTTTTTTTTCTTTTTTCTTTTTTCTTTTCTTTATTTTTCCTGTTCTTAT" }, { "input": "232\nA??AAGC?GCG?AG???GGGCG?C?A?GCAAC?AG?C?GC??CA??A??CC?AA?A????G?AGA?ACACA?C?G?G?G?CGC??G???????GAGC?CAA??????G?A???AGGG?????AAC?AG?A?A??AG?CG?G???G????GGGA?C?G?A?A??GC????C??A?ACG?AA?G?ACG????AC?C?GA??GGCAG?GAA??ACA??A?AGGAGG???CGGA?C", "output": "AAAAAGCAGCGAAGAAAGGGCGACAAAGCAACCAGCCCGCCCCACCACCCCCAACACCCCGCAGACACACACCCGCGCGCCGCCCGCCCGGGGGAGCGCAAGGGGGTGTATTTAGGGTTTTTAACTAGTATATTAGTCGTGTTTGTTTTGGGATCTGTATATTGCTTTTCTTATACGTAATGTACGTTTTACTCTGATTGGCAGTGAATTACATTATAGGAGGTTTCGGATC" }, { "input": "236\nAAGCCC?A?TT??C?AATGC?A?GC?GACGT?CTT?TA??CCG?T?CAA?AGT?CTG???GCGATG?TG?A?A?ACT?AT?GGG?GC?C?CGCCCTT?GT??G?T?????GACTT??????CT?GA?GG?C?T?G??CTG??G??TG?TCA?TCGTT?GC?A?G?GGGT?CG?CGAG??CG?TC?TAT?A???T??GAGTC?CGGC?CG??CT?TAAT??GGAA?G??GG?GCGAC", "output": "AAGCCCAAATTAACAAATGCAAAGCAGACGTACTTATAAACCGATACAAAAGTACTGAAAGCGATGATGAAAAAACTAATAGGGAGCACACGCCCTTAGTACGCTCCCCCGACTTCCCCCCCTCGACGGCCCTCGCCCTGCGGGGTGGTCAGTCGTTGGCGAGGGGGGTGCGTCGAGTTCGTTCTTATTATTTTTTGAGTCTCGGCTCGTTCTTTAATTTGGAATGTTGGTGCGAC" }, { "input": "240\n?T?A?A??G????G????AGGAGTAA?AGGCT??C????AT?GAA?ATGCT???GA?G?A??G?TC??TATT???AG?G?G?A?A??TTGT??GGTCAG?GA?G?AAT?G?GG??CAG?T?GT?G?GC???GC??????GA?A?AAATGGGC??G??????TTA??GTCG?TC?GCCG?GGGA??T?A????T?G?T???G?GG?ATG???A?ATGAC?GGT?CTG?AGGG??TAGT?AG", "output": "ATAAAAAAGAAAAGAAAAAGGAGTAAAAGGCTAACAAAAATAGAAAATGCTACCGACGCACCGCTCCCTATTCCCAGCGCGCACACCTTGTCCGGTCAGCGACGCAATCGCGGCCCAGCTCGTCGCGCCCCGCCCCCCCGACACAAATGGGCCCGCGGGGGTTATTGTCGTTCTGCCGTGGGATTTTATTTTTTGTTTTTGTGGTATGTTTATATGACTGGTTCTGTAGGGTTTAGTTAG" }, { "input": "244\nC?GT???T??TA?CC??TACT???TC?C?A???G??G?TCC?AC??AA???C?CCACC????A?AGCC??T?CT??CCGG?CC?T?C??GCCCTGGCCAAAC???GC?C???AT?CC?CT?TAG??CG?C?T?C??A?AC?GC????A??C?C?A??TC?T????GCCCT??GG???CC?A?CC?G?A?CA?G??CCCG??CG?T?TAC?G???C?AC??G??CCA???G????C??G?CT?C?", "output": "CAGTAAATAATAACCAATACTAAATCACAAAAAGAAGATCCAACAAAAAAACACCACCAAAAAAAGCCAATACTAACCGGGCCGTGCGGGCCCTGGCCAAACGGGGCGCGGGATGCCGCTGTAGGGCGGCGTGCGGAGACGGCGGGGAGGCGCGAGGTCGTGGTTGCCCTTTGGTTTCCTATCCTGTATCATGTTCCCGTTCGTTTTACTGTTTCTACTTGTTCCATTTGTTTTCTTGTCTTCT" }, { "input": "248\n??TC???TG??G??T????CC???C?G?????G?????GT?A?CT?AAT?GG?AGA?????????G???????G???CG??AA?A????T???????TG?CA????C?TT?G?GC???AA?G????G????T??G??A??????TT???G???CG?????A??A??T?GA??G??T?CC?TA??GCTG?A????G?CG??GGTG??CA???????TA??G?????????A???????GC?GG????GC", "output": "AATCAAATGAAGAATAAAACCAAACAGAAAAAGAAAAAGTAAACTAAATAGGAAGAAAAAAAAAAGACCCCCCGCCCCGCCAACACCCCTCCCCCCCTGCCACCCCCCTTCGCGCCCCAACGCCCCGCCCCTCCGGGAGGGGGGTTGGGGGGGCGGGGGGAGGAGGTGGAGGGGGTGCCTTATTGCTGTATTTTGTCGTTGGTGTTCATTTTTTTTATTGTTTTTTTTTATTTTTTTGCTGGTTTTGC" }, { "input": "8\n???AAA??", "output": "===" }, { "input": "12\nC??CC??????C", "output": "===" }, { "input": "4\nG??G", "output": "===" }, { "input": "4\nTT??", "output": "===" }, { "input": "4\nACAC", "output": "===" }, { "input": "8\nACGT???T", "output": "ACGTACGT" }, { "input": "252\n????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????", "output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT" }, { "input": "252\n??????????????????????????????????????????????????????????????????????????????A?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????", "output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT" }, { "input": "252\n???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????C????????????????????????????????????????????????????????????????", "output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGCGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT" }, { "input": "252\n???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????G", "output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTG" }, { "input": "252\nT???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????", "output": "TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT" }, { "input": "4\nAA?T", "output": "===" }, { "input": "4\nAAAA", "output": "===" }, { "input": "8\nAAA?????", "output": "===" }, { "input": "10\nACGT??????", "output": "===" }, { "input": "6\nACGACG", "output": "===" }, { "input": "5\nAAAAA", "output": "===" }, { "input": "8\nGGGGAA??", "output": "===" }, { "input": "5\nATGCA", "output": "===" }, { "input": "4\nTTTT", "output": "===" }, { "input": "4\nACCG", "output": "===" }, { "input": "8\nACGTA?GT", "output": "ACGTACGT" } ]

1,633,694,280

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

4

62

6,963,200

n=int(input()) a=input() ag=a.count("A") gg=a.count("G") cg=a.count("C") tg=a.count("T") vg=a.count("?") b='' if vg==0: print(a) else: if n%4==0: ma=max(ag,max(gg,max(cg,tg))) if ma==n//4: for i in range(n): if a[i]!="?": b=b+a[i] else: if b.count("A")<n//4 and a[i+1::].count("A")+1+b.count("A")<=n//4: b=b+"A" elif b.count("G")<n//4 and a[i+1::].count("G")+1+b.count("G")<=n//4: b=b+"G" elif b.count("C")<n//4 and a[i+1::].count("C")+1+b.count("C")<=n//4: b=b+"C" elif b.count("T")<n//4 and a[i+1::].count("T")+1+b.count("T")<=n//4: b=b+"T" print(b) else: print("===") else: print("===")

Title: Mammoth's Genome Decoding Time Limit: None seconds Memory Limit: None megabytes Problem Description: The process of mammoth's genome decoding in Berland comes to its end! One of the few remaining tasks is to restore unrecognized nucleotides in a found chain *s*. Each nucleotide is coded with a capital letter of English alphabet: 'A', 'C', 'G' or 'T'. Unrecognized nucleotides are coded by a question mark '?'. Thus, *s* is a string consisting of letters 'A', 'C', 'G', 'T' and characters '?'. It is known that the number of nucleotides of each of the four types in the decoded genome of mammoth in Berland should be equal. Your task is to decode the genome and replace each unrecognized nucleotide with one of the four types so that the number of nucleotides of each of the four types becomes equal. Input Specification: The first line contains the integer *n* (4<=≤<=*n*<=≤<=255) — the length of the genome. The second line contains the string *s* of length *n* — the coded genome. It consists of characters 'A', 'C', 'G', 'T' and '?'. Output Specification: If it is possible to decode the genome, print it. If there are multiple answer, print any of them. If it is not possible, print three equals signs in a row: "===" (without quotes). Demo Input: ['8\nAG?C??CT\n', '4\nAGCT\n', '6\n????G?\n', '4\nAA??\n'] Demo Output: ['AGACGTCT\n', 'AGCT\n', '===\n', '===\n'] Note: In the first example you can replace the first question mark with the letter 'A', the second question mark with the letter 'G', the third question mark with the letter 'T', then each nucleotide in the genome would be presented twice. In the second example the genome is already decoded correctly and each nucleotide is exactly once in it. In the third and the fourth examples it is impossible to decode the genom.

```python n=int(input()) a=input() ag=a.count("A") gg=a.count("G") cg=a.count("C") tg=a.count("T") vg=a.count("?") b='' if vg==0: print(a) else: if n%4==0: ma=max(ag,max(gg,max(cg,tg))) if ma==n//4: for i in range(n): if a[i]!="?": b=b+a[i] else: if b.count("A")<n//4 and a[i+1::].count("A")+1+b.count("A")<=n//4: b=b+"A" elif b.count("G")<n//4 and a[i+1::].count("G")+1+b.count("G")<=n//4: b=b+"G" elif b.count("C")<n//4 and a[i+1::].count("C")+1+b.count("C")<=n//4: b=b+"C" elif b.count("T")<n//4 and a[i+1::].count("T")+1+b.count("T")<=n//4: b=b+"T" print(b) else: print("===") else: print("===") ```

0

75

C

Modified GCD

PROGRAMMING

1,600

[ "binary search", "number theory" ]

C. Modified GCD

2

256

Well, here is another math class task. In mathematics, GCD is the greatest common divisor, and it's an easy task to calculate the GCD between two positive integers. A common divisor for two positive numbers is a number which both numbers are divisible by. But your teacher wants to give you a harder task, in this task you have to find the greatest common divisor *d* between two integers *a* and *b* that is in a given range from *low* to *high* (inclusive), i.e. *low*<=≤<=*d*<=≤<=*high*. It is possible that there is no common divisor in the given range. You will be given the two integers *a* and *b*, then *n* queries. Each query is a range from *low* to *high* and you have to answer each query.

The first line contains two integers *a* and *b*, the two integers as described above (1<=≤<=*a*,<=*b*<=≤<=109). The second line contains one integer *n*, the number of queries (1<=≤<=*n*<=≤<=104). Then *n* lines follow, each line contains one query consisting of two integers, *low* and *high* (1<=≤<=*low*<=≤<=*high*<=≤<=109).

Print *n* lines. The *i*-th of them should contain the result of the *i*-th query in the input. If there is no common divisor in the given range for any query, you should print -1 as a result for this query.

[ "9 27\n3\n1 5\n10 11\n9 11\n" ]

[ "3\n-1\n9\n" ]

none

1,500

[ { "input": "9 27\n3\n1 5\n10 11\n9 11", "output": "3\n-1\n9" }, { "input": "48 72\n2\n8 29\n29 37", "output": "24\n-1" }, { "input": "90 100\n10\n51 61\n6 72\n1 84\n33 63\n37 69\n18 21\n9 54\n49 90\n14 87\n37 90", "output": "-1\n10\n10\n-1\n-1\n-1\n10\n-1\n-1\n-1" }, { "input": "84 36\n1\n18 32", "output": "-1" }, { "input": "90 36\n16\n13 15\n5 28\n11 30\n26 35\n2 8\n19 36\n3 17\n5 14\n4 26\n22 33\n16 33\n18 27\n4 17\n1 2\n29 31\n18 36", "output": "-1\n18\n18\n-1\n6\n-1\n9\n9\n18\n-1\n18\n18\n9\n2\n-1\n18" }, { "input": "84 90\n18\n10 75\n2 40\n30 56\n49 62\n19 33\n5 79\n61 83\n13 56\n73 78\n1 18\n23 35\n14 72\n22 33\n1 21\n8 38\n54 82\n6 80\n57 75", "output": "-1\n6\n-1\n-1\n-1\n6\n-1\n-1\n-1\n6\n-1\n-1\n-1\n6\n-1\n-1\n6\n-1" }, { "input": "84 100\n16\n10 64\n3 61\n19 51\n42 67\n51 68\n12 40\n10 47\n52 53\n37 67\n2 26\n23 47\n17 75\n49 52\n3 83\n63 81\n8 43", "output": "-1\n4\n-1\n-1\n-1\n-1\n-1\n-1\n-1\n4\n-1\n-1\n-1\n4\n-1\n-1" }, { "input": "36 60\n2\n17 25\n16 20", "output": "-1\n-1" }, { "input": "90 100\n8\n55 75\n46 68\n44 60\n32 71\n43 75\n23 79\n47 86\n11 57", "output": "-1\n-1\n-1\n-1\n-1\n-1\n-1\n-1" }, { "input": "90 36\n8\n1 19\n10 12\n14 28\n21 24\n8 8\n33 34\n10 26\n15 21", "output": "18\n-1\n18\n-1\n-1\n-1\n18\n18" }, { "input": "48 80\n19\n1 1\n16 16\n1 16\n16 48\n16 80\n16 1000000000\n1000000000 1000000000\n1 1000000000\n500000000 1000000000\n15 17\n17 17\n15 15\n8 8\n8 15\n8 16\n8 17\n7 17\n7 15\n9 15", "output": "1\n16\n16\n16\n16\n16\n-1\n16\n-1\n16\n-1\n-1\n8\n8\n16\n16\n16\n8\n-1" }, { "input": "31607 999002449\n18\n31607 31607\n31606 31608\n31607 31608\n31606 31607\n31606 31606\n31608 31608\n1 31607\n1 31606\n1 31608\n1 1000000000\n31607 1000000000\n31606 1000000000\n31608 1000000000\n1000000000 1000000000\n1 1\n2 31606\n2 31607\n2 31608", "output": "31607\n31607\n31607\n31607\n-1\n-1\n31607\n1\n31607\n31607\n31607\n31607\n-1\n-1\n1\n-1\n31607\n31607" }, { "input": "999999937 999999929\n12\n999999929 999999937\n1 1\n1 1000000000\n2 1000000000\n1 2\n999999937 999999937\n999999929 999999929\n2 2\n3 3\n1 100\n1 999999937\n1 999999929", "output": "-1\n1\n1\n-1\n1\n-1\n-1\n-1\n-1\n1\n1\n1" } ]

1,664,945,516

2,147,483,647

PyPy 3-64

OK

TESTS

60

340

10,137,600

from sys import stdin input = stdin.readline from math import gcd as GCD from bisect import bisect_left def GetPrimes(max_prime): is_prime = [True for i in range(max_prime + 1)] primes = [] for p in range(2, max_prime + 1): if is_prime[p]: primes += [p] for n in range(2*p, max_prime + 1, p): is_prime[n] = False return primes def GetPrimeFactorization(x): prime_factors = [] prime_powers = [] for p in primes: power = 0 while x%p == 0: power +=1 x//=p if power: prime_factors += [p] prime_powers += [power] if x > 1: prime_factors += [x] prime_powers += [1] return prime_factors, prime_powers def GetFactors(prime_factors, prime_powers): factors = {1} for prime, power in zip(prime_factors, prime_powers): for i in range(power): factors.update({prime * x for x in factors}) return sorted(factors) a,b = [int(x) for x in input().split()] gcd = GCD(a,b) primes = GetPrimes(int(gcd**0.5)+1) prime_factors, prime_powers = GetPrimeFactorization(gcd) ''' print("a,b = ", a,b) print("gcd =", gcd) length = len(prime_factors) if length == 1: print("gcd = %d ^ %d"%(prime_factors[0], prime_powers[0])) else: print("gcd = ", end = "") for i in range(length - 1): print("%d ^ %d * "%(prime_factors[i], prime_powers[i])) print("%d ^ %d * "%(prime_factors[-1], prime_powers[-1])) ''' factors = GetFactors(prime_factors, prime_powers) length = len(factors) # have a prime factorization of gcd # get every factor of gcd num_test_cases = int(input()) for test_case_ittr in range(num_test_cases): low, high = [int(x) for x in input().split()] # find the biggest common factor in [low, high] i = bisect_left(factors, high) if i == length or factors[i] > high: i-=1 if i == -1: print(-1) continue factor = factors[i] if (low <= factor <= high): print(factor) else: print(-1)

Title: Modified GCD Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Well, here is another math class task. In mathematics, GCD is the greatest common divisor, and it's an easy task to calculate the GCD between two positive integers. A common divisor for two positive numbers is a number which both numbers are divisible by. But your teacher wants to give you a harder task, in this task you have to find the greatest common divisor *d* between two integers *a* and *b* that is in a given range from *low* to *high* (inclusive), i.e. *low*<=≤<=*d*<=≤<=*high*. It is possible that there is no common divisor in the given range. You will be given the two integers *a* and *b*, then *n* queries. Each query is a range from *low* to *high* and you have to answer each query. Input Specification: The first line contains two integers *a* and *b*, the two integers as described above (1<=≤<=*a*,<=*b*<=≤<=109). The second line contains one integer *n*, the number of queries (1<=≤<=*n*<=≤<=104). Then *n* lines follow, each line contains one query consisting of two integers, *low* and *high* (1<=≤<=*low*<=≤<=*high*<=≤<=109). Output Specification: Print *n* lines. The *i*-th of them should contain the result of the *i*-th query in the input. If there is no common divisor in the given range for any query, you should print -1 as a result for this query. Demo Input: ['9 27\n3\n1 5\n10 11\n9 11\n'] Demo Output: ['3\n-1\n9\n'] Note: none

```python from sys import stdin input = stdin.readline from math import gcd as GCD from bisect import bisect_left def GetPrimes(max_prime): is_prime = [True for i in range(max_prime + 1)] primes = [] for p in range(2, max_prime + 1): if is_prime[p]: primes += [p] for n in range(2*p, max_prime + 1, p): is_prime[n] = False return primes def GetPrimeFactorization(x): prime_factors = [] prime_powers = [] for p in primes: power = 0 while x%p == 0: power +=1 x//=p if power: prime_factors += [p] prime_powers += [power] if x > 1: prime_factors += [x] prime_powers += [1] return prime_factors, prime_powers def GetFactors(prime_factors, prime_powers): factors = {1} for prime, power in zip(prime_factors, prime_powers): for i in range(power): factors.update({prime * x for x in factors}) return sorted(factors) a,b = [int(x) for x in input().split()] gcd = GCD(a,b) primes = GetPrimes(int(gcd**0.5)+1) prime_factors, prime_powers = GetPrimeFactorization(gcd) ''' print("a,b = ", a,b) print("gcd =", gcd) length = len(prime_factors) if length == 1: print("gcd = %d ^ %d"%(prime_factors[0], prime_powers[0])) else: print("gcd = ", end = "") for i in range(length - 1): print("%d ^ %d * "%(prime_factors[i], prime_powers[i])) print("%d ^ %d * "%(prime_factors[-1], prime_powers[-1])) ''' factors = GetFactors(prime_factors, prime_powers) length = len(factors) # have a prime factorization of gcd # get every factor of gcd num_test_cases = int(input()) for test_case_ittr in range(num_test_cases): low, high = [int(x) for x in input().split()] # find the biggest common factor in [low, high] i = bisect_left(factors, high) if i == length or factors[i] > high: i-=1 if i == -1: print(-1) continue factor = factors[i] if (low <= factor <= high): print(factor) else: print(-1) ```

3.896117

488

A

Giga Tower

PROGRAMMING

1,100

[ "brute force" ]

null

Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view. In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?). Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.

The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).

Print the minimum *b* in a line.

[ "179\n", "-1\n", "18\n" ]

[ "1\n", "9\n", "10\n" ]

For the first sample, he has to arrive at the floor numbered 180. For the second sample, he will arrive at 8. Note that *b* should be positive, so the answer for the third sample is 10, not 0.

500

[ { "input": "179", "output": "1" }, { "input": "-1", "output": "9" }, { "input": "18", "output": "10" }, { "input": "-410058385", "output": "1" }, { "input": "-586825624", "output": "1" }, { "input": "852318890", "output": "1" }, { "input": "919067153", "output": "5" }, { "input": "690422411", "output": "7" }, { "input": "-408490162", "output": "1" }, { "input": "-8", "output": "16" }, { "input": "-6", "output": "14" }, { "input": "-4", "output": "12" }, { "input": "-2", "output": "10" }, { "input": "0", "output": "8" }, { "input": "2", "output": "6" }, { "input": "4", "output": "4" }, { "input": "6", "output": "2" }, { "input": "8", "output": "10" }, { "input": "1000000000", "output": "8" }, { "input": "-1000000000", "output": "2" }, { "input": "88888", "output": "1" }, { "input": "89", "output": "9" }, { "input": "-80000000", "output": "2" }, { "input": "-8888", "output": "1" }, { "input": "-17", "output": "9" }, { "input": "78", "output": "2" }, { "input": "-19", "output": "1" }, { "input": "-999999998", "output": "9" }, { "input": "-999999997", "output": "8" }, { "input": "999999997", "output": "1" }, { "input": "811111111", "output": "1" }, { "input": "-8", "output": "16" }, { "input": "-5", "output": "13" }, { "input": "-7", "output": "15" }, { "input": "1000000000", "output": "8" } ]

1,593,928,150

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

3

124

20,172,800

n=(input()) floor=0 if n.count('8')==1: floor=1 n=str(floor+int(n)) while(True): if n.count('8')==1: break else: floor+=1 n=str(1+int(n)) else: while(True): if n.count('8')==1: break else: floor+=1 n=str(1+int(n)) print(floor)

Title: Giga Tower Time Limit: None seconds Memory Limit: None megabytes Problem Description: Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view. In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?). Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number. Input Specification: The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109). Output Specification: Print the minimum *b* in a line. Demo Input: ['179\n', '-1\n', '18\n'] Demo Output: ['1\n', '9\n', '10\n'] Note: For the first sample, he has to arrive at the floor numbered 180. For the second sample, he will arrive at 8. Note that *b* should be positive, so the answer for the third sample is 10, not 0.

```python n=(input()) floor=0 if n.count('8')==1: floor=1 n=str(floor+int(n)) while(True): if n.count('8')==1: break else: floor+=1 n=str(1+int(n)) else: while(True): if n.count('8')==1: break else: floor+=1 n=str(1+int(n)) print(floor) ```

0

160

A

Twins

PROGRAMMING

900

[ "greedy", "sortings" ]

null

Imagine that you have a twin brother or sister. Having another person that looks exactly like you seems very unusual. It's hard to say if having something of an alter ego is good or bad. And if you do have a twin, then you very well know what it's like. Now let's imagine a typical morning in your family. You haven't woken up yet, and Mom is already going to work. She has been so hasty that she has nearly forgotten to leave the two of her darling children some money to buy lunches in the school cafeteria. She fished in the purse and found some number of coins, or to be exact, *n* coins of arbitrary values *a*1,<=*a*2,<=...,<=*a**n*. But as Mom was running out of time, she didn't split the coins for you two. So she scribbled a note asking you to split the money equally. As you woke up, you found Mom's coins and read her note. "But why split the money equally?" — you thought. After all, your twin is sleeping and he won't know anything. So you decided to act like that: pick for yourself some subset of coins so that the sum of values of your coins is strictly larger than the sum of values of the remaining coins that your twin will have. However, you correctly thought that if you take too many coins, the twin will suspect the deception. So, you've decided to stick to the following strategy to avoid suspicions: you take the minimum number of coins, whose sum of values is strictly more than the sum of values of the remaining coins. On this basis, determine what minimum number of coins you need to take to divide them in the described manner.

The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of coins. The second line contains a sequence of *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=100) — the coins' values. All numbers are separated with spaces.

In the single line print the single number — the minimum needed number of coins.

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

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

In the first sample you will have to take 2 coins (you and your twin have sums equal to 6, 0 correspondingly). If you take 1 coin, you get sums 3, 3. If you take 0 coins, you get sums 0, 6. Those variants do not satisfy you as your sum should be strictly more that your twins' sum. In the second sample one coin isn't enough for us, too. You can pick coins with values 1, 2 or 2, 2. In any case, the minimum number of coins equals 2.

500

[ { "input": "2\n3 3", "output": "2" }, { "input": "3\n2 1 2", "output": "2" }, { "input": "1\n5", "output": "1" }, { "input": "5\n4 2 2 2 2", "output": "3" }, { "input": "7\n1 10 1 2 1 1 1", "output": "1" }, { "input": "5\n3 2 3 3 1", "output": "3" }, { "input": "2\n2 1", "output": "1" }, { "input": "3\n2 1 3", "output": "2" }, { "input": "6\n1 1 1 1 1 1", "output": "4" }, { "input": "7\n10 10 5 5 5 5 1", "output": "3" }, { "input": "20\n2 1 2 2 2 1 1 2 1 2 2 1 1 1 1 2 1 1 1 1", "output": "8" }, { "input": "20\n4 2 4 4 3 4 2 2 4 2 3 1 1 2 2 3 3 3 1 4", "output": "8" }, { "input": "20\n35 26 41 40 45 46 22 26 39 23 11 15 47 42 18 15 27 10 45 40", "output": "8" }, { "input": "20\n7 84 100 10 31 35 41 2 63 44 57 4 63 11 23 49 98 71 16 90", "output": "6" }, { "input": "50\n19 2 12 26 17 27 10 26 17 17 5 24 11 15 3 9 16 18 19 1 25 23 18 6 2 7 25 7 21 25 13 29 16 9 25 3 14 30 18 4 10 28 6 10 8 2 2 4 8 28", "output": "14" }, { "input": "70\n2 18 18 47 25 5 14 9 19 46 36 49 33 32 38 23 32 39 8 29 31 17 24 21 10 15 33 37 46 21 22 11 20 35 39 13 11 30 28 40 39 47 1 17 24 24 21 46 12 2 20 43 8 16 44 11 45 10 13 44 31 45 45 46 11 10 33 35 23 42", "output": "22" }, { "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": "51" }, { "input": "100\n1 2 2 1 2 1 1 2 1 1 1 2 2 1 1 1 2 2 2 1 2 1 1 1 1 1 2 1 2 1 2 1 2 1 2 1 1 1 2 1 1 1 1 1 2 2 1 2 1 2 1 2 2 2 1 2 1 2 2 1 1 2 2 1 1 2 2 2 1 1 2 1 1 2 2 1 2 1 1 2 2 1 2 1 1 2 2 1 1 1 1 2 1 1 1 1 2 2 2 2", "output": "37" }, { "input": "100\n1 2 3 2 1 2 2 3 1 3 3 2 2 1 1 2 2 1 1 1 1 2 3 3 2 1 1 2 2 2 3 3 3 2 1 3 1 3 3 2 3 1 2 2 2 3 2 1 1 3 3 3 3 2 1 1 2 3 2 2 3 2 3 2 2 3 2 2 2 2 3 3 3 1 3 3 1 1 2 3 2 2 2 2 3 3 3 2 1 2 3 1 1 2 3 3 1 3 3 2", "output": "36" }, { "input": "100\n5 5 4 3 5 1 2 5 1 1 3 5 4 4 1 1 1 1 5 4 4 5 1 5 5 1 2 1 3 1 5 1 3 3 3 2 2 2 1 1 5 1 3 4 1 1 3 2 5 2 2 5 5 4 4 1 3 4 3 3 4 5 3 3 3 1 2 1 4 2 4 4 1 5 1 3 5 5 5 5 3 4 4 3 1 2 5 2 3 5 4 2 4 5 3 2 4 2 4 3", "output": "33" }, { "input": "100\n3 4 8 10 8 6 4 3 7 7 6 2 3 1 3 10 1 7 9 3 5 5 2 6 2 9 1 7 4 2 4 1 6 1 7 10 2 5 3 7 6 4 6 2 8 8 8 6 6 10 3 7 4 3 4 1 7 9 3 6 3 6 1 4 9 3 8 1 10 1 4 10 7 7 9 5 3 8 10 2 1 10 8 7 10 8 5 3 1 2 1 10 6 1 5 3 3 5 7 2", "output": "30" }, { "input": "100\n16 9 11 8 11 4 9 17 4 8 4 10 9 10 6 3 3 15 1 6 1 15 12 18 6 14 13 18 1 7 18 4 10 7 10 12 3 16 14 4 10 8 10 7 19 13 15 1 4 8 16 10 6 4 3 16 11 10 7 3 4 16 1 20 1 11 4 16 10 7 7 12 18 19 3 17 19 3 4 19 2 12 11 3 18 20 2 2 14 4 20 13 13 11 16 20 19 14 7 2", "output": "29" }, { "input": "100\n2 46 4 6 38 19 15 34 10 35 37 30 3 25 5 45 40 45 33 31 6 20 10 44 11 9 2 14 35 5 9 23 20 2 48 22 25 35 38 31 24 33 35 16 4 30 27 10 12 22 6 24 12 30 23 21 14 12 32 21 7 12 25 43 18 34 34 28 47 13 28 43 18 39 44 42 35 26 35 14 8 29 32 20 29 3 20 6 20 9 9 27 8 42 10 37 42 27 8 1", "output": "30" }, { "input": "100\n85 50 17 89 65 89 5 20 86 26 16 21 85 14 44 31 87 31 6 2 48 67 8 80 79 1 48 36 97 1 5 30 79 50 78 12 2 55 76 100 54 40 26 81 97 96 68 56 87 14 51 17 54 37 52 33 69 62 38 63 74 15 62 78 9 19 67 2 60 58 93 60 18 96 55 48 34 7 79 82 32 58 90 67 20 50 27 15 7 89 98 10 11 15 99 49 4 51 77 52", "output": "29" }, { "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": "30" }, { "input": "1\n1", "output": "1" }, { "input": "4\n4 1 2 3", "output": "2" }, { "input": "5\n2 2 2 4 4", "output": "2" }, { "input": "4\n100 99 99 100", "output": "2" } ]

1,697,366,964

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

62

0

num = int(input()) coins = [int(x) for x in input().split()] coin_to_take = list() count = 0 coins.sort() coins.reverse() for coin in coins: coin_to_take.append(coin) count += 1 if sum(coin_to_take) > sum(coins[coins.index(coin)+1:]): break print(count)

Title: Twins Time Limit: None seconds Memory Limit: None megabytes Problem Description: Imagine that you have a twin brother or sister. Having another person that looks exactly like you seems very unusual. It's hard to say if having something of an alter ego is good or bad. And if you do have a twin, then you very well know what it's like. Now let's imagine a typical morning in your family. You haven't woken up yet, and Mom is already going to work. She has been so hasty that she has nearly forgotten to leave the two of her darling children some money to buy lunches in the school cafeteria. She fished in the purse and found some number of coins, or to be exact, *n* coins of arbitrary values *a*1,<=*a*2,<=...,<=*a**n*. But as Mom was running out of time, she didn't split the coins for you two. So she scribbled a note asking you to split the money equally. As you woke up, you found Mom's coins and read her note. "But why split the money equally?" — you thought. After all, your twin is sleeping and he won't know anything. So you decided to act like that: pick for yourself some subset of coins so that the sum of values of your coins is strictly larger than the sum of values of the remaining coins that your twin will have. However, you correctly thought that if you take too many coins, the twin will suspect the deception. So, you've decided to stick to the following strategy to avoid suspicions: you take the minimum number of coins, whose sum of values is strictly more than the sum of values of the remaining coins. On this basis, determine what minimum number of coins you need to take to divide them in the described manner. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of coins. The second line contains a sequence of *n* integers *a*1, *a*2, ..., *a**n* (1<=≤<=*a**i*<=≤<=100) — the coins' values. All numbers are separated with spaces. Output Specification: In the single line print the single number — the minimum needed number of coins. Demo Input: ['2\n3 3\n', '3\n2 1 2\n'] Demo Output: ['2\n', '2\n'] Note: In the first sample you will have to take 2 coins (you and your twin have sums equal to 6, 0 correspondingly). If you take 1 coin, you get sums 3, 3. If you take 0 coins, you get sums 0, 6. Those variants do not satisfy you as your sum should be strictly more that your twins' sum. In the second sample one coin isn't enough for us, too. You can pick coins with values 1, 2 or 2, 2. In any case, the minimum number of coins equals 2.

```python num = int(input()) coins = [int(x) for x in input().split()] coin_to_take = list() count = 0 coins.sort() coins.reverse() for coin in coins: coin_to_take.append(coin) count += 1 if sum(coin_to_take) > sum(coins[coins.index(coin)+1:]): break print(count) ```

0

127

A

Wasted Time

PROGRAMMING

900

[ "geometry" ]

null

Mr. Scrooge, a very busy man, decided to count the time he wastes on all sorts of useless stuff to evaluate the lost profit. He has already counted the time he wastes sleeping and eating. And now Mr. Scrooge wants to count the time he has wasted signing papers. Mr. Scrooge's signature can be represented as a polyline *A*1*A*2... *A**n*. Scrooge signs like that: first it places a pen at the point *A*1, then draws a segment from point *A*1 to point *A*2, then he draws a segment from point *A*2 to point *A*3 and so on to point *A**n*, where he stops signing and takes the pen off the paper. At that the resulting line can intersect with itself and partially repeat itself but Scrooge pays no attention to it and never changes his signing style. As Scrooge makes the signature, he never takes the pen off the paper and his writing speed is constant — 50 millimeters per second. Scrooge signed exactly *k* papers throughout his life and all those signatures look the same. Find the total time Scrooge wasted signing the papers.

The first line contains two integers *n* and *k* (2<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=1000). Each of the following *n* lines contains the coordinates of the polyline's endpoints. The *i*-th one contains coordinates of the point *A**i* — integers *x**i* and *y**i*, separated by a space. All points *A**i* are different. The absolute value of all coordinates does not exceed 20. The coordinates are measured in millimeters.

Print one real number — the total time Scrooges wastes on signing the papers in seconds. The absolute or relative error should not exceed 10<=-<=6.

[ "2 1\n0 0\n10 0\n", "5 10\n3 1\n-5 6\n-2 -1\n3 2\n10 0\n", "6 10\n5 0\n4 0\n6 0\n3 0\n7 0\n2 0\n" ]

[ "0.200000000", "6.032163204", "3.000000000" ]

none

500

[ { "input": "2 1\n0 0\n10 0", "output": "0.200000000" }, { "input": "5 10\n3 1\n-5 6\n-2 -1\n3 2\n10 0", "output": "6.032163204" }, { "input": "6 10\n5 0\n4 0\n6 0\n3 0\n7 0\n2 0", "output": "3.000000000" }, { "input": "10 95\n-20 -5\n2 -8\n14 13\n10 3\n17 11\n13 -12\n-6 11\n14 -15\n-13 14\n19 8", "output": "429.309294877" }, { "input": "30 1000\n4 -13\n14 13\n-14 -16\n-9 18\n17 11\n2 -8\n2 15\n8 -1\n-9 13\n8 -12\n-2 20\n11 -12\n19 8\n9 -15\n-20 -5\n-18 20\n-13 14\n-12 -17\n-4 3\n13 -12\n11 -10\n18 7\n-6 11\n10 13\n10 3\n6 -14\n-1 10\n14 -15\n2 11\n-8 10", "output": "13629.282573522" }, { "input": "2 1\n-20 -10\n-10 -6", "output": "0.215406592" }, { "input": "2 13\n13 -10\n-3 -2", "output": "4.651021393" }, { "input": "2 21\n13 8\n14 10", "output": "0.939148551" }, { "input": "2 75\n-3 12\n1 12", "output": "6.000000000" }, { "input": "2 466\n10 16\n-6 -3", "output": "231.503997374" }, { "input": "2 999\n6 16\n-17 -14", "output": "755.286284531" }, { "input": "2 1000\n-17 -14\n-14 -8", "output": "134.164078650" }, { "input": "3 384\n-4 -19\n-17 -2\n3 4", "output": "324.722285390" }, { "input": "5 566\n-11 8\n2 -7\n7 0\n-7 -9\n-7 5", "output": "668.956254495" }, { "input": "7 495\n-10 -13\n-9 -5\n4 9\n8 13\n-4 2\n2 10\n-18 15", "output": "789.212495576" }, { "input": "10 958\n7 13\n20 19\n12 -7\n10 -10\n-13 -15\n-10 -7\n20 -5\n-11 19\n-7 3\n-4 18", "output": "3415.618464093" }, { "input": "13 445\n-15 16\n-8 -14\n8 7\n4 15\n8 -13\n15 -11\n-12 -4\n2 -13\n-5 0\n-20 -14\n-8 -7\n-10 -18\n18 -5", "output": "2113.552527680" }, { "input": "18 388\n11 -8\n13 10\n18 -17\n-15 3\n-13 -15\n20 -7\n1 -10\n-13 -12\n-12 -15\n-17 -8\n1 -2\n3 -20\n-8 -9\n15 -13\n-19 -6\n17 3\n-17 2\n6 6", "output": "2999.497312668" }, { "input": "25 258\n-5 -3\n-18 -14\n12 3\n6 11\n4 2\n-19 -3\n19 -7\n-15 19\n-19 -12\n-11 -10\n-5 17\n10 15\n-4 1\n-3 -20\n6 16\n18 -19\n11 -19\n-17 10\n-17 17\n-2 -17\n-3 -9\n18 13\n14 8\n-2 -5\n-11 4", "output": "2797.756635934" }, { "input": "29 848\n11 -10\n-19 1\n18 18\n19 -19\n0 -5\n16 10\n-20 -14\n7 15\n6 8\n-15 -16\n9 3\n16 -20\n-12 12\n18 -1\n-11 14\n18 10\n11 -20\n-20 -16\n-1 11\n13 10\n-6 13\n-7 -10\n-11 -10\n-10 3\n15 -13\n-4 11\n-13 -11\n-11 -17\n11 -5", "output": "12766.080247922" }, { "input": "36 3\n-11 20\n-11 13\n-17 9\n15 9\n-6 9\n-1 11\n12 -11\n16 -10\n-20 7\n-18 6\n-15 -2\n20 -20\n16 4\n-20 -8\n-12 -15\n-13 -6\n-9 -4\n0 -10\n8 -1\n1 4\n5 8\n8 -15\n16 -12\n19 1\n0 -4\n13 -4\n17 -13\n-7 11\n14 9\n-14 -9\n5 -8\n11 -8\n-17 -5\n1 -3\n-16 -17\n2 -3", "output": "36.467924851" }, { "input": "48 447\n14 9\n9 -17\n-17 11\n-14 14\n19 -8\n-14 -17\n-7 10\n-6 -11\n-9 -19\n19 10\n-4 2\n-5 16\n20 9\n-10 20\n-7 -17\n14 -16\n-2 -10\n-18 -17\n14 12\n-6 -19\n5 -18\n-3 2\n-3 10\n-5 5\n13 -12\n10 -18\n10 -12\n-2 4\n7 -15\n-5 -5\n11 14\n11 10\n-6 -9\n13 -4\n13 9\n6 12\n-13 17\n-9 -12\n14 -19\n10 12\n-15 8\n-1 -11\n19 8\n11 20\n-9 -3\n16 1\n-14 19\n8 -4", "output": "9495.010556306" }, { "input": "50 284\n-17 -13\n7 12\n-13 0\n13 1\n14 6\n14 -9\n-5 -1\n0 -10\n12 -3\n-14 6\n-8 10\n-16 17\n0 -1\n4 -9\n2 6\n1 8\n-8 -14\n3 9\n1 -15\n-4 -19\n-7 -20\n18 10\n3 -11\n10 16\n2 -6\n-9 19\n-3 -1\n20 9\n-12 -5\n-10 -2\n16 -7\n-16 -18\n-2 17\n2 8\n7 -15\n4 1\n6 -17\n19 9\n-10 -20\n5 2\n10 -2\n3 7\n20 0\n8 -14\n-16 -1\n-20 7\n20 -19\n17 18\n-11 -18\n-16 14", "output": "6087.366930474" }, { "input": "57 373\n18 3\n-4 -1\n18 5\n-7 -15\n-6 -10\n-19 1\n20 15\n15 4\n-1 -2\n13 -14\n0 12\n10 3\n-16 -17\n-14 -9\n-11 -10\n17 19\n-2 6\n-12 -15\n10 20\n16 7\n9 -1\n4 13\n8 -2\n-1 -16\n-3 8\n14 11\n-12 3\n-5 -6\n3 4\n5 7\n-9 9\n11 4\n-19 10\n-7 4\n-20 -12\n10 16\n13 11\n13 -11\n7 -1\n17 18\n-19 7\n14 13\n5 -1\n-7 6\n-1 -6\n6 20\n-16 2\n4 17\n16 -11\n-4 -20\n19 -18\n17 16\n-14 -8\n3 2\n-6 -16\n10 -10\n-13 -11", "output": "8929.162822862" }, { "input": "60 662\n15 17\n-2 -19\n-4 -17\n10 0\n15 10\n-8 -14\n14 9\n-15 20\n6 5\n-9 0\n-13 20\n13 -2\n10 9\n7 5\n4 18\n-10 1\n6 -15\n15 -16\n6 13\n4 -6\n2 5\n18 19\n8 3\n-7 14\n-12 -20\n14 19\n-15 0\n-2 -12\n9 18\n14 4\n2 -20\n3 0\n20 9\n-5 11\n-11 1\n2 -19\n-14 -4\n18 6\n16 16\n15 3\n-1 -5\n9 20\n12 -8\n-1 10\n-4 -9\n3 6\n3 -12\n14 -10\n-8 10\n-18 6\n14 -2\n-14 -12\n-10 -7\n10 -6\n14 1\n6 14\n15 19\n4 14\n3 -14\n-9 -13", "output": "16314.207721932" }, { "input": "61 764\n-9 15\n11 -8\n-6 -7\n-13 -19\n16 -16\n-5 -1\n20 -19\n-14 -1\n-11 4\n7 -2\n-3 2\n-14 -17\n15 18\n20 15\n-13 -2\n15 8\n3 13\n19 -10\n2 -6\n15 -3\n-12 11\n4 -16\n-14 20\n0 2\n11 -7\n-6 -11\n16 7\n8 -3\n16 -10\n-3 9\n9 5\n4 -1\n-17 9\n14 -4\n8 6\n-19 12\n10 -17\n-5 7\n7 -3\n5 3\n6 -14\n9 9\n-16 -19\n11 -16\n-17 15\n8 5\n16 -19\n-7 10\n14 -15\n15 19\n-20 -16\n6 -2\n-4 6\n7 -15\n1 -8\n20 -17\n3 7\n10 12\n10 -11\n-19 10\n0 -11", "output": "22153.369189802" } ]

1,595,259,272

2,147,483,647

PyPy 3

OK

TESTS

42

310

20,172,800

n,k=map(int,input().split()) ans=0 fx,fy=map(int,input().split()) for i in range(n-1): x,y=map(int,input().split()) ans+=(((fx-x)**2+(fy-y)**2)**.5)/50 fx,fy=x,y print(ans*k)

Title: Wasted Time Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mr. Scrooge, a very busy man, decided to count the time he wastes on all sorts of useless stuff to evaluate the lost profit. He has already counted the time he wastes sleeping and eating. And now Mr. Scrooge wants to count the time he has wasted signing papers. Mr. Scrooge's signature can be represented as a polyline *A*1*A*2... *A**n*. Scrooge signs like that: first it places a pen at the point *A*1, then draws a segment from point *A*1 to point *A*2, then he draws a segment from point *A*2 to point *A*3 and so on to point *A**n*, where he stops signing and takes the pen off the paper. At that the resulting line can intersect with itself and partially repeat itself but Scrooge pays no attention to it and never changes his signing style. As Scrooge makes the signature, he never takes the pen off the paper and his writing speed is constant — 50 millimeters per second. Scrooge signed exactly *k* papers throughout his life and all those signatures look the same. Find the total time Scrooge wasted signing the papers. Input Specification: The first line contains two integers *n* and *k* (2<=≤<=*n*<=≤<=100, 1<=≤<=*k*<=≤<=1000). Each of the following *n* lines contains the coordinates of the polyline's endpoints. The *i*-th one contains coordinates of the point *A**i* — integers *x**i* and *y**i*, separated by a space. All points *A**i* are different. The absolute value of all coordinates does not exceed 20. The coordinates are measured in millimeters. Output Specification: Print one real number — the total time Scrooges wastes on signing the papers in seconds. The absolute or relative error should not exceed 10<=-<=6. Demo Input: ['2 1\n0 0\n10 0\n', '5 10\n3 1\n-5 6\n-2 -1\n3 2\n10 0\n', '6 10\n5 0\n4 0\n6 0\n3 0\n7 0\n2 0\n'] Demo Output: ['0.200000000', '6.032163204', '3.000000000'] Note: none

```python n,k=map(int,input().split()) ans=0 fx,fy=map(int,input().split()) for i in range(n-1): x,y=map(int,input().split()) ans+=(((fx-x)**2+(fy-y)**2)**.5)/50 fx,fy=x,y print(ans*k) ```

3

66

B

Petya and Countryside

PROGRAMMING

1,100

[ "brute force", "implementation" ]

B. Petya and Countryside

2

256

Little Petya often travels to his grandmother in the countryside. The grandmother has a large garden, which can be represented as a rectangle 1<=×<=*n* in size, when viewed from above. This rectangle is divided into *n* equal square sections. The garden is very unusual as each of the square sections possesses its own fixed height and due to the newest irrigation system we can create artificial rain above each section. Creating artificial rain is an expensive operation. That's why we limit ourselves to creating the artificial rain only above one section. At that, the water from each watered section will flow into its neighbouring sections if their height does not exceed the height of the section. That is, for example, the garden can be represented by a 1<=×<=5 rectangle, where the section heights are equal to 4, 2, 3, 3, 2. Then if we create an artificial rain over any of the sections with the height of 3, the water will flow over all the sections, except the ones with the height of 4. See the illustration of this example at the picture: As Petya is keen on programming, he decided to find such a section that if we create artificial rain above it, the number of watered sections will be maximal. Help him.

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=1000). The second line contains *n* positive integers which are the height of the sections. All the numbers are no less than 1 and not more than 1000.

Print a single number, the maximal number of watered sections if we create artificial rain above exactly one section.

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

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

none

1,000

[ { "input": "1\n2", "output": "1" }, { "input": "5\n1 2 1 2 1", "output": "3" }, { "input": "8\n1 2 1 1 1 3 3 4", "output": "6" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "10" }, { "input": "10\n10 9 8 7 6 5 4 3 2 1", "output": "10" }, { "input": "2\n100 100", "output": "2" }, { "input": "3\n100 100 100", "output": "3" }, { "input": "11\n1 2 3 4 5 6 5 4 3 2 1", "output": "11" }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 100 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 1 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": "61" }, { "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 1 82 83 84 85 86 87 88 89 90 91 92 93 94 100 5 4 3 2 1", "output": "81" }, { "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 1 86 87 88 89 90 91 92 93 100 6 5 4 3 2 1", "output": "85" }, { "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 1 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 100 7 6 5 4 3 2 1", "output": "61" }, { "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 100 8 7 6 1 4 3 2 1", "output": "96" }, { "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 100 10 9 8 7 6 5 4 3 2 1", "output": "100" }, { "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 1 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 100 11 10 9 8 7 6 5 4 3 2 1", "output": "55" }, { "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 1 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 100 12 11 10 9 8 7 6 5 4 3 2 1", "output": "59" }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 1 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 100 13 12 11 10 9 8 7 6 5 4 3 2 1", "output": "86" }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 1 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 100 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": "83" }, { "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 100 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 1 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": "74" }, { "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 100 9 8 7 6 5 4 3 2 1", "output": "100" }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 100 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 1 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": "52" }, { "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 100 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 1 2 1", "output": "98" }, { "input": "10\n1 4 4 4 4 4 1 2 4 3", "output": "7" } ]

1,587,576,391

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

7

280

0

n=int(input()) b=[] l=list(map(int,input().split())) if n>2: for i in range(n): j=i-1 count=0 ref=l[i] while(j>=0): if ref>=l[j]: count+=1 ref=l[j] j-=1 else: break j=i+1 while(j<n): if ref>=l[j]: count+=1 ref=l[j] j+=1 else: break b.append(count) print(max(b)+1) else: print(n)

Title: Petya and Countryside Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Little Petya often travels to his grandmother in the countryside. The grandmother has a large garden, which can be represented as a rectangle 1<=×<=*n* in size, when viewed from above. This rectangle is divided into *n* equal square sections. The garden is very unusual as each of the square sections possesses its own fixed height and due to the newest irrigation system we can create artificial rain above each section. Creating artificial rain is an expensive operation. That's why we limit ourselves to creating the artificial rain only above one section. At that, the water from each watered section will flow into its neighbouring sections if their height does not exceed the height of the section. That is, for example, the garden can be represented by a 1<=×<=5 rectangle, where the section heights are equal to 4, 2, 3, 3, 2. Then if we create an artificial rain over any of the sections with the height of 3, the water will flow over all the sections, except the ones with the height of 4. See the illustration of this example at the picture: As Petya is keen on programming, he decided to find such a section that if we create artificial rain above it, the number of watered sections will be maximal. Help him. Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=1000). The second line contains *n* positive integers which are the height of the sections. All the numbers are no less than 1 and not more than 1000. Output Specification: Print a single number, the maximal number of watered sections if we create artificial rain above exactly one section. Demo Input: ['1\n2\n', '5\n1 2 1 2 1\n', '8\n1 2 1 1 1 3 3 4\n'] Demo Output: ['1\n', '3\n', '6\n'] Note: none

```python n=int(input()) b=[] l=list(map(int,input().split())) if n>2: for i in range(n): j=i-1 count=0 ref=l[i] while(j>=0): if ref>=l[j]: count+=1 ref=l[j] j-=1 else: break j=i+1 while(j<n): if ref>=l[j]: count+=1 ref=l[j] j+=1 else: break b.append(count) print(max(b)+1) else: print(n) ```

0

356

A

Knight Tournament

PROGRAMMING

1,500

[ "data structures", "dsu" ]

null

Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event. As for you, you're just a simple peasant. There's no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows: - There are *n* knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to *n*. - The tournament consisted of *m* fights, in the *i*-th fight the knights that were still in the game with numbers at least *l**i* and at most *r**i* have fought for the right to continue taking part in the tournament. - After the *i*-th fight among all participants of the fight only one knight won — the knight number *x**i*, he continued participating in the tournament. Other knights left the tournament. - The winner of the last (the *m*-th) fight (the knight number *x**m*) became the winner of the tournament. You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number *b* was conquered by the knight number *a*, if there was a fight with both of these knights present and the winner was the knight number *a*. Write the code that calculates for each knight, the name of the knight that beat him.

The first line contains two integers *n*, *m* (2<=≤<=*n*<=≤<=3·105; 1<=≤<=*m*<=≤<=3·105) — the number of knights and the number of fights. Each of the following *m* lines contains three integers *l**i*,<=*r**i*,<=*x**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*; *l**i*<=≤<=*x**i*<=≤<=*r**i*) — the description of the *i*-th fight. It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle.

Print *n* integers. If the *i*-th knight lost, then the *i*-th number should equal the number of the knight that beat the knight number *i*. If the *i*-th knight is the winner, then the *i*-th number must equal 0.

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

[ "3 1 4 0 ", "0 8 4 6 4 8 6 1 " ]

Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won.

500

[ { "input": "4 3\n1 2 1\n1 3 3\n1 4 4", "output": "3 1 4 0 " }, { "input": "8 4\n3 5 4\n3 7 6\n2 8 8\n1 8 1", "output": "0 8 4 6 4 8 6 1 " }, { "input": "2 1\n1 2 1", "output": "0 1 " }, { "input": "2 1\n1 2 2", "output": "2 0 " }, { "input": "3 1\n1 3 1", "output": "0 1 1 " }, { "input": "3 1\n1 3 2", "output": "2 0 2 " }, { "input": "3 1\n1 3 3", "output": "3 3 0 " }, { "input": "3 2\n1 2 1\n1 3 3", "output": "3 1 0 " }, { "input": "3 2\n1 2 2\n1 3 2", "output": "2 0 2 " }, { "input": "3 2\n2 3 3\n1 3 3", "output": "3 3 0 " }, { "input": "11 6\n1 2 2\n7 8 7\n3 4 4\n6 9 6\n5 10 10\n2 11 11", "output": "2 11 4 11 10 10 6 7 6 11 0 " }, { "input": "10 6\n9 10 10\n6 7 7\n2 4 2\n2 5 5\n1 7 5\n4 10 8", "output": "5 5 2 2 8 7 5 0 10 8 " }, { "input": "11 8\n3 5 5\n8 9 9\n4 6 6\n8 10 10\n5 7 7\n2 7 2\n10 11 11\n1 11 1", "output": "0 1 5 5 6 7 2 9 10 11 1 " }, { "input": "10 7\n7 8 7\n7 9 9\n5 9 5\n5 10 10\n1 2 2\n3 4 4\n2 10 4", "output": "2 4 4 0 10 5 9 7 5 4 " }, { "input": "11 5\n8 10 9\n6 10 7\n6 11 11\n3 5 5\n1 11 1", "output": "0 1 5 5 1 7 11 9 7 9 1 " }, { "input": "10 6\n6 7 6\n5 7 5\n3 7 4\n2 8 2\n2 10 10\n1 10 10", "output": "10 10 4 2 4 5 6 2 10 0 " }, { "input": "11 7\n7 8 8\n5 6 5\n1 3 3\n7 9 9\n5 10 10\n10 11 11\n1 11 4", "output": "3 3 4 0 10 5 8 9 10 11 4 " }, { "input": "10 7\n8 9 9\n3 4 3\n2 3 2\n1 5 2\n6 7 6\n6 10 10\n1 10 10", "output": "2 10 2 3 2 10 6 9 10 0 " }, { "input": "11 6\n1 2 1\n8 9 9\n3 5 5\n3 6 6\n9 10 10\n1 11 10", "output": "10 1 5 5 6 10 10 9 10 0 10 " }, { "input": "10 5\n1 2 1\n8 10 8\n3 6 4\n4 7 7\n1 8 7", "output": "7 1 4 7 4 4 0 7 8 8 " }, { "input": "4 3\n1 2 2\n1 3 3\n1 4 4", "output": "2 3 4 0 " } ]

1,639,137,330

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

10

3,000

1,126,400

n, m = map(int, input().split()) knights = [0] * (n + 1) for _ in range(m): l, r, x = map(int, input().split()) for i in range(l, r + 1): if knights[i] == 0 and i != x: knights[i] = x for i in range(1, len(knights)): print(knights[i], end=" ")

Title: Knight Tournament Time Limit: None seconds Memory Limit: None megabytes Problem Description: Hooray! Berl II, the king of Berland is making a knight tournament. The king has already sent the message to all knights in the kingdom and they in turn agreed to participate in this grand event. As for you, you're just a simple peasant. There's no surprise that you slept in this morning and were late for the tournament (it was a weekend, after all). Now you are really curious about the results of the tournament. This time the tournament in Berland went as follows: - There are *n* knights participating in the tournament. Each knight was assigned his unique number — an integer from 1 to *n*. - The tournament consisted of *m* fights, in the *i*-th fight the knights that were still in the game with numbers at least *l**i* and at most *r**i* have fought for the right to continue taking part in the tournament. - After the *i*-th fight among all participants of the fight only one knight won — the knight number *x**i*, he continued participating in the tournament. Other knights left the tournament. - The winner of the last (the *m*-th) fight (the knight number *x**m*) became the winner of the tournament. You fished out all the information about the fights from your friends. Now for each knight you want to know the name of the knight he was conquered by. We think that the knight number *b* was conquered by the knight number *a*, if there was a fight with both of these knights present and the winner was the knight number *a*. Write the code that calculates for each knight, the name of the knight that beat him. Input Specification: The first line contains two integers *n*, *m* (2<=≤<=*n*<=≤<=3·105; 1<=≤<=*m*<=≤<=3·105) — the number of knights and the number of fights. Each of the following *m* lines contains three integers *l**i*,<=*r**i*,<=*x**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*; *l**i*<=≤<=*x**i*<=≤<=*r**i*) — the description of the *i*-th fight. It is guaranteed that the input is correct and matches the problem statement. It is guaranteed that at least two knights took part in each battle. Output Specification: Print *n* integers. If the *i*-th knight lost, then the *i*-th number should equal the number of the knight that beat the knight number *i*. If the *i*-th knight is the winner, then the *i*-th number must equal 0. Demo Input: ['4 3\n1 2 1\n1 3 3\n1 4 4\n', '8 4\n3 5 4\n3 7 6\n2 8 8\n1 8 1\n'] Demo Output: ['3 1 4 0 ', '0 8 4 6 4 8 6 1 '] Note: Consider the first test case. Knights 1 and 2 fought the first fight and knight 1 won. Knights 1 and 3 fought the second fight and knight 3 won. The last fight was between knights 3 and 4, knight 4 won.

```python n, m = map(int, input().split()) knights = [0] * (n + 1) for _ in range(m): l, r, x = map(int, input().split()) for i in range(l, r + 1): if knights[i] == 0 and i != x: knights[i] = x for i in range(1, len(knights)): print(knights[i], end=" ") ```

0

507

B

Amr and Pins

PROGRAMMING

1,400

[ "geometry", "math" ]

null

Amr loves Geometry. One day he came up with a very interesting problem. Amr has a circle of radius *r* and center in point (*x*,<=*y*). He wants the circle center to be in new position (*x*',<=*y*'). In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin by any angle and finally remove the pin. Help Amr to achieve his goal in minimum number of steps.

Input consists of 5 space-separated integers *r*, *x*, *y*, *x*' *y*' (1<=≤<=*r*<=≤<=105, <=-<=105<=≤<=*x*,<=*y*,<=*x*',<=*y*'<=≤<=105), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively.

Output a single integer — minimum number of steps required to move the center of the circle to the destination point.

[ "2 0 0 0 4\n", "1 1 1 4 4\n", "4 5 6 5 6\n" ]

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

In the first sample test the optimal way is to put a pin at point (0, 2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter). <img class="tex-graphics" src="https://espresso.codeforces.com/4e40fd4cc24a2050a0488aa131e6244369328039.png" style="max-width: 100.0%;max-height: 100.0%;"/>

1,000

[ { "input": "2 0 0 0 4", "output": "1" }, { "input": "1 1 1 4 4", "output": "3" }, { "input": "4 5 6 5 6", "output": "0" }, { "input": "10 20 0 40 0", "output": "1" }, { "input": "9 20 0 40 0", "output": "2" }, { "input": "5 -1 -6 -5 1", "output": "1" }, { "input": "99125 26876 -21414 14176 17443", "output": "1" }, { "input": "8066 7339 19155 -90534 -60666", "output": "8" }, { "input": "100000 -100000 -100000 100000 100000", "output": "2" }, { "input": "10 20 0 41 0", "output": "2" }, { "input": "25 -64 -6 -56 64", "output": "2" }, { "input": "125 455 450 439 721", "output": "2" }, { "input": "5 6 3 7 2", "output": "1" }, { "input": "24 130 14786 3147 2140", "output": "271" }, { "input": "125 -363 176 93 330", "output": "2" }, { "input": "1 14 30 30 14", "output": "12" }, { "input": "25 96 13 7 2", "output": "2" }, { "input": "4 100000 -100000 100000 -100000", "output": "0" }, { "input": "1 3 4 2 5", "output": "1" }, { "input": "1 -3 3 2 6", "output": "3" }, { "input": "2 7 20 13 -5", "output": "7" }, { "input": "1 1 1 1 4", "output": "2" }, { "input": "249 -54242 -30537 -45023 -89682", "output": "121" }, { "input": "4 100000 -100000 100000 -99999", "output": "1" }, { "input": "97741 23818 78751 97583 26933", "output": "1" }, { "input": "56767 -29030 51625 79823 -56297", "output": "2" }, { "input": "98260 13729 74998 23701 9253", "output": "1" }, { "input": "67377 -80131 -90254 -57320 14102", "output": "1" }, { "input": "1 100000 100000 100000 -100000", "output": "100000" }, { "input": "19312 19470 82059 58064 62231", "output": "2" }, { "input": "67398 -68747 -79056 -34193 29400", "output": "1" }, { "input": "91099 37184 -71137 75650 -3655", "output": "1" }, { "input": "46456 -2621 -23623 -98302 -99305", "output": "2" }, { "input": "100 100000 -100000 100000 -99999", "output": "1" }, { "input": "1 100000 -100000 100000 -100000", "output": "0" }, { "input": "8 0 0 0 32", "output": "2" }, { "input": "100000 100000 1 -100000 0", "output": "2" } ]

1,646,848,155

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

30

0

from math import sqrt r, x1, y1, x, y = map(int,input().split()) distance = sqrt( (x-x1)**2 + (y-y1)**2 ) distance -= r #print(distance) if distance % (2*r) == 0: print(int(distance // (2*r) ) ) else: print(int(distance // (2*r) ) + 2 )

Title: Amr and Pins Time Limit: None seconds Memory Limit: None megabytes Problem Description: Amr loves Geometry. One day he came up with a very interesting problem. Amr has a circle of radius *r* and center in point (*x*,<=*y*). He wants the circle center to be in new position (*x*',<=*y*'). In one step Amr can put a pin to the border of the circle in a certain point, then rotate the circle around that pin by any angle and finally remove the pin. Help Amr to achieve his goal in minimum number of steps. Input Specification: Input consists of 5 space-separated integers *r*, *x*, *y*, *x*' *y*' (1<=≤<=*r*<=≤<=105, <=-<=105<=≤<=*x*,<=*y*,<=*x*',<=*y*'<=≤<=105), circle radius, coordinates of original center of the circle and coordinates of destination center of the circle respectively. Output Specification: Output a single integer — minimum number of steps required to move the center of the circle to the destination point. Demo Input: ['2 0 0 0 4\n', '1 1 1 4 4\n', '4 5 6 5 6\n'] Demo Output: ['1\n', '3\n', '0\n'] Note: In the first sample test the optimal way is to put a pin at point (0, 2) and rotate the circle by 180 degrees counter-clockwise (or clockwise, no matter). <img class="tex-graphics" src="https://espresso.codeforces.com/4e40fd4cc24a2050a0488aa131e6244369328039.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python from math import sqrt r, x1, y1, x, y = map(int,input().split()) distance = sqrt( (x-x1)**2 + (y-y1)**2 ) distance -= r #print(distance) if distance % (2*r) == 0: print(int(distance // (2*r) ) ) else: print(int(distance // (2*r) ) + 2 ) ```

0

705

A

Hulk

PROGRAMMING

800

[ "implementation" ]

null

Dr. Bruce Banner hates his enemies (like others don't). As we all know, he can barely talk when he turns into the incredible Hulk. That's why he asked you to help him to express his feelings. Hulk likes the Inception so much, and like that his feelings are complicated. They have *n* layers. The first layer is hate, second one is love, third one is hate and so on... For example if *n*<==<=1, then his feeling is "I hate it" or if *n*<==<=2 it's "I hate that I love it", and if *n*<==<=3 it's "I hate that I love that I hate it" and so on. Please help Dr. Banner.

The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of layers of love and hate.

Print Dr.Banner's feeling in one line.

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

[ "I hate it\n", "I hate that I love it\n", "I hate that I love that I hate it\n" ]

none

500

[ { "input": "1", "output": "I hate it" }, { "input": "2", "output": "I hate that I love it" }, { "input": "3", "output": "I hate that I love that I hate it" }, { "input": "4", "output": "I hate that I love that I hate that I love it" }, { "input": "5", "output": "I hate that I love that I hate that I love that I hate it" }, { "input": "10", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love it" }, { "input": "18", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love it" }, { "input": "19", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate it" }, { "input": "76", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "77", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "81", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "82", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "85", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "86", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "100", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "99", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "98", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "33", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate it" }, { "input": "34", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love it" }, { "input": "57", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." }, { "input": "100", "output": "I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate that I love that I hate ..." } ]

1,685,417,171

2,147,483,647

Python 3

OK

TESTS

21

31

0

n = int(input()) s1 = "I hate" s2 = "I love" final = "" for i in range(n): if i>0: final +=" that " if i%2==0: final +=s1 else: final +=s2 print(final+" it")

Title: Hulk Time Limit: None seconds Memory Limit: None megabytes Problem Description: Dr. Bruce Banner hates his enemies (like others don't). As we all know, he can barely talk when he turns into the incredible Hulk. That's why he asked you to help him to express his feelings. Hulk likes the Inception so much, and like that his feelings are complicated. They have *n* layers. The first layer is hate, second one is love, third one is hate and so on... For example if *n*<==<=1, then his feeling is "I hate it" or if *n*<==<=2 it's "I hate that I love it", and if *n*<==<=3 it's "I hate that I love that I hate it" and so on. Please help Dr. Banner. Input Specification: The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of layers of love and hate. Output Specification: Print Dr.Banner's feeling in one line. Demo Input: ['1\n', '2\n', '3\n'] Demo Output: ['I hate it\n', 'I hate that I love it\n', 'I hate that I love that I hate it\n'] Note: none

```python n = int(input()) s1 = "I hate" s2 = "I love" final = "" for i in range(n): if i>0: final +=" that " if i%2==0: final +=s1 else: final +=s2 print(final+" it") ```

3

965

C

Greedy Arkady

PROGRAMMING

2,000

[ "math" ]

null

$k$ people want to split $n$ candies between them. Each candy should be given to exactly one of them or be thrown away. The people are numbered from $1$ to $k$, and Arkady is the first of them. To split the candies, Arkady will choose an integer $x$ and then give the first $x$ candies to himself, the next $x$ candies to the second person, the next $x$ candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by $x$) will be thrown away. Arkady can't choose $x$ greater than $M$ as it is considered greedy. Also, he can't choose such a small $x$ that some person will receive candies more than $D$ times, as it is considered a slow splitting. Please find what is the maximum number of candies Arkady can receive by choosing some valid $x$.

The only line contains four integers $n$, $k$, $M$ and $D$ ($2 \le n \le 10^{18}$, $2 \le k \le n$, $1 \le M \le n$, $1 \le D \le \min{(n, 1000)}$, $M \cdot D \cdot k \ge n$) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies.

Print a single integer — the maximum possible number of candies Arkady can give to himself. Note that it is always possible to choose some valid $x$.

[ "20 4 5 2\n", "30 9 4 1\n" ]

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

In the first example Arkady should choose $x = 4$. He will give $4$ candies to himself, $4$ candies to the second person, $4$ candies to the third person, then $4$ candies to the fourth person and then again $4$ candies to himself. No person is given candies more than $2$ times, and Arkady receives $8$ candies in total. Note that if Arkady chooses $x = 5$, he will receive only $5$ candies, and if he chooses $x = 3$, he will receive only $3 + 3 = 6$ candies as well as the second person, the third and the fourth persons will receive $3$ candies, and $2$ candies will be thrown away. He can't choose $x = 1$ nor $x = 2$ because in these cases he will receive candies more than $2$ times. In the second example Arkady has to choose $x = 4$, because any smaller value leads to him receiving candies more than $1$ time.

1,500

[ { "input": "20 4 5 2", "output": "8" }, { "input": "30 9 4 1", "output": "4" }, { "input": "2 2 1 1", "output": "1" }, { "input": "42 20 5 29", "output": "5" }, { "input": "1000000000000000000 135 1000000000000000 1000", "output": "8325624421831635" }, { "input": "100 33 100 100", "output": "100" }, { "input": "1000000000 1000000000 1000000000 1000", "output": "1000000000" }, { "input": "1000000000 32428 1000000000 1000", "output": "1000000000" }, { "input": "1000000000 324934 1000 1000", "output": "4000" }, { "input": "1000000000000000000 32400093004 10000000 1000", "output": "40000000" }, { "input": "885 2 160 842", "output": "504" }, { "input": "216 137 202 208", "output": "202" }, { "input": "72 66 28 9", "output": "28" }, { "input": "294 4 13 8", "output": "80" }, { "input": "9 2 2 3", "output": "4" }, { "input": "31 3 2 8", "output": "10" }, { "input": "104 2 5 11", "output": "50" }, { "input": "1000000000000000000 1000000000000000000 1000 1000", "output": "1000" }, { "input": "1000000000000000000 100000000000000000 1 1000", "output": "10" }, { "input": "23925738098196565 23925738098196565 23925738098196565 1000", "output": "23925738098196565" }, { "input": "576460752303423488 576460752303423488 351082447248993993 1000", "output": "351082447248993993" }, { "input": "962768465676381898 72057594037927936 586039918340257175 256", "output": "586039918340257175" }, { "input": "1000000000000000000 1000000000000000000 10 1000", "output": "10" }, { "input": "23925738098196565 23925738098196565 1 1000", "output": "1" }, { "input": "1000000000000000000 1000000000000000000 1 1000", "output": "1" } ]

1,531,117,111

2,147,483,647

Python 3

OK

TESTS

25

109

0

from sys import stdin n, k, M, D = map(int, stdin.readline().strip().split()) print(max(map(lambda d: d * min(M, n // (1 + (d - 1) * k)), range(1, D + 1))))

Title: Greedy Arkady Time Limit: None seconds Memory Limit: None megabytes Problem Description: $k$ people want to split $n$ candies between them. Each candy should be given to exactly one of them or be thrown away. The people are numbered from $1$ to $k$, and Arkady is the first of them. To split the candies, Arkady will choose an integer $x$ and then give the first $x$ candies to himself, the next $x$ candies to the second person, the next $x$ candies to the third person and so on in a cycle. The leftover (the remainder that is not divisible by $x$) will be thrown away. Arkady can't choose $x$ greater than $M$ as it is considered greedy. Also, he can't choose such a small $x$ that some person will receive candies more than $D$ times, as it is considered a slow splitting. Please find what is the maximum number of candies Arkady can receive by choosing some valid $x$. Input Specification: The only line contains four integers $n$, $k$, $M$ and $D$ ($2 \le n \le 10^{18}$, $2 \le k \le n$, $1 \le M \le n$, $1 \le D \le \min{(n, 1000)}$, $M \cdot D \cdot k \ge n$) — the number of candies, the number of people, the maximum number of candies given to a person at once, the maximum number of times a person can receive candies. Output Specification: Print a single integer — the maximum possible number of candies Arkady can give to himself. Note that it is always possible to choose some valid $x$. Demo Input: ['20 4 5 2\n', '30 9 4 1\n'] Demo Output: ['8\n', '4\n'] Note: In the first example Arkady should choose $x = 4$. He will give $4$ candies to himself, $4$ candies to the second person, $4$ candies to the third person, then $4$ candies to the fourth person and then again $4$ candies to himself. No person is given candies more than $2$ times, and Arkady receives $8$ candies in total. Note that if Arkady chooses $x = 5$, he will receive only $5$ candies, and if he chooses $x = 3$, he will receive only $3 + 3 = 6$ candies as well as the second person, the third and the fourth persons will receive $3$ candies, and $2$ candies will be thrown away. He can't choose $x = 1$ nor $x = 2$ because in these cases he will receive candies more than $2$ times. In the second example Arkady has to choose $x = 4$, because any smaller value leads to him receiving candies more than $1$ time.

```python from sys import stdin n, k, M, D = map(int, stdin.readline().strip().split()) print(max(map(lambda d: d * min(M, n // (1 + (d - 1) * k)), range(1, D + 1)))) ```

3

280

B

Maximum Xor Secondary

PROGRAMMING

1,800

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

null

Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers *x*1,<=*x*2,<=...,<=*x**k* (*k*<=><=1) is such maximum element *x**j*, that the following inequality holds: . The lucky number of the sequence of distinct positive integers *x*1,<=*x*2,<=...,<=*x**k* (*k*<=><=1) is the number that is equal to the bitwise excluding OR of the maximum element of the sequence and the second maximum element of the sequence. You've got a sequence of distinct positive integers *s*1,<=*s*2,<=...,<=*s**n* (*n*<=><=1). Let's denote sequence *s**l*,<=*s**l*<=+<=1,<=...,<=*s**r* as *s*[*l*..*r*] (1<=≤<=*l*<=<<=*r*<=≤<=*n*). Your task is to find the maximum number among all lucky numbers of sequences *s*[*l*..*r*]. Note that as all numbers in sequence *s* are distinct, all the given definitions make sence.

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

Print a single integer — the maximum lucky number among all lucky numbers of sequences *s*[*l*..*r*].

[ "5\n5 2 1 4 3\n", "5\n9 8 3 5 7\n" ]

[ "7\n", "15\n" ]

For the first sample you can choose *s*[4..5] = {4, 3} and its lucky number is (4 *xor* 3) = 7. You can also choose *s*[1..2]. For the second sample you must choose *s*[2..5] = {8, 3, 5, 7}.

1,000

[ { "input": "5\n5 2 1 4 3", "output": "7" }, { "input": "5\n9 8 3 5 7", "output": "15" }, { "input": "10\n76969694 71698884 32888447 31877010 65564584 87864180 7850891 1505323 17879621 15722446", "output": "128869996" }, { "input": "10\n4547989 39261040 94929326 38131456 26174500 7152864 71295827 77784626 89898294 68006331", "output": "134189790" }, { "input": "10\n30301275 19973434 63004643 54007648 93722492 91677384 58694045 41546981 15552151 5811338", "output": "112066588" }, { "input": "10\n47606126 65484553 142643 35352821 26622058 5603080 7296801 53938188 34750256 97196502", "output": "131671782" }, { "input": "10\n82942694 74816699 72957520 1634864 60842992 60103606 61079517 41624114 13932450 24035648", "output": "133874061" }, { "input": "10\n73622246 45316865 2066146 61168230 1258786 69603039 64470479 72811017 72683016 97992629", "output": "133280528" }, { "input": "10\n29272229 8752316 10025994 52398694 57994948 49609605 28150935 66061676 44865054 87041483", "output": "127710165" }, { "input": "10\n3106954 3413954 3854371 85952704 17834583 20954227 58810981 7460648 97908613 97965110", "output": "111078053" }, { "input": "3\n11 10 8", "output": "2" }, { "input": "2\n5 6", "output": "3" }, { "input": "2\n16 17", "output": "1" }, { "input": "3\n8 9 10", "output": "3" } ]

1,659,683,718

2,147,483,647

PyPy 3-64

OK

TESTS

56

93

14,848,000

n, a = int(input()), list(map(int, input().split())) def f(arr): ret = 0 st = [] for v in arr: while st and st[-1] < v: ret = max(st.pop(-1) ^ v, ret) if st: ret=max(st[-1]^v,ret) st.append(v) return ret print(f(a))

Title: Maximum Xor Secondary Time Limit: None seconds Memory Limit: None megabytes Problem Description: Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers *x*1,<=*x*2,<=...,<=*x**k* (*k*<=><=1) is such maximum element *x**j*, that the following inequality holds: . The lucky number of the sequence of distinct positive integers *x*1,<=*x*2,<=...,<=*x**k* (*k*<=><=1) is the number that is equal to the bitwise excluding OR of the maximum element of the sequence and the second maximum element of the sequence. You've got a sequence of distinct positive integers *s*1,<=*s*2,<=...,<=*s**n* (*n*<=><=1). Let's denote sequence *s**l*,<=*s**l*<=+<=1,<=...,<=*s**r* as *s*[*l*..*r*] (1<=≤<=*l*<=<<=*r*<=≤<=*n*). Your task is to find the maximum number among all lucky numbers of sequences *s*[*l*..*r*]. Note that as all numbers in sequence *s* are distinct, all the given definitions make sence. Input Specification: The first line contains integer *n* (1<=<<=*n*<=≤<=105). The second line contains *n* distinct integers *s*1,<=*s*2,<=...,<=*s**n* (1<=≤<=*s**i*<=≤<=109). Output Specification: Print a single integer — the maximum lucky number among all lucky numbers of sequences *s*[*l*..*r*]. Demo Input: ['5\n5 2 1 4 3\n', '5\n9 8 3 5 7\n'] Demo Output: ['7\n', '15\n'] Note: For the first sample you can choose *s*[4..5] = {4, 3} and its lucky number is (4 *xor* 3) = 7. You can also choose *s*[1..2]. For the second sample you must choose *s*[2..5] = {8, 3, 5, 7}.

```python n, a = int(input()), list(map(int, input().split())) def f(arr): ret = 0 st = [] for v in arr: while st and st[-1] < v: ret = max(st.pop(-1) ^ v, ret) if st: ret=max(st[-1]^v,ret) st.append(v) return ret print(f(a)) ```

3

610

B

Vika and Squares

PROGRAMMING

1,300

[ "constructive algorithms", "implementation" ]

null

Vika has *n* jars with paints of distinct colors. All the jars are numbered from 1 to *n* and the *i*-th jar contains *a**i* liters of paint of color *i*. Vika also has an infinitely long rectangular piece of paper of width 1, consisting of squares of size 1<=×<=1. Squares are numbered 1, 2, 3 and so on. Vika decided that she will start painting squares one by one from left to right, starting from the square number 1 and some arbitrary color. If the square was painted in color *x*, then the next square will be painted in color *x*<=+<=1. In case of *x*<==<=*n*, next square is painted in color 1. If there is no more paint of the color Vika wants to use now, then she stops. Square is always painted in only one color, and it takes exactly 1 liter of paint. Your task is to calculate the maximum number of squares that might be painted, if Vika chooses right color to paint the first square.

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of jars with colors Vika has. The second line of the input contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109), where *a**i* is equal to the number of liters of paint in the *i*-th jar, i.e. the number of liters of color *i* that Vika has.

The only line of the output should contain a single integer — the maximum number of squares that Vika can paint if she follows the rules described above.

[ "5\n2 4 2 3 3\n", "3\n5 5 5\n", "6\n10 10 10 1 10 10\n" ]

[ "12\n", "15\n", "11\n" ]

In the first sample the best strategy is to start painting using color 4. Then the squares will be painted in the following colors (from left to right): 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5. In the second sample Vika can start to paint using any color. In the third sample Vika should start painting using color number 5.

1,000

[ { "input": "5\n2 4 2 3 3", "output": "12" }, { "input": "3\n5 5 5", "output": "15" }, { "input": "6\n10 10 10 1 10 10", "output": "11" }, { "input": "1\n167959139", "output": "167959139" }, { "input": "10\n896619242 805194919 844752453 848347723 816995848 856813612 805194919 833406689 816255448 805194919", "output": "8051949194" }, { "input": "2\n2 3", "output": "5" }, { "input": "2\n10 10", "output": "20" }, { "input": "2\n1111 1110", "output": "2221" }, { "input": "3\n100 101 100", "output": "301" }, { "input": "3\n100 100 101", "output": "301" }, { "input": "3\n101 100 100", "output": "301" }, { "input": "4\n2 3 2 2", "output": "9" }, { "input": "4\n1 1 1 1", "output": "4" }, { "input": "4\n100 100 100 101", "output": "401" }, { "input": "4\n101 100 100 101", "output": "402" }, { "input": "4\n100 101 101 100", "output": "402" }, { "input": "4\n200 201 200 201", "output": "801" }, { "input": "4\n201 200 201 200", "output": "801" }, { "input": "4\n300 302 302 300", "output": "1202" }, { "input": "8\n5 4 3 2 1 1 1 1", "output": "12" }, { "input": "8\n2 2 1 2 2 1 2 2", "output": "12" }, { "input": "10\n2 1 2 1 2 2 2 2 2 1", "output": "15" }, { "input": "13\n2 2 2 1 1 1 1 1 1 1 2 2 2", "output": "19" } ]

1,630,210,883

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

248

39,116,800

n = int(input()) l = list(map(int,input().split())) a = min(l) mini = -1 for i in range(len(l)): if l[i]==a: mini = i flag = False c=0 for i in range(mini+1): if l[i]==a: flag = True if not flag: c+=(a+1) else: c+=a for i in range(mini+1,n): c+=a+1 print(c)

Title: Vika and Squares Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vika has *n* jars with paints of distinct colors. All the jars are numbered from 1 to *n* and the *i*-th jar contains *a**i* liters of paint of color *i*. Vika also has an infinitely long rectangular piece of paper of width 1, consisting of squares of size 1<=×<=1. Squares are numbered 1, 2, 3 and so on. Vika decided that she will start painting squares one by one from left to right, starting from the square number 1 and some arbitrary color. If the square was painted in color *x*, then the next square will be painted in color *x*<=+<=1. In case of *x*<==<=*n*, next square is painted in color 1. If there is no more paint of the color Vika wants to use now, then she stops. Square is always painted in only one color, and it takes exactly 1 liter of paint. Your task is to calculate the maximum number of squares that might be painted, if Vika chooses right color to paint the first square. Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of jars with colors Vika has. The second line of the input contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109), where *a**i* is equal to the number of liters of paint in the *i*-th jar, i.e. the number of liters of color *i* that Vika has. Output Specification: The only line of the output should contain a single integer — the maximum number of squares that Vika can paint if she follows the rules described above. Demo Input: ['5\n2 4 2 3 3\n', '3\n5 5 5\n', '6\n10 10 10 1 10 10\n'] Demo Output: ['12\n', '15\n', '11\n'] Note: In the first sample the best strategy is to start painting using color 4. Then the squares will be painted in the following colors (from left to right): 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5. In the second sample Vika can start to paint using any color. In the third sample Vika should start painting using color number 5.

```python n = int(input()) l = list(map(int,input().split())) a = min(l) mini = -1 for i in range(len(l)): if l[i]==a: mini = i flag = False c=0 for i in range(mini+1): if l[i]==a: flag = True if not flag: c+=(a+1) else: c+=a for i in range(mini+1,n): c+=a+1 print(c) ```

0

703

A

Mishka and Game

PROGRAMMING

800

[ "implementation" ]

null

Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game. Rules of the game are very simple: at first number of rounds *n* is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner. In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw. Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her!

The first line of the input contains single integer *n* *n* (1<=≤<=*n*<=≤<=100) — the number of game rounds. The next *n* lines contains rounds description. *i*-th of them contains pair of integers *m**i* and *c**i* (1<=≤<=*m**i*,<=<=*c**i*<=≤<=6) — values on dice upper face after Mishka's and Chris' throws in *i*-th round respectively.

If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line. If Chris is the winner of the game, print "Chris" (without quotes) in the only line. If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line.

[ "3\n3 5\n2 1\n4 2\n", "2\n6 1\n1 6\n", "3\n1 5\n3 3\n2 2\n" ]

[ "Mishka", "Friendship is magic!^^", "Chris" ]

In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game. In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1. In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.

500

[ { "input": "3\n3 5\n2 1\n4 2", "output": "Mishka" }, { "input": "2\n6 1\n1 6", "output": "Friendship is magic!^^" }, { "input": "3\n1 5\n3 3\n2 2", "output": "Chris" }, { "input": "6\n4 1\n4 2\n5 3\n5 1\n5 3\n4 1", "output": "Mishka" }, { "input": "8\n2 4\n1 4\n1 5\n2 6\n2 5\n2 5\n2 4\n2 5", "output": "Chris" }, { "input": "8\n4 1\n2 6\n4 2\n2 5\n5 2\n3 5\n5 2\n1 5", "output": "Friendship is magic!^^" }, { "input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n1 3", "output": "Mishka" }, { "input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "9\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1", "output": "Chris" }, { "input": "9\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n1 4", "output": "Mishka" }, { "input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "10\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1", "output": "Chris" }, { "input": "10\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "100\n2 4\n6 6\n3 2\n1 5\n5 2\n1 5\n1 5\n3 1\n6 5\n4 3\n1 1\n5 1\n3 3\n2 4\n1 5\n3 4\n5 1\n5 5\n2 5\n2 1\n4 3\n6 5\n1 1\n2 1\n1 3\n1 1\n6 4\n4 6\n6 4\n2 1\n2 5\n6 2\n3 4\n5 5\n1 4\n4 6\n3 4\n1 6\n5 1\n4 3\n3 4\n2 2\n1 2\n2 3\n1 3\n4 4\n5 5\n4 5\n4 4\n3 1\n4 5\n2 3\n2 6\n6 5\n6 1\n6 6\n2 3\n6 4\n3 3\n2 5\n4 4\n3 1\n2 4\n6 1\n3 2\n1 3\n5 4\n6 6\n2 5\n5 1\n1 1\n2 5\n6 5\n3 6\n5 6\n4 3\n3 4\n3 4\n6 5\n5 2\n4 2\n1 1\n3 1\n2 6\n1 6\n1 2\n6 1\n3 4\n1 6\n3 1\n5 3\n1 3\n5 6\n2 1\n6 4\n3 1\n1 6\n6 3\n3 3\n4 3", "output": "Chris" }, { "input": "100\n4 1\n3 4\n4 6\n4 5\n6 5\n5 3\n6 2\n6 3\n5 2\n4 5\n1 5\n5 4\n1 4\n4 5\n4 6\n1 6\n4 4\n5 1\n6 4\n6 4\n4 6\n2 3\n6 2\n4 6\n1 4\n2 3\n4 3\n1 3\n6 2\n3 1\n3 4\n2 6\n4 5\n5 4\n2 2\n2 5\n4 1\n2 2\n3 3\n1 4\n5 6\n6 4\n4 2\n6 1\n5 5\n4 1\n2 1\n6 4\n4 4\n4 3\n5 3\n4 5\n5 3\n3 5\n6 3\n1 1\n3 4\n6 3\n6 1\n5 1\n2 4\n4 3\n2 2\n5 5\n1 5\n5 3\n4 6\n1 4\n6 3\n4 3\n2 4\n3 2\n2 4\n3 4\n6 2\n5 6\n1 2\n1 5\n5 5\n2 6\n5 1\n1 6\n5 3\n3 5\n2 6\n4 6\n6 2\n3 1\n5 5\n6 1\n3 6\n4 4\n1 1\n4 6\n5 3\n4 2\n5 1\n3 3\n2 1\n1 4", "output": "Mishka" }, { "input": "100\n6 3\n4 5\n4 3\n5 4\n5 1\n6 3\n4 2\n4 6\n3 1\n2 4\n2 2\n4 6\n5 3\n5 5\n4 2\n6 2\n2 3\n4 4\n6 4\n3 5\n2 4\n2 2\n5 2\n3 5\n2 4\n4 4\n3 5\n6 5\n1 3\n1 6\n2 2\n2 4\n3 2\n5 4\n1 6\n3 4\n4 1\n1 5\n1 4\n5 3\n2 2\n4 5\n6 3\n4 4\n1 1\n4 1\n2 4\n4 1\n4 5\n5 3\n1 1\n1 6\n5 6\n6 6\n4 2\n4 3\n3 4\n3 6\n3 4\n6 5\n3 4\n5 4\n5 1\n5 3\n5 1\n1 2\n2 6\n3 4\n6 5\n4 3\n1 1\n5 5\n5 1\n3 3\n5 2\n1 3\n6 6\n5 6\n1 4\n4 4\n1 4\n3 6\n6 5\n3 3\n3 6\n1 5\n1 2\n3 6\n3 6\n4 1\n5 2\n1 2\n5 2\n3 3\n4 4\n4 2\n6 2\n5 4\n6 1\n6 3", "output": "Mishka" }, { "input": "8\n4 1\n6 2\n4 1\n5 3\n4 1\n5 3\n6 2\n5 3", "output": "Mishka" }, { "input": "5\n3 6\n3 5\n3 5\n1 6\n3 5", "output": "Chris" }, { "input": "4\n4 1\n2 4\n5 3\n3 6", "output": "Friendship is magic!^^" }, { "input": "6\n6 3\n5 1\n6 3\n4 3\n4 3\n5 2", "output": "Mishka" }, { "input": "7\n3 4\n1 4\n2 5\n1 6\n1 6\n1 5\n3 4", "output": "Chris" }, { "input": "6\n6 2\n2 5\n5 2\n3 6\n4 3\n1 6", "output": "Friendship is magic!^^" }, { "input": "8\n6 1\n5 3\n4 3\n4 1\n5 1\n4 2\n4 2\n4 1", "output": "Mishka" }, { "input": "9\n2 5\n2 5\n1 4\n2 6\n2 4\n2 5\n2 6\n1 5\n2 5", "output": "Chris" }, { "input": "4\n6 2\n2 4\n4 2\n3 6", "output": "Friendship is magic!^^" }, { "input": "9\n5 2\n4 1\n4 1\n5 1\n6 2\n6 1\n5 3\n6 1\n6 2", "output": "Mishka" }, { "input": "8\n2 4\n3 6\n1 6\n1 6\n2 4\n3 4\n3 6\n3 4", "output": "Chris" }, { "input": "6\n5 3\n3 6\n6 2\n1 6\n5 1\n3 5", "output": "Friendship is magic!^^" }, { "input": "6\n5 2\n5 1\n6 1\n5 2\n4 2\n5 1", "output": "Mishka" }, { "input": "5\n1 4\n2 5\n3 4\n2 6\n3 4", "output": "Chris" }, { "input": "4\n6 2\n3 4\n5 1\n1 6", "output": "Friendship is magic!^^" }, { "input": "93\n4 3\n4 1\n4 2\n5 2\n5 3\n6 3\n4 3\n6 2\n6 3\n5 1\n4 2\n4 2\n5 1\n6 2\n6 3\n6 1\n4 1\n6 2\n5 3\n4 3\n4 1\n4 2\n5 2\n6 3\n5 2\n5 2\n6 3\n5 1\n6 2\n5 2\n4 1\n5 2\n5 1\n4 1\n6 1\n5 2\n4 3\n5 3\n5 3\n5 1\n4 3\n4 3\n4 2\n4 1\n6 2\n6 1\n4 1\n5 2\n5 2\n6 2\n5 3\n5 1\n6 2\n5 1\n6 3\n5 2\n6 2\n6 2\n4 2\n5 2\n6 1\n6 3\n6 3\n5 1\n5 1\n4 1\n5 1\n4 3\n5 3\n6 3\n4 1\n4 3\n6 1\n6 1\n4 2\n6 2\n4 2\n5 2\n4 1\n5 2\n4 1\n5 1\n5 2\n5 1\n4 1\n6 3\n6 2\n4 3\n4 1\n5 2\n4 3\n5 2\n5 1", "output": "Mishka" }, { "input": "11\n1 6\n1 6\n2 4\n2 5\n3 4\n1 5\n1 6\n1 5\n1 6\n2 6\n3 4", "output": "Chris" }, { "input": "70\n6 1\n3 6\n4 3\n2 5\n5 2\n1 4\n6 2\n1 6\n4 3\n1 4\n5 3\n2 4\n5 3\n1 6\n5 1\n3 5\n4 2\n2 4\n5 1\n3 5\n6 2\n1 5\n4 2\n2 5\n5 3\n1 5\n4 2\n1 4\n5 2\n2 6\n4 3\n1 5\n6 2\n3 4\n4 2\n3 5\n6 3\n3 4\n5 1\n1 4\n4 2\n1 4\n6 3\n2 6\n5 2\n1 6\n6 1\n2 6\n5 3\n1 5\n5 1\n1 6\n4 1\n1 5\n4 2\n2 4\n5 1\n2 5\n6 3\n1 4\n6 3\n3 6\n5 1\n1 4\n5 3\n3 5\n4 2\n3 4\n6 2\n1 4", "output": "Friendship is magic!^^" }, { "input": "59\n4 1\n5 3\n6 1\n4 2\n5 1\n4 3\n6 1\n5 1\n4 3\n4 3\n5 2\n5 3\n4 1\n6 2\n5 1\n6 3\n6 3\n5 2\n5 2\n6 1\n4 1\n6 1\n4 3\n5 3\n5 3\n4 3\n4 2\n4 2\n6 3\n6 3\n6 1\n4 3\n5 1\n6 2\n6 1\n4 1\n6 1\n5 3\n4 2\n5 1\n6 2\n6 2\n4 3\n5 3\n4 3\n6 3\n5 2\n5 2\n4 3\n5 1\n5 3\n6 1\n6 3\n6 3\n4 3\n5 2\n5 2\n5 2\n4 3", "output": "Mishka" }, { "input": "42\n1 5\n1 6\n1 6\n1 4\n2 5\n3 6\n1 6\n3 4\n2 5\n2 5\n2 4\n1 4\n3 4\n2 4\n2 6\n1 5\n3 6\n2 6\n2 6\n3 5\n1 4\n1 5\n2 6\n3 6\n1 4\n3 4\n2 4\n1 6\n3 4\n2 4\n2 6\n1 6\n1 4\n1 6\n1 6\n2 4\n1 5\n1 6\n2 5\n3 6\n3 5\n3 4", "output": "Chris" }, { "input": "78\n4 3\n3 5\n4 3\n1 5\n5 1\n1 5\n4 3\n1 4\n6 3\n1 5\n4 1\n2 4\n4 3\n2 4\n5 1\n3 6\n4 2\n3 6\n6 3\n3 4\n4 3\n3 6\n5 3\n1 5\n4 1\n2 6\n4 2\n2 4\n4 1\n3 5\n5 2\n3 6\n4 3\n2 4\n6 3\n1 6\n4 3\n3 5\n6 3\n2 6\n4 1\n2 4\n6 2\n1 6\n4 2\n1 4\n4 3\n1 4\n4 3\n2 4\n6 2\n3 5\n6 1\n3 6\n5 3\n1 6\n6 1\n2 6\n4 2\n1 5\n6 2\n2 6\n6 3\n2 4\n4 2\n3 5\n6 1\n2 5\n5 3\n2 6\n5 1\n3 6\n4 3\n3 6\n6 3\n2 5\n6 1\n2 6", "output": "Friendship is magic!^^" }, { "input": "76\n4 1\n5 2\n4 3\n5 2\n5 3\n5 2\n6 1\n4 2\n6 2\n5 3\n4 2\n6 2\n4 1\n4 2\n5 1\n5 1\n6 2\n5 2\n5 3\n6 3\n5 2\n4 3\n6 3\n6 1\n4 3\n6 2\n6 1\n4 1\n6 1\n5 3\n4 1\n5 3\n4 2\n5 2\n4 3\n6 1\n6 2\n5 2\n6 1\n5 3\n4 3\n5 1\n5 3\n4 3\n5 1\n5 1\n4 1\n4 1\n4 1\n4 3\n5 3\n6 3\n6 3\n5 2\n6 2\n6 3\n5 1\n6 3\n5 3\n6 1\n5 3\n4 1\n5 3\n6 1\n4 2\n6 2\n4 3\n4 1\n6 2\n4 3\n5 3\n5 2\n5 3\n5 1\n6 3\n5 2", "output": "Mishka" }, { "input": "84\n3 6\n3 4\n2 5\n2 4\n1 6\n3 4\n1 5\n1 6\n3 5\n1 6\n2 4\n2 6\n2 6\n2 4\n3 5\n1 5\n3 6\n3 6\n3 4\n3 4\n2 6\n1 6\n1 6\n3 5\n3 4\n1 6\n3 4\n3 5\n2 4\n2 5\n2 5\n3 5\n1 6\n3 4\n2 6\n2 6\n3 4\n3 4\n2 5\n2 5\n2 4\n3 4\n2 5\n3 4\n3 4\n2 6\n2 6\n1 6\n2 4\n1 5\n3 4\n2 5\n2 5\n3 4\n2 4\n2 6\n2 6\n1 4\n3 5\n3 5\n2 4\n2 5\n3 4\n1 5\n1 5\n2 6\n1 5\n3 5\n2 4\n2 5\n3 4\n2 6\n1 6\n2 5\n3 5\n3 5\n3 4\n2 5\n2 6\n3 4\n1 6\n2 5\n2 6\n1 4", "output": "Chris" }, { "input": "44\n6 1\n1 6\n5 2\n1 4\n6 2\n2 5\n5 3\n3 6\n5 2\n1 6\n4 1\n2 4\n6 1\n3 4\n6 3\n3 6\n4 3\n2 4\n6 1\n3 4\n6 1\n1 6\n4 1\n3 5\n6 1\n3 6\n4 1\n1 4\n4 2\n2 6\n6 1\n2 4\n6 2\n1 4\n6 2\n2 4\n5 2\n3 6\n6 3\n2 6\n5 3\n3 4\n5 3\n2 4", "output": "Friendship is magic!^^" }, { "input": "42\n5 3\n5 1\n5 2\n4 1\n6 3\n6 1\n6 2\n4 1\n4 3\n4 1\n5 1\n5 3\n5 1\n4 1\n4 2\n6 1\n6 3\n5 1\n4 1\n4 1\n6 3\n4 3\n6 3\n5 2\n6 1\n4 1\n5 3\n4 3\n5 2\n6 3\n6 1\n5 1\n4 2\n4 3\n5 2\n5 3\n6 3\n5 2\n5 1\n5 3\n6 2\n6 1", "output": "Mishka" }, { "input": "50\n3 6\n2 6\n1 4\n1 4\n1 4\n2 5\n3 4\n3 5\n2 6\n1 6\n3 5\n1 5\n2 6\n2 4\n2 4\n3 5\n1 6\n1 5\n1 5\n1 4\n3 5\n1 6\n3 5\n1 4\n1 5\n1 4\n3 6\n1 6\n1 4\n1 4\n1 4\n1 5\n3 6\n1 6\n1 6\n2 4\n1 5\n2 6\n2 5\n3 5\n3 6\n3 4\n2 4\n2 6\n3 4\n2 5\n3 6\n3 5\n2 4\n2 4", "output": "Chris" }, { "input": "86\n6 3\n2 4\n6 3\n3 5\n6 3\n1 5\n5 2\n2 4\n4 3\n2 6\n4 1\n2 6\n5 2\n1 4\n5 1\n2 4\n4 1\n1 4\n6 2\n3 5\n4 2\n2 4\n6 2\n1 5\n5 3\n2 5\n5 1\n1 6\n6 1\n1 4\n4 3\n3 4\n5 2\n2 4\n5 3\n2 5\n4 3\n3 4\n4 1\n1 5\n6 3\n3 4\n4 3\n3 4\n4 1\n3 4\n5 1\n1 6\n4 2\n1 6\n5 1\n2 4\n5 1\n3 6\n4 1\n1 5\n5 2\n1 4\n4 3\n2 5\n5 1\n1 5\n6 2\n2 6\n4 2\n2 4\n4 1\n2 5\n5 3\n3 4\n5 1\n3 4\n6 3\n3 4\n4 3\n2 6\n6 2\n2 5\n5 2\n3 5\n4 2\n3 6\n6 2\n3 4\n4 2\n2 4", "output": "Friendship is magic!^^" }, { "input": "84\n6 1\n6 3\n6 3\n4 1\n4 3\n4 2\n6 3\n5 3\n6 1\n6 3\n4 3\n5 2\n5 3\n5 1\n6 2\n6 2\n6 1\n4 1\n6 3\n5 2\n4 1\n5 3\n6 3\n4 2\n6 2\n6 3\n4 3\n4 1\n4 3\n5 1\n5 1\n5 1\n4 1\n6 1\n4 3\n6 2\n5 1\n5 1\n6 2\n5 2\n4 1\n6 1\n6 1\n6 3\n6 2\n4 3\n6 3\n6 2\n5 2\n5 1\n4 3\n6 2\n4 1\n6 2\n6 1\n5 2\n5 1\n6 2\n6 1\n5 3\n5 2\n6 1\n6 3\n5 2\n6 1\n6 3\n4 3\n5 1\n6 3\n6 1\n5 3\n4 3\n5 2\n5 1\n6 2\n5 3\n6 1\n5 1\n4 1\n5 1\n5 1\n5 2\n5 2\n5 1", "output": "Mishka" }, { "input": "92\n1 5\n2 4\n3 5\n1 6\n2 5\n1 6\n3 6\n1 6\n2 4\n3 4\n3 4\n3 6\n1 5\n2 5\n1 5\n1 5\n2 6\n2 4\n3 6\n1 4\n1 6\n2 6\n3 4\n2 6\n2 6\n1 4\n3 5\n2 5\n2 6\n1 5\n1 4\n1 5\n3 6\n3 5\n2 5\n1 5\n3 5\n3 6\n2 6\n2 6\n1 5\n3 4\n2 4\n3 6\n2 5\n1 5\n2 4\n1 4\n2 6\n2 6\n2 6\n1 5\n3 6\n3 6\n2 5\n1 4\n2 4\n3 4\n1 5\n2 5\n2 4\n2 5\n3 5\n3 4\n3 6\n2 6\n3 5\n1 4\n3 4\n1 6\n3 6\n2 6\n1 4\n3 6\n3 6\n2 5\n2 6\n1 6\n2 6\n3 5\n2 5\n3 6\n2 5\n2 6\n1 5\n2 4\n1 4\n2 4\n1 5\n2 5\n2 5\n2 6", "output": "Chris" }, { "input": "20\n5 1\n1 4\n4 3\n1 5\n4 2\n3 6\n6 2\n1 6\n4 1\n1 4\n5 2\n3 4\n5 1\n1 6\n5 1\n2 6\n6 3\n2 5\n6 2\n2 4", "output": "Friendship is magic!^^" }, { "input": "100\n4 3\n4 3\n4 2\n4 3\n4 1\n4 3\n5 2\n5 2\n6 2\n4 2\n5 1\n4 2\n5 2\n6 1\n4 1\n6 3\n5 3\n5 1\n5 1\n5 1\n5 3\n6 1\n6 1\n4 1\n5 2\n5 2\n6 1\n6 3\n4 2\n4 1\n5 3\n4 1\n5 3\n5 1\n6 3\n6 3\n6 1\n5 2\n5 3\n5 3\n6 1\n4 1\n6 2\n6 1\n6 2\n6 3\n4 3\n4 3\n6 3\n4 2\n4 2\n5 3\n5 2\n5 2\n4 3\n5 3\n5 2\n4 2\n5 1\n4 2\n5 1\n5 3\n6 3\n5 3\n5 3\n4 2\n4 1\n4 2\n4 3\n6 3\n4 3\n6 2\n6 1\n5 3\n5 2\n4 1\n6 1\n5 2\n6 2\n4 2\n6 3\n4 3\n5 1\n6 3\n5 2\n4 3\n5 3\n5 3\n4 3\n6 3\n4 3\n4 1\n5 1\n6 2\n6 3\n5 3\n6 1\n6 3\n5 3\n6 1", "output": "Mishka" }, { "input": "100\n1 5\n1 4\n1 5\n2 4\n2 6\n3 6\n3 5\n1 5\n2 5\n3 6\n3 5\n1 6\n1 4\n1 5\n1 6\n2 6\n1 5\n3 5\n3 4\n2 6\n2 6\n2 5\n3 4\n1 6\n1 4\n2 4\n1 5\n1 6\n3 5\n1 6\n2 6\n3 5\n1 6\n3 4\n3 5\n1 6\n3 6\n2 4\n2 4\n3 5\n2 6\n1 5\n3 5\n3 6\n2 4\n2 4\n2 6\n3 4\n3 4\n1 5\n1 4\n2 5\n3 4\n1 4\n2 6\n2 5\n2 4\n2 4\n2 5\n1 5\n1 6\n1 5\n1 5\n1 5\n1 6\n3 4\n2 4\n3 5\n3 5\n1 6\n3 5\n1 5\n1 6\n3 6\n3 4\n1 5\n3 5\n3 6\n1 4\n3 6\n1 5\n3 5\n3 6\n3 5\n1 4\n3 4\n2 4\n2 4\n2 5\n3 6\n3 5\n1 5\n2 4\n1 4\n3 4\n1 5\n3 4\n3 6\n3 5\n3 4", "output": "Chris" }, { "input": "100\n4 3\n3 4\n5 1\n2 5\n5 3\n1 5\n6 3\n2 4\n5 2\n2 6\n5 2\n1 5\n6 3\n1 5\n6 3\n3 4\n5 2\n1 5\n6 1\n1 5\n4 2\n3 5\n6 3\n2 6\n6 3\n1 4\n6 2\n3 4\n4 1\n3 6\n5 1\n2 4\n5 1\n3 4\n6 2\n3 5\n4 1\n2 6\n4 3\n2 6\n5 2\n3 6\n6 2\n3 5\n4 3\n1 5\n5 3\n3 6\n4 2\n3 4\n6 1\n3 4\n5 2\n2 6\n5 2\n2 4\n6 2\n3 6\n4 3\n2 4\n4 3\n2 6\n4 2\n3 4\n6 3\n2 4\n6 3\n3 5\n5 2\n1 5\n6 3\n3 6\n4 3\n1 4\n5 2\n1 6\n4 1\n2 5\n4 1\n2 4\n4 2\n2 5\n6 1\n2 4\n6 3\n1 5\n4 3\n2 6\n6 3\n2 6\n5 3\n1 5\n4 1\n1 5\n6 2\n2 5\n5 1\n3 6\n4 3\n3 4", "output": "Friendship is magic!^^" }, { "input": "99\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n1 3", "output": "Mishka" }, { "input": "99\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\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\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\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "99\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\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\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\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1", "output": "Chris" }, { "input": "99\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\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\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\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "100\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n2 1\n2 1\n2 1\n1 4", "output": "Mishka" }, { "input": "100\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\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\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\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "100\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\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\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\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1\n6 1", "output": "Chris" }, { "input": "100\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\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\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\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6\n1 6", "output": "Mishka" }, { "input": "84\n6 2\n1 5\n6 2\n2 3\n5 5\n1 2\n3 4\n3 4\n6 5\n6 4\n2 5\n4 1\n1 2\n1 1\n1 4\n2 5\n5 6\n6 3\n2 4\n5 5\n2 6\n3 4\n5 1\n3 3\n5 5\n4 6\n4 6\n2 4\n4 1\n5 2\n2 2\n3 6\n3 3\n4 6\n1 1\n2 4\n6 5\n5 2\n6 5\n5 5\n2 5\n6 4\n1 1\n6 2\n3 6\n6 5\n4 4\n1 5\n5 6\n4 4\n3 5\n6 1\n3 4\n1 5\n4 6\n4 6\n4 1\n3 6\n6 2\n1 1\n4 5\n5 4\n5 3\n3 4\n6 4\n1 1\n5 2\n6 5\n6 1\n2 2\n2 4\n3 3\n4 6\n1 3\n6 6\n5 2\n1 6\n6 2\n6 6\n4 1\n3 6\n6 4\n2 3\n3 4", "output": "Chris" }, { "input": "70\n3 4\n2 3\n2 3\n6 5\n6 6\n4 3\n2 3\n3 1\n3 5\n5 6\n1 6\n2 5\n5 3\n2 5\n4 6\n5 1\n6 1\n3 1\n3 3\n5 3\n2 1\n3 3\n6 4\n6 3\n4 3\n4 5\n3 5\n5 5\n5 2\n1 6\n3 4\n5 2\n2 4\n1 6\n4 3\n4 3\n6 2\n1 3\n1 5\n6 1\n3 1\n1 1\n1 3\n2 2\n3 2\n6 4\n1 1\n4 4\n3 1\n4 5\n4 2\n6 3\n4 4\n3 2\n1 2\n2 6\n3 3\n1 5\n1 1\n6 5\n2 2\n3 1\n5 4\n5 2\n6 4\n6 3\n6 6\n6 3\n3 3\n5 4", "output": "Mishka" }, { "input": "56\n6 4\n3 4\n6 1\n3 3\n1 4\n2 3\n1 5\n2 5\n1 5\n5 5\n2 3\n1 1\n3 2\n3 5\n4 6\n4 4\n5 2\n4 3\n3 1\n3 6\n2 3\n3 4\n5 6\n5 2\n5 6\n1 5\n1 5\n4 1\n6 3\n2 2\n2 1\n5 5\n2 1\n4 1\n5 4\n2 5\n4 1\n6 2\n3 4\n4 2\n6 4\n5 4\n4 2\n4 3\n6 2\n6 2\n3 1\n1 4\n3 6\n5 1\n5 5\n3 6\n6 4\n2 3\n6 5\n3 3", "output": "Mishka" }, { "input": "94\n2 4\n6 4\n1 6\n1 4\n5 1\n3 3\n4 3\n6 1\n6 5\n3 2\n2 3\n5 1\n5 3\n1 2\n4 3\n3 2\n2 3\n4 6\n1 3\n6 3\n1 1\n3 2\n4 3\n1 5\n4 6\n3 2\n6 3\n1 6\n1 1\n1 2\n3 5\n1 3\n3 5\n4 4\n4 2\n1 4\n4 5\n1 3\n1 2\n1 1\n5 4\n5 5\n6 1\n2 1\n2 6\n6 6\n4 2\n3 6\n1 6\n6 6\n1 5\n3 2\n1 2\n4 4\n6 4\n4 1\n1 5\n3 3\n1 3\n3 4\n4 4\n1 1\n2 5\n4 5\n3 1\n3 1\n3 6\n3 2\n1 4\n1 6\n6 3\n2 4\n1 1\n2 2\n2 2\n2 1\n5 4\n1 2\n6 6\n2 2\n3 3\n6 3\n6 3\n1 6\n2 3\n2 4\n2 3\n6 6\n2 6\n6 3\n3 5\n1 4\n1 1\n3 5", "output": "Chris" }, { "input": "81\n4 2\n1 2\n2 3\n4 5\n6 2\n1 6\n3 6\n3 4\n4 6\n4 4\n3 5\n4 6\n3 6\n3 5\n3 1\n1 3\n5 3\n3 4\n1 1\n4 1\n1 2\n6 1\n1 3\n6 5\n4 5\n4 2\n4 5\n6 2\n1 2\n2 6\n5 2\n1 5\n2 4\n4 3\n5 4\n1 2\n5 3\n2 6\n6 4\n1 1\n1 3\n3 1\n3 1\n6 5\n5 5\n6 1\n6 6\n5 2\n1 3\n1 4\n2 3\n5 5\n3 1\n3 1\n4 4\n1 6\n6 4\n2 2\n4 6\n4 4\n2 6\n2 4\n2 4\n4 1\n1 6\n1 4\n1 3\n6 5\n5 1\n1 3\n5 1\n1 4\n3 5\n2 6\n1 3\n5 6\n3 5\n4 4\n5 5\n5 6\n4 3", "output": "Chris" }, { "input": "67\n6 5\n3 6\n1 6\n5 3\n5 4\n5 1\n1 6\n1 1\n3 2\n4 4\n3 1\n4 1\n1 5\n5 3\n3 3\n6 4\n2 4\n2 2\n4 3\n1 4\n1 4\n6 1\n1 2\n2 2\n5 1\n6 2\n3 5\n5 5\n2 2\n6 5\n6 2\n4 4\n3 1\n4 2\n6 6\n6 4\n5 1\n2 2\n4 5\n5 5\n4 6\n1 5\n6 3\n4 4\n1 5\n6 4\n3 6\n3 4\n1 6\n2 4\n2 1\n2 5\n6 5\n6 4\n4 1\n3 2\n1 2\n5 1\n5 6\n1 5\n3 5\n3 1\n5 3\n3 2\n5 1\n4 6\n6 6", "output": "Mishka" }, { "input": "55\n6 6\n6 5\n2 2\n2 2\n6 4\n5 5\n6 5\n5 3\n1 3\n2 2\n5 6\n3 3\n3 3\n6 5\n3 5\n5 5\n1 2\n1 1\n4 6\n1 2\n5 5\n6 2\n6 3\n1 2\n5 1\n1 3\n3 3\n4 4\n2 5\n1 1\n5 3\n4 3\n2 2\n4 5\n5 6\n4 5\n6 3\n1 6\n6 4\n3 6\n1 6\n5 2\n6 3\n2 3\n5 5\n4 3\n3 1\n4 2\n1 1\n2 5\n5 3\n2 2\n6 3\n4 5\n2 2", "output": "Mishka" }, { "input": "92\n2 3\n1 3\n2 6\n5 1\n5 5\n3 2\n5 6\n2 5\n3 1\n3 6\n4 5\n2 5\n1 2\n2 3\n6 5\n3 6\n4 4\n6 2\n4 5\n4 4\n5 1\n6 1\n3 4\n3 5\n6 6\n3 2\n6 4\n2 2\n3 5\n6 4\n6 3\n6 6\n3 4\n3 3\n6 1\n5 4\n6 2\n2 6\n5 6\n1 4\n4 6\n6 3\n3 1\n4 1\n6 6\n3 5\n6 3\n6 1\n1 6\n3 2\n6 6\n4 3\n3 4\n1 3\n3 5\n5 3\n6 5\n4 3\n5 5\n4 1\n1 5\n6 4\n2 3\n2 3\n1 5\n1 2\n5 2\n4 3\n3 6\n5 5\n5 4\n1 4\n3 3\n1 6\n5 6\n5 4\n5 3\n1 1\n6 2\n5 5\n2 5\n4 3\n6 6\n5 1\n1 1\n4 6\n4 6\n3 1\n6 4\n2 4\n2 2\n2 1", "output": "Chris" }, { "input": "79\n5 3\n4 6\n3 6\n2 1\n5 2\n2 3\n4 4\n6 2\n2 5\n1 6\n6 6\n2 6\n3 3\n4 5\n6 2\n2 1\n1 5\n5 1\n2 1\n2 6\n5 3\n6 2\n2 6\n2 3\n1 5\n4 4\n6 3\n5 2\n3 2\n1 3\n1 3\n6 3\n2 6\n3 6\n5 3\n4 5\n6 1\n3 5\n3 5\n6 5\n1 5\n4 2\n6 2\n2 3\n4 6\n3 6\n2 5\n4 4\n1 1\n4 6\n2 6\n6 4\n3 2\n4 1\n1 2\n6 4\n5 6\n1 4\n2 2\n5 4\n3 2\n1 2\n2 4\n2 5\n2 1\n3 6\n3 3\n1 1\n2 2\n4 4\n4 5\n3 3\n5 3\n6 2\n4 5\n6 5\n2 5\n5 6\n2 2", "output": "Chris" }, { "input": "65\n1 1\n5 1\n2 2\n5 4\n4 5\n2 5\n3 2\n5 6\n6 3\n1 1\n6 1\n1 5\n1 1\n5 2\n6 4\n1 6\n1 1\n4 3\n2 3\n5 6\n4 4\n6 2\n1 3\n4 3\n1 3\n6 3\n3 5\n4 2\n4 1\n6 1\n3 2\n2 6\n3 2\n3 5\n6 3\n4 3\n1 5\n2 6\n1 3\n4 1\n4 1\n2 5\n2 5\n6 2\n5 3\n3 1\n3 3\n5 1\n2 4\n5 3\n3 3\n1 1\n6 3\n3 3\n5 1\n1 6\n4 5\n6 6\n5 5\n2 5\n4 1\n2 2\n1 4\n1 6\n6 5", "output": "Mishka" }, { "input": "1\n1 1", "output": "Friendship is magic!^^" } ]

1,694,605,310

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

5

77

0

n=int(input()) s=0; t=0; for i in range(n): a,b=map(int,input().split()) s+=a; t+=b; if s==t: print('Friendship is magic!^^'); if s>t: print('Mishka'); elif s<t: print('Chris');

Title: Mishka and Game Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mishka is a little polar bear. As known, little bears loves spending their free time playing dice for chocolates. Once in a wonderful sunny morning, walking around blocks of ice, Mishka met her friend Chris, and they started playing the game. Rules of the game are very simple: at first number of rounds *n* is defined. In every round each of the players throws a cubical dice with distinct numbers from 1 to 6 written on its faces. Player, whose value after throwing the dice is greater, wins the round. In case if player dice values are equal, no one of them is a winner. In average, player, who won most of the rounds, is the winner of the game. In case if two players won the same number of rounds, the result of the game is draw. Mishka is still very little and can't count wins and losses, so she asked you to watch their game and determine its result. Please help her! Input Specification: The first line of the input contains single integer *n* *n* (1<=≤<=*n*<=≤<=100) — the number of game rounds. The next *n* lines contains rounds description. *i*-th of them contains pair of integers *m**i* and *c**i* (1<=≤<=*m**i*,<=<=*c**i*<=≤<=6) — values on dice upper face after Mishka's and Chris' throws in *i*-th round respectively. Output Specification: If Mishka is the winner of the game, print "Mishka" (without quotes) in the only line. If Chris is the winner of the game, print "Chris" (without quotes) in the only line. If the result of the game is draw, print "Friendship is magic!^^" (without quotes) in the only line. Demo Input: ['3\n3 5\n2 1\n4 2\n', '2\n6 1\n1 6\n', '3\n1 5\n3 3\n2 2\n'] Demo Output: ['Mishka', 'Friendship is magic!^^', 'Chris'] Note: In the first sample case Mishka loses the first round, but wins second and third rounds and thus she is the winner of the game. In the second sample case Mishka wins the first round, Chris wins the second round, and the game ends with draw with score 1:1. In the third sample case Chris wins the first round, but there is no winner of the next two rounds. The winner of the game is Chris.

```python n=int(input()) s=0; t=0; for i in range(n): a,b=map(int,input().split()) s+=a; t+=b; if s==t: print('Friendship is magic!^^'); if s>t: print('Mishka'); elif s<t: print('Chris'); ```

0

300

A

Array

PROGRAMMING

1,100

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

null

Vitaly has an array of *n* distinct integers. Vitaly wants to divide this array into three non-empty sets so as the following conditions hold: 1. The product of all numbers in the first set is less than zero (<=<<=0). 1. The product of all numbers in the second set is greater than zero (<=><=0). 1. The product of all numbers in the third set is equal to zero. 1. Each number from the initial array must occur in exactly one set. Help Vitaly. Divide the given array.

The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=100). The second line contains *n* space-separated distinct integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=103) — the array elements.

In the first line print integer *n*1 (*n*1<=><=0) — the number of elements in the first set. Then print *n*1 numbers — the elements that got to the first set. In the next line print integer *n*2 (*n*2<=><=0) — the number of elements in the second set. Then print *n*2 numbers — the elements that got to the second set. In the next line print integer *n*3 (*n*3<=><=0) — the number of elements in the third set. Then print *n*3 numbers — the elements that got to the third set. The printed sets must meet the described conditions. It is guaranteed that the solution exists. If there are several solutions, you are allowed to print any of them.

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

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

none

500

[ { "input": "3\n-1 2 0", "output": "1 -1\n1 2\n1 0" }, { "input": "4\n-1 -2 -3 0", "output": "1 -1\n2 -3 -2\n1 0" }, { "input": "5\n-1 -2 1 2 0", "output": "1 -1\n2 1 2\n2 0 -2" }, { "input": "100\n-64 -51 -75 -98 74 -26 -1 -8 -99 -76 -53 -80 -43 -22 -100 -62 -34 -5 -65 -81 -18 -91 -92 -16 -23 -95 -9 -19 -44 -46 -79 52 -35 4 -87 -7 -90 -20 -71 -61 -67 -50 -66 -68 -49 -27 -32 -57 -85 -59 -30 -36 -3 -77 86 -25 -94 -56 60 -24 -37 -72 -41 -31 11 -48 28 -38 -42 -39 -33 -70 -84 0 -93 -73 -14 -69 -40 -97 -6 -55 -45 -54 -10 -29 -96 -12 -83 -15 -21 -47 17 -2 -63 -89 88 13 -58 -82", "output": "89 -64 -51 -75 -98 -26 -1 -8 -99 -76 -53 -80 -43 -22 -100 -62 -34 -5 -65 -81 -18 -91 -92 -16 -23 -95 -9 -19 -44 -46 -79 -35 -87 -7 -90 -20 -71 -61 -67 -50 -66 -68 -49 -27 -32 -57 -85 -59 -30 -36 -3 -77 -25 -94 -56 -24 -37 -72 -41 -31 -48 -38 -42 -39 -33 -70 -84 -93 -73 -14 -69 -40 -97 -6 -55 -45 -54 -10 -29 -96 -12 -83 -15 -21 -47 -2 -63 -89 -58 -82\n10 74 52 4 86 60 11 28 17 88 13\n1 0" }, { "input": "100\n3 -66 -17 54 24 -29 76 89 32 -37 93 -16 99 -25 51 78 23 68 -95 59 18 34 -45 77 9 39 -10 19 8 73 -5 60 12 31 0 2 26 40 48 30 52 49 27 4 87 57 85 58 -61 50 83 80 69 67 91 97 -96 11 100 56 82 53 13 -92 -72 70 1 -94 -63 47 21 14 74 7 6 33 55 65 64 -41 81 42 36 28 38 20 43 71 90 -88 22 84 -86 15 75 62 44 35 98 46", "output": "19 -66 -17 -29 -37 -16 -25 -95 -45 -10 -5 -61 -96 -92 -72 -94 -63 -41 -88 -86\n80 3 54 24 76 89 32 93 99 51 78 23 68 59 18 34 77 9 39 19 8 73 60 12 31 2 26 40 48 30 52 49 27 4 87 57 85 58 50 83 80 69 67 91 97 11 100 56 82 53 13 70 1 47 21 14 74 7 6 33 55 65 64 81 42 36 28 38 20 43 71 90 22 84 15 75 62 44 35 98 46\n1 0" }, { "input": "100\n-17 16 -70 32 -60 75 -100 -9 -68 -30 -42 86 -88 -98 -47 -5 58 -14 -94 -73 -80 -51 -66 -85 -53 49 -25 -3 -45 -69 -11 -64 83 74 -65 67 13 -91 81 6 -90 -54 -12 -39 0 -24 -71 -41 -44 57 -93 -20 -92 18 -43 -52 -55 -84 -89 -19 40 -4 -99 -26 -87 -36 -56 -61 -62 37 -95 -28 63 23 35 -82 1 -2 -78 -96 -21 -77 -76 -27 -10 -97 -8 46 -15 -48 -34 -59 -7 -29 50 -33 -72 -79 22 38", "output": "75 -17 -70 -60 -100 -9 -68 -30 -42 -88 -98 -47 -5 -14 -94 -73 -80 -51 -66 -85 -53 -25 -3 -45 -69 -11 -64 -65 -91 -90 -54 -12 -39 -24 -71 -41 -44 -93 -20 -92 -43 -52 -55 -84 -89 -19 -4 -99 -26 -87 -36 -56 -61 -62 -95 -28 -82 -2 -78 -96 -21 -77 -76 -27 -10 -97 -8 -15 -48 -34 -59 -7 -29 -33 -72 -79\n24 16 32 75 86 58 49 83 74 67 13 81 6 57 18 40 37 63 23 35 1 46 50 22 38\n1 0" }, { "input": "100\n-97 -90 61 78 87 -52 -3 65 83 38 30 -60 35 -50 -73 -77 44 -32 -81 17 -67 58 -6 -34 47 -28 71 -45 69 -80 -4 -7 -57 -79 43 -27 -31 29 16 -89 -21 -93 95 -82 74 -5 -70 -20 -18 36 -64 -66 72 53 62 -68 26 15 76 -40 -99 8 59 88 49 -23 9 10 56 -48 -98 0 100 -54 25 94 13 -63 42 39 -1 55 24 -12 75 51 41 84 -96 -85 -2 -92 14 -46 -91 -19 -11 -86 22 -37", "output": "51 -97 -90 -52 -3 -60 -50 -73 -77 -32 -81 -67 -6 -34 -28 -45 -80 -4 -7 -57 -79 -27 -31 -89 -21 -93 -82 -5 -70 -20 -18 -64 -66 -68 -40 -99 -23 -48 -98 -54 -63 -1 -12 -96 -85 -2 -92 -46 -91 -19 -11 -86\n47 61 78 87 65 83 38 30 35 44 17 58 47 71 69 43 29 16 95 74 36 72 53 62 26 15 76 8 59 88 49 9 10 56 100 25 94 13 42 39 55 24 75 51 41 84 14 22\n2 0 -37" }, { "input": "100\n-75 -60 -18 -92 -71 -9 -37 -34 -82 28 -54 93 -83 -76 -58 -88 -17 -97 64 -39 -96 -81 -10 -98 -47 -100 -22 27 14 -33 -19 -99 87 -66 57 -21 -90 -70 -32 -26 24 -77 -74 13 -44 16 -5 -55 -2 -6 -7 -73 -1 -68 -30 -95 -42 69 0 -20 -79 59 -48 -4 -72 -67 -46 62 51 -52 -86 -40 56 -53 85 -35 -8 49 50 65 29 11 -43 -15 -41 -12 -3 -80 -31 -38 -91 -45 -25 78 94 -23 -63 84 89 -61", "output": "73 -75 -60 -18 -92 -71 -9 -37 -34 -82 -54 -83 -76 -58 -88 -17 -97 -39 -96 -81 -10 -98 -47 -100 -22 -33 -19 -99 -66 -21 -90 -70 -32 -26 -77 -74 -44 -5 -55 -2 -6 -7 -73 -1 -68 -30 -95 -42 -20 -79 -48 -4 -72 -67 -46 -52 -86 -40 -53 -35 -8 -43 -15 -41 -12 -3 -80 -31 -38 -91 -45 -25 -23 -63\n25 28 93 64 27 14 87 57 24 13 16 69 59 62 51 56 85 49 50 65 29 11 78 94 84 89\n2 0 -61" }, { "input": "100\n-87 -48 -76 -1 -10 -17 -22 -19 -27 -99 -43 49 38 -20 -45 -64 44 -96 -35 -74 -65 -41 -21 -75 37 -12 -67 0 -3 5 -80 -93 -81 -97 -47 -63 53 -100 95 -79 -83 -90 -32 88 -77 -16 -23 -54 -28 -4 -73 -98 -25 -39 60 -56 -34 -2 -11 -55 -52 -69 -68 -29 -82 -62 -36 -13 -6 -89 8 -72 18 -15 -50 -71 -70 -92 -42 -78 -61 -9 -30 -85 -91 -94 84 -86 -7 -57 -14 40 -33 51 -26 46 59 -31 -58 -66", "output": "83 -87 -48 -76 -1 -10 -17 -22 -19 -27 -99 -43 -20 -45 -64 -96 -35 -74 -65 -41 -21 -75 -12 -67 -3 -80 -93 -81 -97 -47 -63 -100 -79 -83 -90 -32 -77 -16 -23 -54 -28 -4 -73 -98 -25 -39 -56 -34 -2 -11 -55 -52 -69 -68 -29 -82 -62 -36 -13 -6 -89 -72 -15 -50 -71 -70 -92 -42 -78 -61 -9 -30 -85 -91 -94 -86 -7 -57 -14 -33 -26 -31 -58 -66\n16 49 38 44 37 5 53 95 88 60 8 18 84 40 51 46 59\n1 0" }, { "input": "100\n-95 -28 -43 -72 -11 -24 -37 -35 -44 -66 -45 -62 -96 -51 -55 -23 -31 -26 -59 -17 77 -69 -10 -12 -78 -14 -52 -57 -40 -75 4 -98 -6 7 -53 -3 -90 -63 -8 -20 88 -91 -32 -76 -80 -97 -34 -27 -19 0 70 -38 -9 -49 -67 73 -36 2 81 -39 -65 -83 -64 -18 -94 -79 -58 -16 87 -22 -74 -25 -13 -46 -89 -47 5 -15 -54 -99 56 -30 -60 -21 -86 33 -1 -50 -68 -100 -85 -29 92 -48 -61 42 -84 -93 -41 -82", "output": "85 -95 -28 -43 -72 -11 -24 -37 -35 -44 -66 -45 -62 -96 -51 -55 -23 -31 -26 -59 -17 -69 -10 -12 -78 -14 -52 -57 -40 -75 -98 -6 -53 -3 -90 -63 -8 -20 -91 -32 -76 -80 -97 -34 -27 -19 -38 -9 -49 -67 -36 -39 -65 -83 -64 -18 -94 -79 -58 -16 -22 -74 -25 -13 -46 -89 -47 -15 -54 -99 -30 -60 -21 -86 -1 -50 -68 -100 -85 -29 -48 -61 -84 -93 -41 -82\n14 77 4 7 88 70 73 2 81 87 5 56 33 92 42\n1 0" }, { "input": "100\n-12 -41 57 13 83 -36 53 69 -6 86 -75 87 11 -5 -4 -14 -37 -84 70 2 -73 16 31 34 -45 94 -9 26 27 52 -42 46 96 21 32 7 -18 61 66 -51 95 -48 -76 90 80 -40 89 77 78 54 -30 8 88 33 -24 82 -15 19 1 59 44 64 -97 -60 43 56 35 47 39 50 29 28 -17 -67 74 23 85 -68 79 0 65 55 -3 92 -99 72 93 -71 38 -10 -100 -98 81 62 91 -63 -58 49 -20 22", "output": "35 -12 -41 -36 -6 -75 -5 -4 -14 -37 -84 -73 -45 -9 -42 -18 -51 -48 -76 -40 -30 -24 -15 -97 -60 -17 -67 -68 -3 -99 -71 -10 -100 -98 -63 -58\n63 57 13 83 53 69 86 87 11 70 2 16 31 34 94 26 27 52 46 96 21 32 7 61 66 95 90 80 89 77 78 54 8 88 33 82 19 1 59 44 64 43 56 35 47 39 50 29 28 74 23 85 79 65 55 92 72 93 38 81 62 91 49 22\n2 0 -20" }, { "input": "100\n-34 81 85 -96 50 20 54 86 22 10 -19 52 65 44 30 53 63 71 17 98 -92 4 5 -99 89 -23 48 9 7 33 75 2 47 -56 42 70 -68 57 51 83 82 94 91 45 46 25 95 11 -12 62 -31 -87 58 38 67 97 -60 66 73 -28 13 93 29 59 -49 77 37 -43 -27 0 -16 72 15 79 61 78 35 21 3 8 84 1 -32 36 74 -88 26 100 6 14 40 76 18 90 24 69 80 64 55 41", "output": "19 -34 -96 -19 -92 -99 -23 -56 -68 -12 -31 -87 -60 -28 -49 -43 -27 -16 -32 -88\n80 81 85 50 20 54 86 22 10 52 65 44 30 53 63 71 17 98 4 5 89 48 9 7 33 75 2 47 42 70 57 51 83 82 94 91 45 46 25 95 11 62 58 38 67 97 66 73 13 93 29 59 77 37 72 15 79 61 78 35 21 3 8 84 1 36 74 26 100 6 14 40 76 18 90 24 69 80 64 55 41\n1 0" }, { "input": "100\n-1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 0 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983 -952 -935", "output": "97 -1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983\n2 -935 -952\n1 0" }, { "input": "99\n-1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 0 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983 -952", "output": "95 -1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941\n2 -952 -983\n2 0 -961" }, { "input": "59\n-990 -876 -641 -726 718 -53 803 -954 894 -265 -587 -665 904 349 754 -978 441 794 -768 -428 -569 -476 188 -620 -290 -333 45 705 -201 109 165 446 13 122 714 -562 -15 -86 -960 43 329 578 287 -776 -14 -71 915 886 -259 337 -495 913 -498 -669 -673 818 225 647 0", "output": "29 -990 -876 -641 -726 -53 -954 -265 -587 -665 -978 -768 -428 -569 -476 -620 -290 -333 -201 -562 -15 -86 -960 -776 -14 -71 -259 -495 -498 -669\n28 718 803 894 904 349 754 441 794 188 45 705 109 165 446 13 122 714 43 329 578 287 915 886 337 913 818 225 647\n2 0 -673" }, { "input": "64\n502 885 -631 -906 735 687 642 -29 -696 -165 -524 15 -129 -663 -846 -501 -651 895 -341 -833 -142 33 -847 688 945 -192 -587 -930 603 849 736 676 788 256 863 -509 319 -49 -807 -158 218 -886 -143 -639 118 -156 -291 325 892 -916 -622 -960 -959 -731 -943 436 -535 861 745 589 -159 376 -182 0", "output": "35 -631 -906 -29 -696 -165 -524 -129 -663 -846 -501 -651 -341 -833 -142 -847 -192 -587 -930 -509 -49 -807 -158 -886 -143 -639 -156 -291 -916 -622 -960 -959 -731 -943 -535 -159\n27 502 885 735 687 642 15 895 33 688 945 603 849 736 676 788 256 863 319 218 118 325 892 436 861 745 589 376\n2 0 -182" }, { "input": "5\n-1 -2 -3 -4 0", "output": "1 -1\n2 -4 -3\n2 0 -2" }, { "input": "3\n-101 101 0", "output": "1 -101\n1 101\n1 0" }, { "input": "21\n-100 -200 -300 -400 -500 -600 -700 -800 -900 -1000 0 100 200 300 400 500 600 700 800 900 1000", "output": "9 -100 -200 -300 -400 -500 -600 -700 -800 -900\n10 100 200 300 400 500 600 700 800 900 1000\n2 0 -1000" }, { "input": "4\n0 -1 -2 -3", "output": "1 -1\n2 -3 -2\n1 0" } ]

1,688,870,013

2,147,483,647

PyPy 3-64

OK

TESTS

20

124

0

n = int(input()) arr = list(map(int, input().split())) nArr = list(filter(lambda x: x < 0, arr)) pArr = list(filter(lambda x: x > 0, arr)) zArr = list(filter(lambda x: x == 0, arr)) if len(nArr) % 2 == 0: val = nArr.pop() zArr.append(val) if len(pArr) == 0: pArr += nArr[:2] nArr = nArr[2:] print(f"{len(nArr)} {' '.join(map(str, nArr))}") print(f"{len(pArr)} {' '.join(map(str, pArr))}") print(f"{len(zArr)} {' '.join(map(str, zArr))}")

Title: Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vitaly has an array of *n* distinct integers. Vitaly wants to divide this array into three non-empty sets so as the following conditions hold: 1. The product of all numbers in the first set is less than zero (<=<<=0). 1. The product of all numbers in the second set is greater than zero (<=><=0). 1. The product of all numbers in the third set is equal to zero. 1. Each number from the initial array must occur in exactly one set. Help Vitaly. Divide the given array. Input Specification: The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=100). The second line contains *n* space-separated distinct integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=103) — the array elements. Output Specification: In the first line print integer *n*1 (*n*1<=><=0) — the number of elements in the first set. Then print *n*1 numbers — the elements that got to the first set. In the next line print integer *n*2 (*n*2<=><=0) — the number of elements in the second set. Then print *n*2 numbers — the elements that got to the second set. In the next line print integer *n*3 (*n*3<=><=0) — the number of elements in the third set. Then print *n*3 numbers — the elements that got to the third set. The printed sets must meet the described conditions. It is guaranteed that the solution exists. If there are several solutions, you are allowed to print any of them. Demo Input: ['3\n-1 2 0\n', '4\n-1 -2 -3 0\n'] Demo Output: ['1 -1\n1 2\n1 0\n', '1 -1\n2 -3 -2\n1 0\n'] Note: none

```python n = int(input()) arr = list(map(int, input().split())) nArr = list(filter(lambda x: x < 0, arr)) pArr = list(filter(lambda x: x > 0, arr)) zArr = list(filter(lambda x: x == 0, arr)) if len(nArr) % 2 == 0: val = nArr.pop() zArr.append(val) if len(pArr) == 0: pArr += nArr[:2] nArr = nArr[2:] print(f"{len(nArr)} {' '.join(map(str, nArr))}") print(f"{len(pArr)} {' '.join(map(str, pArr))}") print(f"{len(zArr)} {' '.join(map(str, zArr))}") ```

3

653

C

Bear and Up-Down

PROGRAMMING

1,900

[ "brute force", "implementation" ]

null

The life goes up and down, just like nice sequences. Sequence *t*1,<=*t*2,<=...,<=*t**n* is called nice if the following two conditions are satisfied: - *t**i*<=<<=*t**i*<=+<=1 for each odd *i*<=<<=*n*; - *t**i*<=><=*t**i*<=+<=1 for each even *i*<=<<=*n*. For example, sequences (2,<=8), (1,<=5,<=1) and (2,<=5,<=1,<=100,<=99,<=120) are nice, while (1,<=1), (1,<=2,<=3) and (2,<=5,<=3,<=2) are not. Bear Limak has a sequence of positive integers *t*1,<=*t*2,<=...,<=*t**n*. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices *i*<=<<=*j* and swap elements *t**i* and *t**j* in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.

The first line of the input contains one integer *n* (2<=≤<=*n*<=≤<=150<=000) — the length of the sequence. The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=150<=000) — the initial sequence. It's guaranteed that the given sequence is not nice.

Print the number of ways to swap two elements exactly once in order to get a nice sequence.

[ "5\n2 8 4 7 7\n", "4\n200 150 100 50\n", "10\n3 2 1 4 1 4 1 4 1 4\n", "9\n1 2 3 4 5 6 7 8 9\n" ]

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

In the first sample, there are two ways to get a nice sequence with one swap: 1. Swap *t*2 = 8 with *t*4 = 7. 1. Swap *t*1 = 2 with *t*5 = 7. In the second sample, there is only one way — Limak should swap *t*1 = 200 with *t*4 = 50.

1,500

[ { "input": "5\n2 8 4 7 7", "output": "2" }, { "input": "4\n200 150 100 50", "output": "1" }, { "input": "10\n3 2 1 4 1 4 1 4 1 4", "output": "8" }, { "input": "9\n1 2 3 4 5 6 7 8 9", "output": "0" }, { "input": "5\n1 1 1 4 3", "output": "1" }, { "input": "10\n7 7 8 10 5 10 1 5 2 6", "output": "2" }, { "input": "50\n11836 28308 72527 92281 139289 93797 134555 148444 40866 111317 21564 87813 65466 20541 99238 2287 74647 128071 18163 61672 39766 55589 138385 147443 138100 142683 60703 15444 52566 72976 147412 116006 115986 110545 79993 100440 9876 71470 75209 62443 64906 88987 72232 2246 63160 45041 729 148611 103397 78474", "output": "0" }, { "input": "10\n522 309 276 454 566 978 175 388 289 276", "output": "0" }, { "input": "20\n8 9 1 10 7 9 5 8 5 7 5 6 1 3 2 7 3 2 6 9", "output": "3" }, { "input": "25\n25 20 58 95 47 68 38 39 24 83 36 68 28 67 25 40 62 99 11 88 74 75 38 90 42", "output": "1" }, { "input": "30\n18647 31594 58075 122543 49766 65303 48728 102863 22542 140297 5300 90685 50141 86948 27074 40214 17945 147095 97758 140835 121469 139920 63817 138623 85609 110002 70046 128002 122139 116109", "output": "1" }, { "input": "39\n18329 39326 21115 36341 3916 40060 23262 41923 17476 42107 17052 23198 10756 32540 14873 28454 23912 35765 9459 45834 85 46756 31859 40087 35420 47585 9781 46544 31859 49453 7394 17459 2816 34051 12519 4077 692 44098 23345", "output": "15" }, { "input": "2\n5 1", "output": "1" }, { "input": "2\n10 10", "output": "0" }, { "input": "6\n1 1 1 2 2 2", "output": "1" }, { "input": "12\n10 15 10 15 10 8 10 15 10 20 30 20", "output": "1" } ]

1,576,117,520

2,147,483,647

Python 3

OK

TESTS

44

1,747

10,854,400

def get_bit(diff, i): return 1 if ((i%2==1 and diff<=0) or (i%2==0 and diff>=0)) else 0 def swap_(i, j, a): temp = a[i] a[i] = a[j] a[j] = temp def swap(i, j, n, a, mask, S): change = 0 swap_(i, j, a) set_index = set([i, j]) if i<n-1: set_index.add(i+1) if j<n-1: set_index.add(j+1) for index in set_index: if index > 0: diff = a[index] - a[index-1] bit_ = get_bit(diff, index) change += bit_ - mask[index] swap_(i, j, a) if S + change == 0: return 1 return 0 n = int(input()) a = list(map(int, input().split())) diff = [-1] + [x-y for x, y in zip(a[1:], a[:-1])] mask = [get_bit(diff[i], i) for i in range(n)] S = sum(mask) first = -1 for i, x in enumerate(mask): if x == 1: first = i break cnt = 0 for second in range(n): if swap(first, second, n, a, mask, S) == 1: cnt += 1 if first != 0 and swap(first-1, second, n, a, mask, S) == 1: cnt += 1 if first!=0 and swap(first-1, first, n, a, mask, S) == 1: cnt-=1 print(cnt) #9 #1 2 3 4 5 6 7 8 9 #10 #3 2 1 4 1 4 1 4 1 4 #4 #200 150 100 50 #5 #2 8 4 7 7

Title: Bear and Up-Down Time Limit: None seconds Memory Limit: None megabytes Problem Description: The life goes up and down, just like nice sequences. Sequence *t*1,<=*t*2,<=...,<=*t**n* is called nice if the following two conditions are satisfied: - *t**i*<=<<=*t**i*<=+<=1 for each odd *i*<=<<=*n*; - *t**i*<=><=*t**i*<=+<=1 for each even *i*<=<<=*n*. For example, sequences (2,<=8), (1,<=5,<=1) and (2,<=5,<=1,<=100,<=99,<=120) are nice, while (1,<=1), (1,<=2,<=3) and (2,<=5,<=3,<=2) are not. Bear Limak has a sequence of positive integers *t*1,<=*t*2,<=...,<=*t**n*. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices *i*<=<<=*j* and swap elements *t**i* and *t**j* in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different. Input Specification: The first line of the input contains one integer *n* (2<=≤<=*n*<=≤<=150<=000) — the length of the sequence. The second line contains *n* integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=150<=000) — the initial sequence. It's guaranteed that the given sequence is not nice. Output Specification: Print the number of ways to swap two elements exactly once in order to get a nice sequence. Demo Input: ['5\n2 8 4 7 7\n', '4\n200 150 100 50\n', '10\n3 2 1 4 1 4 1 4 1 4\n', '9\n1 2 3 4 5 6 7 8 9\n'] Demo Output: ['2\n', '1\n', '8\n', '0\n'] Note: In the first sample, there are two ways to get a nice sequence with one swap: 1. Swap *t*2 = 8 with *t*4 = 7. 1. Swap *t*1 = 2 with *t*5 = 7. In the second sample, there is only one way — Limak should swap *t*1 = 200 with *t*4 = 50.

```python def get_bit(diff, i): return 1 if ((i%2==1 and diff<=0) or (i%2==0 and diff>=0)) else 0 def swap_(i, j, a): temp = a[i] a[i] = a[j] a[j] = temp def swap(i, j, n, a, mask, S): change = 0 swap_(i, j, a) set_index = set([i, j]) if i<n-1: set_index.add(i+1) if j<n-1: set_index.add(j+1) for index in set_index: if index > 0: diff = a[index] - a[index-1] bit_ = get_bit(diff, index) change += bit_ - mask[index] swap_(i, j, a) if S + change == 0: return 1 return 0 n = int(input()) a = list(map(int, input().split())) diff = [-1] + [x-y for x, y in zip(a[1:], a[:-1])] mask = [get_bit(diff[i], i) for i in range(n)] S = sum(mask) first = -1 for i, x in enumerate(mask): if x == 1: first = i break cnt = 0 for second in range(n): if swap(first, second, n, a, mask, S) == 1: cnt += 1 if first != 0 and swap(first-1, second, n, a, mask, S) == 1: cnt += 1 if first!=0 and swap(first-1, first, n, a, mask, S) == 1: cnt-=1 print(cnt) #9 #1 2 3 4 5 6 7 8 9 #10 #3 2 1 4 1 4 1 4 1 4 #4 #200 150 100 50 #5 #2 8 4 7 7 ```

3

732

A

Buy a Shovel

PROGRAMMING

800

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

null

Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop. In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of *r* burles (1<=≤<=*r*<=≤<=9). What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of *r* burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.

The single line of input contains two integers *k* and *r* (1<=≤<=*k*<=≤<=1000, 1<=≤<=*r*<=≤<=9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins". Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.

Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.

[ "117 3\n", "237 7\n", "15 2\n" ]

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

In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change. In the second example it is enough for Polycarp to buy one shovel. In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.

500

[ { "input": "117 3", "output": "9" }, { "input": "237 7", "output": "1" }, { "input": "15 2", "output": "2" }, { "input": "1 1", "output": "1" }, { "input": "1 9", "output": "9" }, { "input": "1000 3", "output": "1" }, { "input": "1000 1", "output": "1" }, { "input": "1000 9", "output": "1" }, { "input": "1 2", "output": "2" }, { "input": "999 9", "output": "1" }, { "input": "999 8", "output": "2" }, { "input": "105 6", "output": "2" }, { "input": "403 9", "output": "3" }, { "input": "546 4", "output": "4" }, { "input": "228 9", "output": "5" }, { "input": "57 2", "output": "6" }, { "input": "437 9", "output": "7" }, { "input": "997 6", "output": "8" }, { "input": "109 1", "output": "9" }, { "input": "998 9", "output": "5" }, { "input": "4 2", "output": "3" }, { "input": "9 3", "output": "7" }, { "input": "8 2", "output": "4" }, { "input": "1 3", "output": "3" }, { "input": "1 4", "output": "4" }, { "input": "1 5", "output": "5" }, { "input": "1 6", "output": "6" }, { "input": "1 7", "output": "7" }, { "input": "1 8", "output": "8" }, { "input": "100 3", "output": "1" }, { "input": "1000 2", "output": "1" }, { "input": "1000 4", "output": "1" }, { "input": "1000 5", "output": "1" }, { "input": "1000 6", "output": "1" }, { "input": "1000 7", "output": "1" }, { "input": "1000 8", "output": "1" }, { "input": "23 4", "output": "8" }, { "input": "33 1", "output": "7" }, { "input": "33 2", "output": "4" }, { "input": "666 5", "output": "5" }, { "input": "2 3", "output": "5" }, { "input": "5 5", "output": "1" }, { "input": "3 6", "output": "2" }, { "input": "12 4", "output": "2" }, { "input": "15 5", "output": "1" }, { "input": "2 5", "output": "5" }, { "input": "25 5", "output": "1" }, { "input": "2 9", "output": "5" }, { "input": "6 7", "output": "5" }, { "input": "8 9", "output": "5" }, { "input": "2 7", "output": "5" }, { "input": "4 7", "output": "5" }, { "input": "2 1", "output": "5" }, { "input": "261 1", "output": "1" } ]

1,683,805,899

2,147,483,647

Python 3

OK

TESTS

54

46

0

k,r=map(int,input().split()) i=1 x=k while i>=1: if k%10==0: print(i) break elif (k-r)%10==0: print(i) break else: i+=1 k=i*x

Title: Buy a Shovel Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for *k* burles. Assume that there is an unlimited number of such shovels in the shop. In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of *r* burles (1<=≤<=*r*<=≤<=9). What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of *r* burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel. Input Specification: The single line of input contains two integers *k* and *r* (1<=≤<=*k*<=≤<=1000, 1<=≤<=*r*<=≤<=9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins". Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels. Output Specification: Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change. Demo Input: ['117 3\n', '237 7\n', '15 2\n'] Demo Output: ['9\n', '1\n', '2\n'] Note: In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change. In the second example it is enough for Polycarp to buy one shovel. In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.

```python k,r=map(int,input().split()) i=1 x=k while i>=1: if k%10==0: print(i) break elif (k-r)%10==0: print(i) break else: i+=1 k=i*x ```

3

120

G

Boom

PROGRAMMING

1,800

[ "implementation" ]

null

Let's consider the famous game called Boom (aka Hat) with simplified rules. There are *n* teams playing the game. Each team has two players. The purpose of the game is to explain the words to the teammate without using any words that contain the same root or that sound similarly. Player *j* from team *i* (1<=≤<=*i*<=≤<=*n*,<=1<=≤<=*j*<=≤<=2) is characterized by two numbers: *a**ij* and *b**ij*. The numbers correspondingly represent the skill of explaining and the skill of understanding this particular player has. Besides, *m* cards are used for the game. Each card has a word written on it. The card number *k* (1<=≤<=*k*<=≤<=*m*) is characterized by number *c**k* — the complexity of the word it contains. Before the game starts the cards are put in a deck and shuffled. Then the teams play in turns like that: the 1-st player of the 1-st team, the 1-st player of the 2-nd team, ... , the 1-st player of the *n*-th team, the 2-nd player of the 1-st team, ... , the 2-nd player of the *n*-th team, the 1-st player of the 1-st team and so on. Each turn continues for *t* seconds. It goes like that: Initially the time for each turn is *t*. While the time left to a player is more than 0, a player takes a card from the top of the deck and starts explaining the word it has to his teammate. The time needed for the *j*-th player of the *i*-th team to explain the word from the card *k* to his teammate (the *q*-th player of the *i*-th team) equals *max*(1,<=*c**k*<=-<=(*a**ij*<=+<=*b**iq*)<=-<=*d**ik*) (if *j*<==<=1,<= then *q*<==<=2,<= else *q*<==<=1). The value *d**ik* is the number of seconds the *i*-th team has already spent explaining the word *k* during the previous turns. Initially, all *d**ik* equal 0. If a team manages to guess the word before the end of the turn, then the time given above is substracted from the duration of the turn, the card containing the guessed word leaves the game, the team wins one point and the game continues. If the team doesn't manage to guess the word, then the card is put at the bottom of the deck, *d**ik* increases on the amount of time of the turn, spent on explaining the word. Thus, when this team gets the very same word, they start explaining it not from the beginning, but from the point where they stopped. The game ends when words from all *m* cards are guessed correctly. You are given *n* teams and a deck of *m* cards. You should determine for each team, how many points it will have by the end of the game and which words the team will have guessed.

The first line contains two integers *n*,<=*t* (1<=≤<=*n*,<=*t*<=≤<=100), which correspondingly denote the number of teams and a turn's duration. Next *n* lines of the input file contain four integers each: *a**i*1,<=*b**i*1,<=*a**i*2,<=*b**i*2 (1<=≤<=*a**ij*,<=*b**ij*<=≤<=100) — the skills of the first and the second player of the *i*-th team. The teams are given in the order in which they play. The next line of the input file contains integer *m* (1<=≤<=*m*<=≤<=100) the number of cards. Next 2*m* lines contain the cards' descriptions. Two lines describe each card. The first line of the description contains the word that consists of no more than 20 characters. The words only contain small Latin letters. The second line of the description contains an integer *c**k* (1<=≤<=*c**k*<=≤<=100) — the complexity of the word written on the *k*-th card. The cards are listed in the order in which the lie in the deck from top to bottom. The words on all cards are different.

Print *n* lines. On the *i*-th line first print number *s**i* the number of points the *i*-th team wins. Then print *s**i* space-separated words — the words from the cards guessed by team *i* in the order in which they were guessed.

[ "2 2\n1 1 1 1\n1 1 1 1\n3\nhome\n1\ncar\n1\nbrother\n1\n", "2 4\n1 2 2 1\n2 3 2 2\n4\narmchair\n3\nquetzalcoatl\n10\npilotage\n5\ndefibrillator\n7\n" ]

[ "2 home car \n1 brother \n", "2 armchair quetzalcoatl \n2 pilotage defibrillator \n" ]

none

0

[ { "input": "2 2\n1 1 1 1\n1 1 1 1\n3\nhome\n1\ncar\n1\nbrother\n1", "output": "2 home car \n1 brother " }, { "input": "2 4\n1 2 2 1\n2 3 2 2\n4\narmchair\n3\nquetzalcoatl\n10\npilotage\n5\ndefibrillator\n7", "output": "2 armchair quetzalcoatl \n2 pilotage defibrillator " }, { "input": "5 10\n7 4 2 1\n3 8 4 3\n10 1 8 2\n1 10 8 1\n7 2 8 5\n20\nawhiwqom\n97\nbupsrkw\n67\ncdcle\n46\ndbw\n20\nhypayjdabm\n96\nigclyxfkshgbhrf\n78\nldcyjtkldc\n73\nmgrdcybqbvor\n49\nnjzddrjxafjrrw\n63\nozucivhhggjtfkbojuqw\n11\nqgzsrwl\n95\nrz\n28\ntperpgd\n66\nvilawpd\n16\nvnujx\n8\nwadgiywkj\n23\nydisqmwtprbiexkxy\n16\nyejvg\n29\nyusivpcoucy\n43\nzdnpcaybyupwnrqjln\n69", "output": "2 ydisqmwtprbiexkxy ldcyjtkldc \n4 dbw tperpgd qgzsrwl awhiwqom \n7 vilawpd vnujx rz mgrdcybqbvor bupsrkw zdnpcaybyupwnrqjln hypayjdabm \n2 cdcle njzddrjxafjrrw \n5 ozucivhhggjtfkbojuqw yejvg wadgiywkj yusivpcoucy igclyxfkshgbhrf " }, { "input": "5 10\n10 10 5 1\n7 2 1 3\n1 9 6 10\n9 9 8 2\n9 7 3 3\n20\nau\n9\nazyqnadfkgan\n40\nbljzegoaovxjpmgu\n42\ncoetohydzgsgcobutdis\n60\nd\n29\ndbly\n72\nejfg\n65\ng\n61\ngegfsmb\n77\ngfchnfbrmgzhka\n92\nhigitegymghcm\n59\nipnaqundvzjnth\n32\nlxwjjupqyeovetkxp\n5\nmdzdmjffnijjaxumayvf\n44\notxrsihubv\n4\np\n38\nubelpi\n80\nvrvsyanbzf\n56\nwultlskyakufgynixzu\n98\nyyionxuvc\n10", "output": "6 au azyqnadfkgan mdzdmjffnijjaxumayvf ejfg vrvsyanbzf ubelpi \n4 lxwjjupqyeovetkxp yyionxuvc p wultlskyakufgynixzu \n4 otxrsihubv ipnaqundvzjnth gegfsmb gfchnfbrmgzhka \n3 d coetohydzgsgcobutdis g \n3 bljzegoaovxjpmgu higitegymghcm dbly " }, { "input": "5 10\n6 8 9 1\n1 7 6 4\n10 8 3 7\n6 9 8 10\n1 9 9 9\n20\nabbugflflinrioxgvl\n14\nafpwenhqgfwser\n75\nakpiohdcrquscdxil\n82\ncpppzkllbjjwqaao\n40\neah\n36\nem\n5\neotdkpityyxejgxuqk\n6\nevowzppqdmiyjds\n40\nfifdbjdtoespushpex\n54\njibx\n54\nmhcldvkm\n51\nmyozdrlz\n87\nsfxdpyunksqixgvrgpye\n49\ntymtutmayttwhbdt\n65\nu\n37\nujncufz\n46\nuohkmteallop\n12\nwug\n29\nykgzkwsrfls\n54\nzm\n58", "output": "4 abbugflflinrioxgvl u ujncufz jibx \n1 akpiohdcrquscdxil \n3 cpppzkllbjjwqaao mhcldvkm myozdrlz \n7 uohkmteallop eah wug sfxdpyunksqixgvrgpye fifdbjdtoespushpex zm afpwenhqgfwser \n5 em eotdkpityyxejgxuqk evowzppqdmiyjds tymtutmayttwhbdt ykgzkwsrfls " }, { "input": "5 10\n20 6 16 6\n2 10 13 19\n15 11 1 4\n15 3 12 6\n6 7 19 5\n20\nandzzevyyejsla\n20\nbkaljsdgrbqbpoqapknb\n74\nbkuvgjx\n79\nce\n34\neasgyfwgxfegtqx\n73\necjhpqjvuqtltcyd\n59\nganmza\n85\ngh\n100\ngmoimkqhbaprgvksati\n95\nimgugcpeqgtnjbw\n55\ninrehyoipugj\n90\njbhvbvgcmfyv\n96\nlrzxlgznwhrtkjlg\n75\npgxbtjjstynucdxwodwx\n36\npyvjrrc\n35\nqhrjljx\n32\nthdzwf\n59\nvacd\n6\nwgzmzmmyo\n25\nydayfmhgesnwmysmslnm\n34", "output": "6 andzzevyyejsla thdzwf ecjhpqjvuqtltcyd ganmza bkaljsdgrbqbpoqapknb jbhvbvgcmfyv \n5 vacd wgzmzmmyo ydayfmhgesnwmysmslnm lrzxlgznwhrtkjlg gh \n3 pgxbtjjstynucdxwodwx bkuvgjx gmoimkqhbaprgvksati \n2 imgugcpeqgtnjbw easgyfwgxfegtqx \n4 ce pyvjrrc qhrjljx inrehyoipugj " }, { "input": "5 10\n8 1 5 14\n17 5 16 14\n9 4 2 8\n1 12 10 10\n7 20 8 12\n20\narkeegnvzxwkmhttig\n95\nbxvjixvhrwtddesip\n60\nddoyeyftpsfdburf\n64\ne\n62\ni\n11\nkcmkkzacal\n100\nlwzeutqojfoakzr\n7\nmgylauhh\n60\notsee\n54\noymxmaqf\n2\npw\n84\nqbrguhfgswdiqdd\n84\nrlujthwavumoio\n57\nsejtaiujdmpykwmsblhw\n29\ntgiwytlml\n75\ntkcqescgluggpn\n47\nuchk\n79\nuvmwnjpj\n78\nxugnf\n1\nyvuyle\n55", "output": "4 lwzeutqojfoakzr sejtaiujdmpykwmsblhw tkcqescgluggpn mgylauhh \n4 bxvjixvhrwtddesip otsee uchk qbrguhfgswdiqdd \n3 oymxmaqf ddoyeyftpsfdburf tgiwytlml \n2 e arkeegnvzxwkmhttig \n7 i xugnf rlujthwavumoio yvuyle kcmkkzacal pw uvmwnjpj " }, { "input": "5 10\n15 4 15 14\n13 8 6 17\n11 17 2 1\n7 13 8 15\n7 6 17 20\n20\naaqiqonqh\n38\nakonztimlx\n99\ndplqs\n20\neadliyjzqrmpusux\n49\nfferd\n44\ngpvogqvfg\n31\nh\n69\niagxaacjqrdfyqhalqip\n25\niuylompdxxro\n82\njaoesfe\n72\nkqqgigyuncqoxh\n27\nkrcmediuiholmtefnhjj\n32\nlrwjbttlzdxvvzcmhjg\n98\npijippred\n45\npyvamvpwllojbnqowxi\n2\nqahpgw\n63\nrbyvangmxes\n17\nsezugolsnnuxibunzt\n13\nvbcvglvndzdskks\n63\nym\n7", "output": "4 aaqiqonqh pyvamvpwllojbnqowxi pijippred akonztimlx \n6 dplqs rbyvangmxes sezugolsnnuxibunzt eadliyjzqrmpusux h iuylompdxxro \n2 ym jaoesfe \n3 gpvogqvfg kqqgigyuncqoxh lrwjbttlzdxvvzcmhjg \n5 iagxaacjqrdfyqhalqip krcmediuiholmtefnhjj fferd vbcvglvndzdskks qahpgw " }, { "input": "5 10\n2 8 13 14\n9 3 9 11\n14 3 11 6\n13 2 7 8\n19 12 6 7\n20\nbociyuihqsycazxbui\n4\ncpmele\n66\nengvnnjisqaavzfxfd\n27\nexh\n29\nfdfsvmiit\n53\nikzcj\n8\nkhsiqelk\n78\nkztgoyoyvhsmvgel\n35\nmebxvlhzjcszgsjpibw\n56\novxakwrtpyybp\n49\nozsoefwgaztswtwb\n3\npaojwscogjvogeyzwe\n15\nphdbcnfuqeskauygu\n55\nrds\n51\nshastxtximm\n62\nssenuaqqxvhdqgeayrir\n57\nvcelxizohyfjrzxalhcv\n59\nyisnkcedfkk\n45\nzcknnzdruemywcbndzp\n64\nzpw\n90", "output": "7 bociyuihqsycazxbui exh ovxakwrtpyybp yisnkcedfkk mebxvlhzjcszgsjpibw cpmele zpw \n5 engvnnjisqaavzfxfd ozsoefwgaztswtwb paojwscogjvogeyzwe rds phdbcnfuqeskauygu \n2 ssenuaqqxvhdqgeayrir shastxtximm \n2 ikzcj khsiqelk \n4 kztgoyoyvhsmvgel fdfsvmiit vcelxizohyfjrzxalhcv zcknnzdruemywcbndzp " }, { "input": "5 10\n8 19 18 11\n2 16 9 12\n9 1 20 5\n1 7 15 9\n8 3 13 10\n20\na\n89\nadzyvfy\n87\naoybveo\n3\nbgydqvpv\n64\nbsfap\n35\nezdrupaqno\n32\nip\n39\nipcgzrz\n21\njvejeogiwk\n12\nlas\n19\nlsasbtvbmw\n20\nltnqvtsrsxplcrvbou\n4\nmcokeatvdjvv\n26\nmcycqkq\n83\npdesmpuapplpxbpjoo\n49\nslokvekutpxfvadwfl\n61\nwwocjxemijrdmbje\n97\nymbijnafcxp\n97\nzjffmxjuolyoqnob\n18\nzuylsraoahtcncl\n43", "output": "15 ip ipcgzrz jvejeogiwk las lsasbtvbmw ltnqvtsrsxplcrvbou mcokeatvdjvv zjffmxjuolyoqnob ezdrupaqno zuylsraoahtcncl pdesmpuapplpxbpjoo slokvekutpxfvadwfl bgydqvpv mcycqkq a \n1 wwocjxemijrdmbje \n2 aoybveo ymbijnafcxp \n0 \n2 bsfap adzyvfy " }, { "input": "5 10\n94 46 74 76\n98 78 62 64\n7 94 44 18\n95 18 40 52\n76 94 74 83\n20\nai\n61\nakwvpfyuovffgzmiwij\n34\ndkqpsirmrlrwlgmez\n78\ndtmpwtuiumzvgt\n18\neryegapeqgtsxrbg\n98\ngoaoldmikasvae\n6\njvmbaidtwcubkxbj\n100\nnupdjdwii\n89\nougt\n59\npqqwvnmexqiahhmhxzv\n65\npzogwycbtnns\n100\nqglmnq\n100\nrikefhitquizqzcisw\n21\nrpivyqjbycahluq\n18\nt\n3\ntpzvlmu\n66\nvcjlejgt\n48\nwkish\n56\nyjeistoxf\n28\nzwiyyokxcfnsaeqb\n30", "output": "10 ai akwvpfyuovffgzmiwij dkqpsirmrlrwlgmez dtmpwtuiumzvgt eryegapeqgtsxrbg goaoldmikasvae jvmbaidtwcubkxbj nupdjdwii ougt pqqwvnmexqiahhmhxzv \n10 pzogwycbtnns qglmnq rikefhitquizqzcisw rpivyqjbycahluq t tpzvlmu vcjlejgt wkish yjeistoxf zwiyyokxcfnsaeqb \n0 \n0 \n0 " }, { "input": "5 10\n49 18 18 52\n26 77 12 43\n21 82 70 77\n49 1 50 90\n73 31 68 46\n20\nagwxdzcn\n56\namhreihencdrvgp\n93\nbdfofyqlgi\n59\ncpbaknolumygqniuwbe\n7\ndzdtqmtdnipwdamwln\n61\netmigbmyujysw\n6\ngrxhwyd\n67\njfsfuuppzomdsfmnyzll\n65\nldgvplfitficghxluyl\n53\nowgatyzyqndkdetwz\n87\nqbbrtprovvitokrpitfr\n76\nqdeknxkanbwrbqcixolg\n86\nrqbrba\n86\nsdwyovjg\n97\nskncaygbfwsolymu\n89\nukufa\n42\nuydvdsyaqevwwg\n25\nwjkhjtevg\n32\nyyfnmzhqi\n69\nzek\n20", "output": "10 agwxdzcn amhreihencdrvgp bdfofyqlgi cpbaknolumygqniuwbe dzdtqmtdnipwdamwln etmigbmyujysw grxhwyd jfsfuuppzomdsfmnyzll ldgvplfitficghxluyl owgatyzyqndkdetwz \n1 qbbrtprovvitokrpitfr \n9 rqbrba sdwyovjg skncaygbfwsolymu ukufa uydvdsyaqevwwg wjkhjtevg yyfnmzhqi zek qdeknxkanbwrbqcixolg \n0 \n0 " }, { "input": "5 10\n57 90 62 27\n5 75 62 69\n87 23 48 36\n2 32 60 80\n69 16 13 56\n20\nbhmbverlrtgvx\n52\ndnhosobck\n99\nhlznhilcvdnr\n92\nizbjynytcgrbpqnqhp\n75\njaifakkvnlr\n37\njrbtxkbobtosuaud\n15\nkv\n98\nli\n75\nmilllkprtl\n94\nnhdrfrl\n90\nnlphcovhnfnfumapkbm\n49\nnuhnsdlhumwvs\n21\nnuwhuubonagwpmmm\n28\npirifeguyqen\n25\nsspdbzm\n68\nstzuhm\n71\ntdfltomloxwlphacktyg\n47\ntixhw\n15\nvhuerqvvrjhnc\n50\nvjrrozumn\n31", "output": "1 bhmbverlrtgvx \n0 \n10 izbjynytcgrbpqnqhp jaifakkvnlr jrbtxkbobtosuaud kv li milllkprtl nhdrfrl nlphcovhnfnfumapkbm nuhnsdlhumwvs nuwhuubonagwpmmm \n7 pirifeguyqen sspdbzm stzuhm tdfltomloxwlphacktyg tixhw vhuerqvvrjhnc vjrrozumn \n2 hlznhilcvdnr dnhosobck " }, { "input": "5 10\n12 9 6 3\n33 73 12 95\n1 11 74 96\n55 15 71 18\n66 1 6 67\n20\najswnebgqqqbjxmkdheo\n58\narc\n99\nartszhohkioftbczj\n100\nczrmrqxj\n45\nduheezasxssdlf\n99\neayvzrnfzxsdvbkhak\n20\nebegtvr\n66\ngwklmtrccwkll\n73\nirt\n81\njodtdtvupsqg\n93\nn\n53\nouptrwdjlh\n79\npckhvvk\n48\nrkosjzej\n94\ntbqaulkrgudsmnwuohsy\n53\nvlhygzjqiosd\n47\nvsizzuritvag\n80\nxyigmazkcb\n45\nyg\n6\nz\n43", "output": "0 \n10 arc artszhohkioftbczj czrmrqxj duheezasxssdlf eayvzrnfzxsdvbkhak ebegtvr gwklmtrccwkll irt jodtdtvupsqg n \n10 ouptrwdjlh pckhvvk rkosjzej tbqaulkrgudsmnwuohsy vlhygzjqiosd vsizzuritvag xyigmazkcb yg z ajswnebgqqqbjxmkdheo \n0 \n0 " }, { "input": "5 10\n20 81 50 31\n13 72 62 21\n16 100 52 55\n61 98 81 57\n63 86 99 30\n20\nacujkdmfpuaplztwjvf\n52\naukaptogrrs\n89\nbvigwerojcsnwkyc\n50\nbwkcfuxdvlbqoi\n90\nbxajnylvt\n28\ndgzcyqcydlusjuxggz\n79\ndwoknsorfijnwvqfurx\n45\ndxczy\n45\nezydesaaojxxgpx\n98\njuyl\n61\nk\n35\nmwzvcim\n9\nqutttclwzcpyooq\n65\nqvntkgapdfms\n58\nqxcsubefyvn\n55\nsjycfizpxtzpfzo\n44\ntjzaazdgmtveqsh\n77\nucywuorbapn\n78\nuyibtcpkmscfyxoidx\n43\nwfc\n2", "output": "1 acujkdmfpuaplztwjvf \n0 \n0 \n10 bxajnylvt dgzcyqcydlusjuxggz dwoknsorfijnwvqfurx dxczy ezydesaaojxxgpx juyl k mwzvcim qutttclwzcpyooq qvntkgapdfms \n9 qxcsubefyvn sjycfizpxtzpfzo tjzaazdgmtveqsh ucywuorbapn uyibtcpkmscfyxoidx wfc aukaptogrrs bvigwerojcsnwkyc bwkcfuxdvlbqoi " }, { "input": "5 50\n10 8 3 3\n2 4 6 2\n2 8 7 5\n3 10 9 10\n10 8 9 6\n20\namfenzyhouqyb\n28\nau\n83\nf\n20\nk\n31\nkcqpzf\n70\nlpnwt\n60\nmciyhhqhzcux\n6\nnkxlqseszxqsecitby\n17\nnvgdtvgptbdkae\n65\npzhsbcfvtzsb\n63\nrauqfn\n93\nsdhbzvpprmkngh\n95\nsoz\n41\nswn\n20\ntjjtrbhvctmcuwipc\n97\ntmntkzwqguzpurixss\n24\nurgi\n71\nvyzu\n45\nxwxvnbkgovrvdaz\n34\nyqsuqsw\n95", "output": "4 amfenzyhouqyb lpnwt urgi yqsuqsw \n4 f k soz swn \n1 tmntkzwqguzpurixss \n9 mciyhhqhzcux nkxlqseszxqsecitby vyzu xwxvnbkgovrvdaz nvgdtvgptbdkae rauqfn au kcqpzf tjjtrbhvctmcuwipc \n2 pzhsbcfvtzsb sdhbzvpprmkngh " }, { "input": "5 50\n2 5 1 10\n8 1 2 9\n6 1 10 7\n5 5 5 6\n8 7 6 3\n20\na\n61\nanwfhdzbroapky\n43\naqs\n6\nasyrerlvmedr\n27\nbydnewaighdz\n35\ndfcolvmynxggqotjebus\n40\neoihqup\n82\nepjb\n55\nhndfoylj\n10\nlcd\n39\nlthdbhinxmjodeycotbw\n36\npktluolmnfpxtha\n65\nqubalanyjrs\n9\nrkybaxglies\n49\nsqhwsohkckgwlvzose\n48\ntxzt\n64\nxqxebvboqef\n96\nxtgrawwn\n91\nykjadz\n74\nzo\n61", "output": "5 a qubalanyjrs rkybaxglies zo xtgrawwn \n5 aqs asyrerlvmedr bydnewaighdz dfcolvmynxggqotjebus eoihqup \n4 lcd anwfhdzbroapky ykjadz xqxebvboqef \n3 epjb hndfoylj sqhwsohkckgwlvzose \n3 lthdbhinxmjodeycotbw pktluolmnfpxtha txzt " }, { "input": "5 50\n5 4 8 5\n3 8 5 6\n9 5 2 10\n9 9 9 1\n3 4 1 10\n20\nancdcwlv\n31\nbcwvki\n51\nbmwmpfdzdbvltxqda\n39\nccwojdhjqzw\n23\ndpkeuxvzne\n37\ndrtehqk\n47\nfili\n80\ngirpbsdjwftwlylnaw\n84\ngnjs\n69\nj\n77\njuawwnr\n42\nmsorjozptebsnc\n14\nplmociostnusoyjcb\n68\nrvajwvzggnyqeptnpru\n90\ntmakmmcatbortnzohgz\n18\nwiyvtgmrjb\n84\nxchosuozgyolons\n46\nyigrbslff\n49\nysm\n77\nzzuzjydmlkjhjggk\n30", "output": "3 ancdcwlv gnjs j \n6 bmwmpfdzdbvltxqda ccwojdhjqzw juawwnr msorjozptebsnc zzuzjydmlkjhjggk rvajwvzggnyqeptnpru \n4 drtehqk dpkeuxvzne plmociostnusoyjcb fili \n5 tmakmmcatbortnzohgz girpbsdjwftwlylnaw yigrbslff wiyvtgmrjb ysm \n2 xchosuozgyolons bcwvki " }, { "input": "5 50\n8 3 7 10\n1 5 1 3\n3 8 3 2\n3 6 3 5\n1 1 6 7\n20\napppvvfctrygtlak\n89\nawrdgntimvwgrsogwyh\n84\nbagkyaojjvyrozaitziq\n44\nbalolgsdsiqh\n77\neuhcsj\n25\ngioscscimj\n32\njnzbl\n77\nlmlomhusnkxaqgng\n81\nofusonyqpwlpcfbaha\n57\np\n20\nqgvhqdhrnzgfkmaisr\n98\nrkljm\n86\ntljevehfr\n91\ntlynkqdk\n95\ntznddgxugv\n26\nvtsiqbjowume\n62\nwd\n81\nwobwxcqjgmsjp\n80\nytxmdaoztkgtci\n4\nzv\n98", "output": "5 ofusonyqpwlpcfbaha tznddgxugv apppvvfctrygtlak awrdgntimvwgrsogwyh zv \n3 balolgsdsiqh jnzbl wobwxcqjgmsjp \n3 bagkyaojjvyrozaitziq qgvhqdhrnzgfkmaisr tlynkqdk \n6 euhcsj gioscscimj ytxmdaoztkgtci tljevehfr lmlomhusnkxaqgng rkljm \n3 p vtsiqbjowume wd " }, { "input": "5 50\n6 10 1 10\n8 1 2 5\n3 7 5 4\n9 6 7 2\n8 2 5 5\n20\nbdxhtiyvnidncbxm\n62\ncew\n9\ndkuzi\n58\ndyklulpdxpyk\n27\ng\n62\nh\n31\nhw\n1\nizhcoyxnau\n42\njpmnpruqwrntnimlatc\n17\njrdirm\n41\nkfyfybhrjjvbhqy\n3\nmlrfzcmjtmumtsrtr\n75\nnonzf\n7\npekcqqqueqvdcgdkfvq\n10\nq\n99\nujfyhulrvbwpmtjfdix\n77\numfyhgfhbqsbhi\n59\nvyztrqkbjxksx\n93\nwhiecyszn\n15\nxlryjtewrmadscw\n34", "output": "4 bdxhtiyvnidncbxm cew izhcoyxnau mlrfzcmjtmumtsrtr \n3 dyklulpdxpyk ujfyhulrvbwpmtjfdix q \n3 h hw vyztrqkbjxksx \n6 jpmnpruqwrntnimlatc jrdirm kfyfybhrjjvbhqy whiecyszn xlryjtewrmadscw umfyhgfhbqsbhi \n4 nonzf pekcqqqueqvdcgdkfvq dkuzi g " }, { "input": "5 50\n20 9 4 15\n11 7 20 19\n10 12 16 20\n12 16 8 8\n8 8 17 20\n20\naiddcowxna\n3\nalxnogcbowinrdkjwzce\n83\naytwtj\n21\nekfan\n49\neleyngyfyegsndt\n64\nfv\n38\ng\n14\nhmpezcyerp\n10\nilfwwnksg\n88\nkvheokhedoxehezog\n83\nmirkhoxpdfjbmadom\n71\nmng\n23\nnjwxhcilaipojnjxgop\n48\nspieiz\n2\nszu\n34\nvicqplxewimms\n33\nwfxaniwrzfgcqoynp\n10\nx\n38\nysbxs\n77\nyxajhu\n60", "output": "10 aiddcowxna alxnogcbowinrdkjwzce aytwtj spieiz szu vicqplxewimms wfxaniwrzfgcqoynp njwxhcilaipojnjxgop x eleyngyfyegsndt \n2 ekfan ysbxs \n5 fv g hmpezcyerp yxajhu ilfwwnksg \n1 kvheokhedoxehezog \n2 mirkhoxpdfjbmadom mng " }, { "input": "5 50\n5 3 16 3\n11 20 16 13\n17 11 20 8\n15 15 5 13\n12 12 17 3\n20\nbavp\n62\nca\n23\nezfsjtk\n83\nhwhjlqkttxphrwcgeigl\n40\njmoubzudsvgjaspum\n8\njpdlz\n18\nkgkcfspxyktf\n13\nkgpasabhelruzxv\n12\nkvoxay\n60\nkwijsxgrvgg\n56\nmrtxzpwcamqotjdk\n18\noiehvcwvrvrjuxogml\n51\nsrqdbqvcaditbahljz\n27\ntjxqhmsynadmy\n60\nuhrvobtjdlmrqrsb\n90\nvf\n19\nvlnysf\n81\nwtnhlty\n61\nxbgunpa\n76\nzichtmwnxnlgo\n61", "output": "2 zichtmwnxnlgo tjxqhmsynadmy \n4 ca vf vlnysf uhrvobtjdlmrqrsb \n7 hwhjlqkttxphrwcgeigl jmoubzudsvgjaspum jpdlz kgkcfspxyktf kgpasabhelruzxv xbgunpa wtnhlty \n5 kwijsxgrvgg mrtxzpwcamqotjdk bavp ezfsjtk oiehvcwvrvrjuxogml \n2 srqdbqvcaditbahljz kvoxay " }, { "input": "5 50\n19 8 7 10\n12 13 19 15\n12 17 11 5\n19 1 10 18\n16 16 5 5\n20\nbztasxrdqjohdni\n64\ndwovblrsrpwchcouuckh\n30\nfadnywcwok\n26\nghaebyrzwaevmvzhnb\n17\ngvfuraokmbpbnpfldleh\n71\nhozprpseuoikckbim\n72\nihkgm\n64\njnfppsvdrdzfrjdzzgl\n58\nknqiqkmwp\n21\nmdvirneqphzt\n36\nnpirgxvvfqfomkzv\n93\nqqgxywhwlhswcf\n80\ntzpiiekollt\n3\nudlesioaorijvvkrwo\n29\nugccemcppztewzfzdo\n90\nutfqciwvumhjebkceigu\n15\nv\n64\nwdjmzytgzcfi\n96\nwnilntitqcedelw\n20\nz\n71", "output": "6 bztasxrdqjohdni dwovblrsrpwchcouuckh fadnywcwok ghaebyrzwaevmvzhnb tzpiiekollt udlesioaorijvvkrwo \n4 hozprpseuoikckbim utfqciwvumhjebkceigu v qqgxywhwlhswcf \n5 jnfppsvdrdzfrjdzzgl knqiqkmwp wnilntitqcedelw z wdjmzytgzcfi \n3 gvfuraokmbpbnpfldleh ihkgm npirgxvvfqfomkzv \n2 mdvirneqphzt ugccemcppztewzfzdo " }, { "input": "5 50\n4 1 19 18\n13 6 3 8\n20 16 15 13\n2 20 7 3\n1 19 6 7\n20\nai\n61\nbvqwbmqdaubogayvw\n51\ncauhidgjapnqg\n69\ncsjtakwufxljc\n79\nghxfrjjtcatau\n13\nhhtwyffedlxugfa\n9\nhyhuiaytkywdwbvaegca\n84\nisbaua\n54\nmbzixjlhinlaqmicsc\n12\nmekhaolgybapknwaqvlb\n71\nmzyhickr\n61\nomhezs\n12\npkbizfxxoyflsnnz\n14\nrldwhrl\n64\nryfuclrvcxmunzsof\n73\nsycuncfzjgxedqisikbs\n36\nv\n20\nxbdqi\n45\nxpwcg\n8\nzdbztlgroj\n40", "output": "6 ai mzyhickr omhezs pkbizfxxoyflsnnz mbzixjlhinlaqmicsc mekhaolgybapknwaqvlb \n3 cauhidgjapnqg rldwhrl ryfuclrvcxmunzsof \n10 ghxfrjjtcatau hhtwyffedlxugfa sycuncfzjgxedqisikbs v xbdqi xpwcg zdbztlgroj bvqwbmqdaubogayvw hyhuiaytkywdwbvaegca csjtakwufxljc \n1 isbaua \n0 " }, { "input": "5 50\n10 7 19 5\n14 19 6 2\n15 14 7 1\n18 19 4 7\n5 3 6 17\n20\nanjanquhtpmvxjlls\n15\napbqgw\n89\nbbdb\n56\negwbywecktqi\n15\nfmdt\n18\nhoeaqpuhnpdoay\n72\njfotd\n70\nlfnjpaml\n77\nmbnrhgptxwrzuc\n6\npdxylbogsx\n50\nrvnucqxntanzthxftf\n1\nshzurowgelywkvgo\n86\nsja\n53\nslxiuocwj\n35\ntoeumedszamrwgi\n77\ntyqulaygk\n15\nwjrzov\n10\nwpgouiakamdet\n76\nzhn\n63\nzipa\n40", "output": "6 anjanquhtpmvxjlls sja slxiuocwj zipa apbqgw toeumedszamrwgi \n7 bbdb egwbywecktqi fmdt tyqulaygk wjrzov jfotd lfnjpaml \n1 zhn \n0 \n6 mbnrhgptxwrzuc pdxylbogsx rvnucqxntanzthxftf hoeaqpuhnpdoay wpgouiakamdet shzurowgelywkvgo " }, { "input": "5 50\n59 19 4 25\n43 84 20 78\n100 34 83 95\n70 68 54 69\n79 3 64 13\n20\nageyekyeotphxor\n66\nahivvgoxeinupvjjmna\n25\ncdhrvlw\n93\nepihzzwa\n37\ngqv\n48\ngwqdctxjqqaa\n51\nktelqfyr\n35\nnicuhosl\n7\npggqv\n49\nqssfunopqcpapwtlszo\n4\nrndbqbrbbvjsxyn\n51\nslbmbuaj\n62\nt\n58\ntkozezypszfeha\n68\nuodsxhlpilvxjb\n52\nwmlpngngl\n50\nxduistxka\n35\nyjhcjqm\n84\nypefmbnrzdkhwi\n90\nztuyqfldahhb\n12", "output": "20 ageyekyeotphxor ahivvgoxeinupvjjmna cdhrvlw epihzzwa gqv gwqdctxjqqaa ktelqfyr nicuhosl pggqv qssfunopqcpapwtlszo rndbqbrbbvjsxyn slbmbuaj t tkozezypszfeha uodsxhlpilvxjb wmlpngngl xduistxka yjhcjqm ypefmbnrzdkhwi ztuyqfldahhb \n0 \n0 \n0 \n0 " }, { "input": "5 50\n46 66 37 1\n21 48 55 59\n54 91 44 25\n70 30 62 58\n38 72 71 78\n20\naewcafbvegypxtohswql\n49\nbpgmyiv\n78\nchbfvhlvwjvgtaxp\n3\neozeghdjcvhofzmefe\n20\ngv\n66\niaixcggahrxeu\n29\niruluvirbwthphzhvit\n40\niuyjteocfyqgoxds\n64\nkimnqo\n72\nlsclcjc\n56\nlxqjghfdakxekxub\n93\nm\n78\nobg\n4\noeizzjxfxz\n90\nplamvbets\n33\nrfdrljdolmytuc\n11\ntsetdq\n35\nwqcpsi\n60\nz\n83\nznxinpggugojxmsxqcwz\n25", "output": "4 aewcafbvegypxtohswql bpgmyiv chbfvhlvwjvgtaxp eozeghdjcvhofzmefe \n16 iaixcggahrxeu iruluvirbwthphzhvit iuyjteocfyqgoxds kimnqo lsclcjc lxqjghfdakxekxub m obg oeizzjxfxz plamvbets rfdrljdolmytuc tsetdq wqcpsi z znxinpggugojxmsxqcwz gv \n0 \n0 \n0 " }, { "input": "5 50\n82 62 70 78\n98 13 90 40\n59 97 6 54\n71 92 17 95\n97 41 78 90\n20\ncgautxwtmlabznreq\n70\ncvkauepojwpjefa\n12\ndiprexliwld\n65\nficct\n98\ngrdtqyribdzbdiff\n25\ngsdsiibnae\n24\nhjgfnglgipzhqga\n8\njqvgsd\n97\nkyhisgyaemjfmrfsgrgv\n4\nlfh\n35\nmmsudyzdczaq\n90\nn\n4\nodlomhgwzsscl\n27\nojuvlqpnvuorcm\n65\npldvzhx\n46\nqukyrrnohsovufck\n33\nswcchorziuixlppbvv\n84\ntyxjoljgg\n10\nylngxglaknqsmkmjibms\n88\nzujjnypzonnznuaqr\n37", "output": "20 cgautxwtmlabznreq cvkauepojwpjefa diprexliwld ficct grdtqyribdzbdiff gsdsiibnae hjgfnglgipzhqga jqvgsd kyhisgyaemjfmrfsgrgv lfh mmsudyzdczaq n odlomhgwzsscl ojuvlqpnvuorcm pldvzhx qukyrrnohsovufck swcchorziuixlppbvv tyxjoljgg ylngxglaknqsmkmjibms zujjnypzonnznuaqr \n0 \n0 \n0 \n0 " }, { "input": "5 50\n69 9 2 54\n76 77 26 21\n12 54 16 83\n23 53 73 84\n4 10 33 3\n20\nbmnxihdetiqy\n75\ndhmdlcbnkpokanszze\n26\nemc\n87\nfdctpnpzcf\n3\nfqngmlfbk\n53\ngdm\n87\nhbvgtopviqequtuzewm\n17\nhlvtavljzxsgxjyt\n57\njkpdwxthqedkyog\n79\njpoytysgjmwp\n27\nlcgekveeecbeeybsh\n72\nnuokijkionqdm\n33\nqezequdandvc\n38\nqykpwytljsspdjy\n40\nrkvykuxpyeagjshj\n75\nslysoumltgtrcqgy\n30\nthfdjdps\n37\nurkekqnwdg\n38\nvgmecwqzarqdnfr\n8\nwxbhydmyb\n54", "output": "20 bmnxihdetiqy dhmdlcbnkpokanszze emc fdctpnpzcf fqngmlfbk gdm hbvgtopviqequtuzewm hlvtavljzxsgxjyt jkpdwxthqedkyog jpoytysgjmwp lcgekveeecbeeybsh nuokijkionqdm qezequdandvc qykpwytljsspdjy rkvykuxpyeagjshj slysoumltgtrcqgy thfdjdps urkekqnwdg vgmecwqzarqdnfr wxbhydmyb \n0 \n0 \n0 \n0 " }, { "input": "5 50\n59 9 99 28\n98 25 1 73\n100 26 15 42\n94 6 74 70\n80 16 98 34\n20\nayhoayordvvtkc\n40\nch\n74\neryetue\n59\ngahetf\n21\nhjvhzybokveeaxflj\n78\njtldpiukiqdfmnwm\n76\nk\n64\nkpxfebgk\n40\nom\n51\notmqusdzhuoyeavdsvk\n59\novbphkivfjvpgxhj\n77\npgiyswfmsu\n27\npiaqhupfusebwv\n4\nqfcbmlksbfcpynnvzxne\n92\nqldrufcidocofac\n24\nrinavovgihwtb\n55\nsghpkh\n74\nsjdsknqytq\n65\nwpubtyezskqswm\n33\nzwmgzpdmgzktgdmgqj\n37", "output": "20 ayhoayordvvtkc ch eryetue gahetf hjvhzybokveeaxflj jtldpiukiqdfmnwm k kpxfebgk om otmqusdzhuoyeavdsvk ovbphkivfjvpgxhj pgiyswfmsu piaqhupfusebwv qfcbmlksbfcpynnvzxne qldrufcidocofac rinavovgihwtb sghpkh sjdsknqytq wpubtyezskqswm zwmgzpdmgzktgdmgqj \n0 \n0 \n0 \n0 " } ]

1,623,836,854

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

3

184

409,600

import sys from collections import deque sys.stdin = open('input.txt', 'r') sys.stdout = open('output.txt', 'w') n, t = [int(x) for x in input().split()] teams = [] for i in range(n): a1, b1, a2, b2 = [int(x) for x in input().split()] teams.append((a1 + b2, a2 + b1)) m = int(input()) words = [] c = [] deck = deque() for i in range(m): words.append(input()) c.append(int(input())) deck.append(i) cur_team = 0 cur_player = 0 guessed = [[] for _ in range(n)] cur_time = t d = [[0] * m for _ in range(n)] while len(deck) > 0: card = deck.popleft() time = max(1, c[card] - teams[cur_team][cur_player] - d[cur_team][card]) if cur_time >= time: guessed[cur_team].append(card) cur_time -= time else: d[cur_team][card] += cur_time cur_team += 1 if cur_team == n: cur_team = 0 cur_player = 1 - cur_player cur_time = t deck.append(card) for i in range(n): print(len(guessed[i]), *map(lambda x: words[x], guessed[i]))

Title: Boom Time Limit: None seconds Memory Limit: None megabytes Problem Description: Let's consider the famous game called Boom (aka Hat) with simplified rules. There are *n* teams playing the game. Each team has two players. The purpose of the game is to explain the words to the teammate without using any words that contain the same root or that sound similarly. Player *j* from team *i* (1<=≤<=*i*<=≤<=*n*,<=1<=≤<=*j*<=≤<=2) is characterized by two numbers: *a**ij* and *b**ij*. The numbers correspondingly represent the skill of explaining and the skill of understanding this particular player has. Besides, *m* cards are used for the game. Each card has a word written on it. The card number *k* (1<=≤<=*k*<=≤<=*m*) is characterized by number *c**k* — the complexity of the word it contains. Before the game starts the cards are put in a deck and shuffled. Then the teams play in turns like that: the 1-st player of the 1-st team, the 1-st player of the 2-nd team, ... , the 1-st player of the *n*-th team, the 2-nd player of the 1-st team, ... , the 2-nd player of the *n*-th team, the 1-st player of the 1-st team and so on. Each turn continues for *t* seconds. It goes like that: Initially the time for each turn is *t*. While the time left to a player is more than 0, a player takes a card from the top of the deck and starts explaining the word it has to his teammate. The time needed for the *j*-th player of the *i*-th team to explain the word from the card *k* to his teammate (the *q*-th player of the *i*-th team) equals *max*(1,<=*c**k*<=-<=(*a**ij*<=+<=*b**iq*)<=-<=*d**ik*) (if *j*<==<=1,<= then *q*<==<=2,<= else *q*<==<=1). The value *d**ik* is the number of seconds the *i*-th team has already spent explaining the word *k* during the previous turns. Initially, all *d**ik* equal 0. If a team manages to guess the word before the end of the turn, then the time given above is substracted from the duration of the turn, the card containing the guessed word leaves the game, the team wins one point and the game continues. If the team doesn't manage to guess the word, then the card is put at the bottom of the deck, *d**ik* increases on the amount of time of the turn, spent on explaining the word. Thus, when this team gets the very same word, they start explaining it not from the beginning, but from the point where they stopped. The game ends when words from all *m* cards are guessed correctly. You are given *n* teams and a deck of *m* cards. You should determine for each team, how many points it will have by the end of the game and which words the team will have guessed. Input Specification: The first line contains two integers *n*,<=*t* (1<=≤<=*n*,<=*t*<=≤<=100), which correspondingly denote the number of teams and a turn's duration. Next *n* lines of the input file contain four integers each: *a**i*1,<=*b**i*1,<=*a**i*2,<=*b**i*2 (1<=≤<=*a**ij*,<=*b**ij*<=≤<=100) — the skills of the first and the second player of the *i*-th team. The teams are given in the order in which they play. The next line of the input file contains integer *m* (1<=≤<=*m*<=≤<=100) the number of cards. Next 2*m* lines contain the cards' descriptions. Two lines describe each card. The first line of the description contains the word that consists of no more than 20 characters. The words only contain small Latin letters. The second line of the description contains an integer *c**k* (1<=≤<=*c**k*<=≤<=100) — the complexity of the word written on the *k*-th card. The cards are listed in the order in which the lie in the deck from top to bottom. The words on all cards are different. Output Specification: Print *n* lines. On the *i*-th line first print number *s**i* the number of points the *i*-th team wins. Then print *s**i* space-separated words — the words from the cards guessed by team *i* in the order in which they were guessed. Demo Input: ['2 2\n1 1 1 1\n1 1 1 1\n3\nhome\n1\ncar\n1\nbrother\n1\n', '2 4\n1 2 2 1\n2 3 2 2\n4\narmchair\n3\nquetzalcoatl\n10\npilotage\n5\ndefibrillator\n7\n'] Demo Output: ['2 home car \n1 brother \n', '2 armchair quetzalcoatl \n2 pilotage defibrillator \n'] Note: none

```python import sys from collections import deque sys.stdin = open('input.txt', 'r') sys.stdout = open('output.txt', 'w') n, t = [int(x) for x in input().split()] teams = [] for i in range(n): a1, b1, a2, b2 = [int(x) for x in input().split()] teams.append((a1 + b2, a2 + b1)) m = int(input()) words = [] c = [] deck = deque() for i in range(m): words.append(input()) c.append(int(input())) deck.append(i) cur_team = 0 cur_player = 0 guessed = [[] for _ in range(n)] cur_time = t d = [[0] * m for _ in range(n)] while len(deck) > 0: card = deck.popleft() time = max(1, c[card] - teams[cur_team][cur_player] - d[cur_team][card]) if cur_time >= time: guessed[cur_team].append(card) cur_time -= time else: d[cur_team][card] += cur_time cur_team += 1 if cur_team == n: cur_team = 0 cur_player = 1 - cur_player cur_time = t deck.append(card) for i in range(n): print(len(guessed[i]), *map(lambda x: words[x], guessed[i])) ```

0

271

D

Good Substrings

PROGRAMMING

1,800

[ "data structures", "strings" ]

null

You've got string *s*, consisting of small English letters. Some of the English letters are good, the rest are bad. A substring *s*[*l*...*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=|*s*|) of string *s*<=<==<=<=*s*1*s*2...*s*|*s*| (where |*s*| is the length of string *s*) is string <=*s**l**s**l*<=+<=1...*s**r*. The substring *s*[*l*...*r*] is good, if among the letters <=*s**l*,<=*s**l*<=+<=1,<=...,<=*s**r* there are at most *k* bad ones (look at the sample's explanation to understand it more clear). Your task is to find the number of distinct good substrings of the given string *s*. Two substrings *s*[*x*...*y*] and *s*[*p*...*q*] are considered distinct if their content is different, i.e. *s*[*x*...*y*]<=≠<=*s*[*p*...*q*].

The first line of the input is the non-empty string *s*, consisting of small English letters, the string's length is at most 1500 characters. The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the *i*-th character of this string equals "1", then the *i*-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on. The third line of the input consists a single integer *k* (0<=≤<=*k*<=≤<=|*s*|) — the maximum acceptable number of bad characters in a good substring.

Print a single integer — the number of distinct good substrings of string *s*.

[ "ababab\n01000000000000000000000000\n1\n", "acbacbacaa\n00000000000000000000000000\n2\n" ]

[ "5\n", "8\n" ]

In the first example there are following good substrings: "a", "ab", "b", "ba", "bab". In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".

2,000

[ { "input": "ababab\n01000000000000000000000000\n1", "output": "5" }, { "input": "acbacbacaa\n00000000000000000000000000\n2", "output": "8" }, { "input": "a\n00000000000000000000000000\n0", "output": "0" }, { "input": "aaaa\n00000000000000000000000000\n0", "output": "0" }, { "input": "aaaaaa\n00000000000000000000000000\n1", "output": "1" }, { "input": "bbbbbbbbba\n01000000000000000000000000\n0", "output": "9" }, { "input": "bbbbbbbbba\n10000000000000000000000000\n0", "output": "1" }, { "input": "kqdwdulmgvugvbl\n00101010100100100101101110\n13", "output": "114" }, { "input": "acehqnrtuwaealwbqufdmizce\n10000110100000010011101101\n16", "output": "316" }, { "input": "yqahbyyoxltryqdmvenemaqnbakglgqolxnaifnqtoclnnqiab\n11000001000110100111100001\n41", "output": "1243" }, { "input": "dykhvzcntljuuoqghptioetqnfllwekzohiuaxelgecabvsbibgqodqxvyfkbyjwtgbyhvssntinkwsinwsmalusiwnjmtcoovfj\n10001111101011111101101001\n25", "output": "4420" }, { "input": "dcijflpluxgeqlroaktzcujfaaidnrdzgogzhobhsmbwmjpschtvjmivfapddsmxfvlhhgguymgtdjxpiezbnlmnlvdnuaohqskdbcjlyfdrzicflveffvpeyzhwqqdaenbsghuvetpxvqcutjxbelbfzuqpwlfvveebnmkoryxgodpccanzwhziiiumgtwskxhrhwdkwmyreefwmoedcvaokvetcgundyiidsqkolpqkarpszrrmagrfvpnwharotashtwcnrcnhapdwrbltgkpkkmlrpapfizonyttrikh\n11011010101101110101010001\n54", "output": "31658" }, { "input": "baababbbaa\n01011100110010100100001111\n7", "output": "41" }, { "input": "aaaabaababbbbbbbbbaaabaaabbbababbbbbbabbaaabaabaabaaabaaaabbababbaaaaaaababbaababbabbaabbbabaabbbbababaaabbabbbabaaabbbabbbbbbbbabababaaaaaabaababbbbbaaaaaaaaaaaaaaababbbbabbbbbbababaabbabbbaababaabaaaabbababaaaabaaaaaaabaabaababbbbbbaababbabbaaaababbabbaaaabaaaaaaababbbbabbbbabaaabababaaaabaaaababb\n11011010101101110101010001\n54", "output": "42890" }, { "input": "dykhvzcntljuuoqghptioetqnfllwekzohiuaxelgecabvsbibgqodqxvyfkbyjwtgbyhvssntinkwsinwsmalusiwnjmtcoovfj\n11111111111111111111111111\n25", "output": "4967" }, { "input": "twnwdluhxf\n00000000000000000000000000\n1", "output": "9" }, { "input": "aaaaaaaaaa\n01011100110010100100001111\n7", "output": "7" }, { "input": "eoyirpkwgpvvwzaaaaaaaaaaaaaa\n11111111111111111111111111\n1", "output": "312" }, { "input": "fwnpwwuzszuryaaaaaaaaaaaaa\n11111111111111111111111111\n1", "output": "269" }, { "input": "xnahfslefuigqaaaaaaaaaaaaa\n11111111111111111111111111\n1", "output": "271" } ]

1,691,430,237

2,147,483,647

PyPy 3

TIME_LIMIT_EXCEEDED

TESTS

7

2,000

113,152,000

p = 31 m1 = 10**9+7 m2 = 10**9+9 s = input() n = len(s) alpha = [] for i in input(): if i == '0': alpha.append(1) else: alpha.append(0) k = int(input()) good = set() for l in range(n): bad = alpha[ord(s[l]) - ord('a')] h1 = (ord(s[l]) - ord('a') + 1) h2 = (ord(s[l]) - ord('a') + 1) h1 %= m1 h2 %= m2 i = 0 for r in range(l,n): if r > l: bad += alpha[ord(s[r]) - ord('a')] h1 += (ord(s[r]) - ord('a') + 1) * pow(p,i,m1) h1 %= m1 h2 += (ord(s[r]) - ord('a') + 1) * pow(p,i,m2) h2 %= m2 if bad <= k: good.add((h1,h2)) else: break i += 1 print(len(good))

Title: Good Substrings Time Limit: None seconds Memory Limit: None megabytes Problem Description: You've got string *s*, consisting of small English letters. Some of the English letters are good, the rest are bad. A substring *s*[*l*...*r*] (1<=≤<=*l*<=≤<=*r*<=≤<=|*s*|) of string *s*<=<==<=<=*s*1*s*2...*s*|*s*| (where |*s*| is the length of string *s*) is string <=*s**l**s**l*<=+<=1...*s**r*. The substring *s*[*l*...*r*] is good, if among the letters <=*s**l*,<=*s**l*<=+<=1,<=...,<=*s**r* there are at most *k* bad ones (look at the sample's explanation to understand it more clear). Your task is to find the number of distinct good substrings of the given string *s*. Two substrings *s*[*x*...*y*] and *s*[*p*...*q*] are considered distinct if their content is different, i.e. *s*[*x*...*y*]<=≠<=*s*[*p*...*q*]. Input Specification: The first line of the input is the non-empty string *s*, consisting of small English letters, the string's length is at most 1500 characters. The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the *i*-th character of this string equals "1", then the *i*-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on. The third line of the input consists a single integer *k* (0<=≤<=*k*<=≤<=|*s*|) — the maximum acceptable number of bad characters in a good substring. Output Specification: Print a single integer — the number of distinct good substrings of string *s*. Demo Input: ['ababab\n01000000000000000000000000\n1\n', 'acbacbacaa\n00000000000000000000000000\n2\n'] Demo Output: ['5\n', '8\n'] Note: In the first example there are following good substrings: "a", "ab", "b", "ba", "bab". In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".

```python p = 31 m1 = 10**9+7 m2 = 10**9+9 s = input() n = len(s) alpha = [] for i in input(): if i == '0': alpha.append(1) else: alpha.append(0) k = int(input()) good = set() for l in range(n): bad = alpha[ord(s[l]) - ord('a')] h1 = (ord(s[l]) - ord('a') + 1) h2 = (ord(s[l]) - ord('a') + 1) h1 %= m1 h2 %= m2 i = 0 for r in range(l,n): if r > l: bad += alpha[ord(s[r]) - ord('a')] h1 += (ord(s[r]) - ord('a') + 1) * pow(p,i,m1) h1 %= m1 h2 += (ord(s[r]) - ord('a') + 1) * pow(p,i,m2) h2 %= m2 if bad <= k: good.add((h1,h2)) else: break i += 1 print(len(good)) ```

0

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,592,751,304

2,147,483,647

Python 3

OK

TESTS

34

452

18,636,800

i=0 j=int(input()) j=j-1 a=list(map(int,input().split())) while j>i: a[j],a[i]=a[i],a[j] i=i+2 j=j-2 for i in a: print(i,end=' ')

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 i=0 j=int(input()) j=j-1 a=list(map(int,input().split())) while j>i: a[j],a[i]=a[i],a[j] i=i+2 j=j-2 for i in a: print(i,end=' ') ```

3

68

B

Energy exchange

PROGRAMMING

1,600

[ "binary search" ]

B. Energy exchange

2

256

It is well known that the planet suffers from the energy crisis. Little Petya doesn't like that and wants to save the world. For this purpose he needs every accumulator to contain the same amount of energy. Initially every accumulator has some amount of energy: the *i*-th accumulator has *a**i* units of energy. Energy can be transferred from one accumulator to the other. Every time *x* units of energy are transferred (*x* is not necessarily an integer) *k* percent of it is lost. That is, if *x* units were transferred from one accumulator to the other, amount of energy in the first one decreased by *x* units and in other increased by units. Your task is to help Petya find what maximum equal amount of energy can be stored in each accumulator after the transfers.

First line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=10000,<=0<=≤<=*k*<=≤<=99) — number of accumulators and the percent of energy that is lost during transfers. Next line contains *n* integers *a*1,<=*a*2,<=... ,<=*a**n* — amounts of energy in the first, second, .., *n*-th accumulator respectively (0<=≤<=*a**i*<=≤<=1000,<=1<=≤<=*i*<=≤<=*n*).

Output maximum possible amount of energy that can remain in each of accumulators after the transfers of energy. The absolute or relative error in the answer should not exceed 10<=-<=6.

[ "3 50\n4 2 1\n", "2 90\n1 11\n" ]

[ "2.000000000\n", "1.909090909\n" ]

none

1,000

[ { "input": "3 50\n4 2 1", "output": "2.000000000" }, { "input": "2 90\n1 11", "output": "1.909090909" }, { "input": "5 26\n42 65 23 43 64", "output": "45.415178571" }, { "input": "5 45\n964 515 454 623 594", "output": "594.109756098" }, { "input": "1 20\n784", "output": "784.000000000" }, { "input": "10 20\n812 896 36 596 709 641 679 778 738 302", "output": "597.255813953" }, { "input": "10 83\n689 759 779 927 15 231 976 943 604 917", "output": "406.839285714" }, { "input": "11 1\n235 280 196 670 495 379 391 280 847 875 506", "output": "467.586301370" }, { "input": "12 71\n472 111 924 103 975 527 807 618 400 523 607 424", "output": "413.249554367" }, { "input": "13 89\n19 944 341 846 764 676 222 957 953 481 708 920 950", "output": "361.924390244" }, { "input": "14 6\n256 465 759 589 242 824 638 985 506 128 809 105 301 827", "output": "523.427098675" }, { "input": "100 95\n154 444 715 98 35 347 799 313 40 821 118 786 31 587 888 84 88 751 98 86 321 720 201 247 302 518 663 904 482 385 139 646 581 995 847 775 173 252 508 722 380 922 634 911 102 384 346 212 705 380 220 221 492 421 244 591 758 631 370 866 536 872 294 152 337 810 761 235 789 839 365 366 623 897 905 249 685 838 380 873 702 379 865 68 215 168 425 264 652 228 167 498 733 41 502 21 565 956 430 171", "output": "179.075000000" }, { "input": "101 71\n113 551 568 26 650 547 89 668 64 651 110 515 482 401 170 971 623 672 135 106 985 751 286 255 82 588 122 568 751 867 335 488 324 122 829 256 675 471 255 723 630 802 667 665 206 774 573 499 361 202 620 522 72 220 739 868 101 135 254 519 896 227 224 968 263 826 466 377 360 24 124 874 877 513 130 79 630 786 265 150 232 783 449 914 815 557 646 367 733 576 840 683 417 709 569 432 515 702 811 877 286", "output": "343.047284817" }, { "input": "102 99\n73 348 420 956 955 436 69 714 87 480 102 555 933 215 452 167 157 593 863 816 337 471 371 574 862 967 581 543 330 348 221 640 378 250 500 428 866 379 1 723 880 992 9 419 0 163 800 96 16 25 19 513 653 19 924 144 135 950 449 481 255 582 844 473 189 841 862 520 242 210 573 381 130 820 357 911 884 735 460 428 764 187 344 760 413 636 868 780 123 614 822 869 792 66 636 843 465 449 191 891 819 30", "output": "68.702920443" }, { "input": "103 26\n33 455 273 884 569 636 360 69 802 310 405 594 693 339 43 53 692 514 590 835 1000 191 456 582 641 35 731 207 600 830 416 483 431 377 481 910 367 597 58 413 128 873 42 173 104 553 26 383 673 849 728 503 924 819 108 422 169 454 333 134 926 247 464 289 115 547 567 663 123 396 21 890 385 436 584 432 829 683 345 706 294 901 238 606 12 24 89 882 203 962 804 745 166 425 393 252 415 195 571 596 41 486 445", "output": "419.922659430" }, { "input": "104 54\n683 252 125 813 874 835 651 424 826 139 397 323 143 153 326 941 536 435 317 854 353 222 851 591 420 415 190 872 178 311 612 635 174 505 153 81 559 815 805 414 378 62 75 929 208 942 254 670 329 671 127 494 504 618 292 699 203 959 218 788 285 602 83 104 41 562 272 806 4 582 780 87 639 743 811 263 83 632 230 984 826 304 133 142 612 413 310 985 594 309 787 930 541 92 461 663 675 942 952 610 574 633 758 999", "output": "399.430903462" } ]

1,515,243,327

2,147,483,647

Python 3

OK

TESTS

42

404

6,144,000

n, k = map(int, input().split()) a = list(map(int, input().split())) s = sum(a) eps = 0.0000000001 rem = (100-k)/100 left = min(a) right = max(a) guess = left while (right - left) > eps: guess = left + (right-left)/2 transferred = 0.0 missing = 0.0 for ai in a: if ai-guess > 0: transferred += rem*(ai-guess) else: missing += guess-ai if missing < transferred: left = guess else: right = guess print(guess)

Title: Energy exchange Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: It is well known that the planet suffers from the energy crisis. Little Petya doesn't like that and wants to save the world. For this purpose he needs every accumulator to contain the same amount of energy. Initially every accumulator has some amount of energy: the *i*-th accumulator has *a**i* units of energy. Energy can be transferred from one accumulator to the other. Every time *x* units of energy are transferred (*x* is not necessarily an integer) *k* percent of it is lost. That is, if *x* units were transferred from one accumulator to the other, amount of energy in the first one decreased by *x* units and in other increased by units. Your task is to help Petya find what maximum equal amount of energy can be stored in each accumulator after the transfers. Input Specification: First line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=10000,<=0<=≤<=*k*<=≤<=99) — number of accumulators and the percent of energy that is lost during transfers. Next line contains *n* integers *a*1,<=*a*2,<=... ,<=*a**n* — amounts of energy in the first, second, .., *n*-th accumulator respectively (0<=≤<=*a**i*<=≤<=1000,<=1<=≤<=*i*<=≤<=*n*). Output Specification: Output maximum possible amount of energy that can remain in each of accumulators after the transfers of energy. The absolute or relative error in the answer should not exceed 10<=-<=6. Demo Input: ['3 50\n4 2 1\n', '2 90\n1 11\n'] Demo Output: ['2.000000000\n', '1.909090909\n'] Note: none

```python n, k = map(int, input().split()) a = list(map(int, input().split())) s = sum(a) eps = 0.0000000001 rem = (100-k)/100 left = min(a) right = max(a) guess = left while (right - left) > eps: guess = left + (right-left)/2 transferred = 0.0 missing = 0.0 for ai in a: if ai-guess > 0: transferred += rem*(ai-guess) else: missing += guess-ai if missing < transferred: left = guess else: right = guess print(guess) ```

3.887556

7

A

Kalevitch and Chess

PROGRAMMING

1,100

[ "brute force", "constructive algorithms" ]

A. Kalevitch and Chess

2

64

A famous Berland's painter Kalevitch likes to shock the public. One of his last obsessions is chess. For more than a thousand years people have been playing this old game on uninteresting, monotonous boards. Kalevitch decided to put an end to this tradition and to introduce a new attitude to chessboards. As before, the chessboard is a square-checkered board with the squares arranged in a 8<=×<=8 grid, each square is painted black or white. Kalevitch suggests that chessboards should be painted in the following manner: there should be chosen a horizontal or a vertical line of 8 squares (i.e. a row or a column), and painted black. Initially the whole chessboard is white, and it can be painted in the above described way one or more times. It is allowed to paint a square many times, but after the first time it does not change its colour any more and remains black. Kalevitch paints chessboards neatly, and it is impossible to judge by an individual square if it was painted with a vertical or a horizontal stroke. Kalevitch hopes that such chessboards will gain popularity, and he will be commissioned to paint chessboards, which will help him ensure a comfortable old age. The clients will inform him what chessboard they want to have, and the painter will paint a white chessboard meeting the client's requirements. It goes without saying that in such business one should economize on everything — for each commission he wants to know the minimum amount of strokes that he has to paint to fulfill the client's needs. You are asked to help Kalevitch with this task.

The input file contains 8 lines, each of the lines contains 8 characters. The given matrix describes the client's requirements, W character stands for a white square, and B character — for a square painted black. It is guaranteed that client's requirments can be fulfilled with a sequence of allowed strokes (vertical/column or horizontal/row).

Output the only number — the minimum amount of rows and columns that Kalevitch has to paint on the white chessboard to meet the client's requirements.

[ "WWWBWWBW\nBBBBBBBB\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\n", "WWWWWWWW\nBBBBBBBB\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\n" ]

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

none

0

[ { "input": "WWWBWWBW\nBBBBBBBB\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW", "output": "3" }, { "input": "WWWWWWWW\nBBBBBBBB\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW", "output": "1" }, { "input": "WWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW", "output": "0" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB", "output": "8" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBW", "output": "14" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBWB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB", "output": "14" }, { "input": "BBBBBBBB\nWBBBWBBW\nBBBBBBBB\nWBBBWBBW\nWBBBWBBW\nBBBBBBBB\nBBBBBBBB\nWBBBWBBW", "output": "9" }, { "input": "BBBBBBBB\nWBBWWWBB\nBBBBBBBB\nWBBWWWBB\nBBBBBBBB\nBBBBBBBB\nWBBWWWBB\nBBBBBBBB", "output": "9" }, { "input": "BBBBBWWB\nBBBBBBBB\nBBBBBBBB\nBBBBBWWB\nBBBBBWWB\nBBBBBWWB\nBBBBBWWB\nBBBBBWWB", "output": "8" }, { "input": "WWWWBBBB\nWWWWBBBB\nBBBBBBBB\nBBBBBBBB\nWWWWBBBB\nWWWWBBBB\nBBBBBBBB\nBBBBBBBB", "output": "8" }, { "input": "BBBBBBBB\nWBWWBBBW\nBBBBBBBB\nWBWWBBBW\nWBWWBBBW\nWBWWBBBW\nWBWWBBBW\nBBBBBBBB", "output": "7" }, { "input": "WBWWBBBW\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nWBWWBBBW\nWBWWBBBW", "output": "9" }, { "input": "BBWWBBBW\nBBBBBBBB\nBBBBBBBB\nBBWWBBBW\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB", "output": "11" }, { "input": "WWBWBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nWWBWBBBB\nBBBBBBBB\nWWBWBBBB\nBBBBBBBB", "output": "10" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBBB\nWWBWBBBB\nWWBWBBBB\nBBBBBBBB\nBBBBBBBB\nWWBWBBBB", "output": "10" }, { "input": "WBBWBBBW\nWBBWBBBW\nWBBWBBBW\nWBBWBBBW\nWBBWBBBW\nBBBBBBBB\nWBBWBBBW\nWBBWBBBW", "output": "6" }, { "input": "BBBWBBBW\nBBBWBBBW\nBBBWBBBW\nBBBBBBBB\nBBBBBBBB\nBBBWBBBW\nBBBBBBBB\nBBBBBBBB", "output": "10" }, { "input": "BBBBBBBB\nBBBWBBBB\nBBBWBBBB\nBBBWBBBB\nBBBBBBBB\nBBBWBBBB\nBBBWBBBB\nBBBWBBBB", "output": "9" }, { "input": "BBBBBBBB\nWWWBBBBB\nWWWBBBBB\nBBBBBBBB\nWWWBBBBB\nWWWBBBBB\nBBBBBBBB\nBBBBBBBB", "output": "9" }, { "input": "WBBBBBWB\nBBBBBBBB\nWBBBBBWB\nWBBBBBWB\nWBBBBBWB\nWBBBBBWB\nWBBBBBWB\nBBBBBBBB", "output": "8" }, { "input": "WBBBWWBW\nWBBBWWBW\nBBBBBBBB\nWBBBWWBW\nBBBBBBBB\nWBBBWWBW\nWBBBWWBW\nWBBBWWBW", "output": "6" }, { "input": "WBBBBWBB\nBBBBBBBB\nBBBBBBBB\nWBBBBWBB\nWBBBBWBB\nBBBBBBBB\nWBBBBWBB\nBBBBBBBB", "output": "10" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBBB\nWBBBWBBW\nBBBBBBBB\nBBBBBBBB\nWBBBWBBW\nBBBBBBBB", "output": "11" }, { "input": "BBBBBBBB\nBWBBBBBW\nBWBBBBBW\nBBBBBBBB\nBWBBBBBW\nBWBBBBBW\nBBBBBBBB\nBWBBBBBW", "output": "9" }, { "input": "BBBBBBBB\nBBBBBBBB\nWBBBWWWW\nBBBBBBBB\nBBBBBBBB\nWBBBWWWW\nBBBBBBBB\nBBBBBBBB", "output": "9" }, { "input": "BWBBBWWB\nBWBBBWWB\nBBBBBBBB\nBBBBBBBB\nBWBBBWWB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB", "output": "10" }, { "input": "BBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBWBBWBWB", "output": "12" }, { "input": "BWBBBBWW\nBWBBBBWW\nBWBBBBWW\nBWBBBBWW\nBBBBBBBB\nBWBBBBWW\nBWBBBBWW\nBBBBBBBB", "output": "7" }, { "input": "WWBBWWBB\nBBBBBBBB\nWWBBWWBB\nWWBBWWBB\nWWBBWWBB\nBBBBBBBB\nWWBBWWBB\nWWBBWWBB", "output": "6" }, { "input": "BWBBWWWW\nBWBBWWWW\nBWBBWWWW\nBBBBBBBB\nBBBBBBBB\nBBBBBBBB\nBWBBWWWW\nBBBBBBBB", "output": "7" } ]

1,616,071,437

2,147,483,647

Python 3

OK

TESTS

30

124

0

s = [input().count('B') for i in range(8)] print(min(s) % 8 + s.count(8))

Title: Kalevitch and Chess Time Limit: 2 seconds Memory Limit: 64 megabytes Problem Description: A famous Berland's painter Kalevitch likes to shock the public. One of his last obsessions is chess. For more than a thousand years people have been playing this old game on uninteresting, monotonous boards. Kalevitch decided to put an end to this tradition and to introduce a new attitude to chessboards. As before, the chessboard is a square-checkered board with the squares arranged in a 8<=×<=8 grid, each square is painted black or white. Kalevitch suggests that chessboards should be painted in the following manner: there should be chosen a horizontal or a vertical line of 8 squares (i.e. a row or a column), and painted black. Initially the whole chessboard is white, and it can be painted in the above described way one or more times. It is allowed to paint a square many times, but after the first time it does not change its colour any more and remains black. Kalevitch paints chessboards neatly, and it is impossible to judge by an individual square if it was painted with a vertical or a horizontal stroke. Kalevitch hopes that such chessboards will gain popularity, and he will be commissioned to paint chessboards, which will help him ensure a comfortable old age. The clients will inform him what chessboard they want to have, and the painter will paint a white chessboard meeting the client's requirements. It goes without saying that in such business one should economize on everything — for each commission he wants to know the minimum amount of strokes that he has to paint to fulfill the client's needs. You are asked to help Kalevitch with this task. Input Specification: The input file contains 8 lines, each of the lines contains 8 characters. The given matrix describes the client's requirements, W character stands for a white square, and B character — for a square painted black. It is guaranteed that client's requirments can be fulfilled with a sequence of allowed strokes (vertical/column or horizontal/row). Output Specification: Output the only number — the minimum amount of rows and columns that Kalevitch has to paint on the white chessboard to meet the client's requirements. Demo Input: ['WWWBWWBW\nBBBBBBBB\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\nWWWBWWBW\n', 'WWWWWWWW\nBBBBBBBB\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\nWWWWWWWW\n'] Demo Output: ['3\n', '1\n'] Note: none

```python s = [input().count('B') for i in range(8)] print(min(s) % 8 + s.count(8)) ```

3.969

462

A

Appleman and Easy Task

PROGRAMMING

1,000

[ "brute force", "implementation" ]

null

Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him? Given a *n*<=×<=*n* checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Then *n* lines follow containing the description of the checkerboard. Each of them contains *n* characters (either 'x' or 'o') without spaces.

Print "YES" or "NO" (without the quotes) depending on the answer to the problem.

[ "3\nxxo\nxox\noxx\n", "4\nxxxo\nxoxo\noxox\nxxxx\n" ]

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

none

500

[ { "input": "3\nxxo\nxox\noxx", "output": "YES" }, { "input": "4\nxxxo\nxoxo\noxox\nxxxx", "output": "NO" }, { "input": "1\no", "output": "YES" }, { "input": "2\nox\nxo", "output": "YES" }, { "input": "2\nxx\nxo", "output": "NO" }, { "input": "3\nooo\noxo\nxoo", "output": "NO" }, { "input": "3\nxxx\nxxo\nxxo", "output": "NO" }, { "input": "4\nxooo\nooxo\noxoo\nooox", "output": "YES" }, { "input": "4\noooo\noxxo\nxoxo\noooo", "output": "NO" }, { "input": "5\noxoxo\nxxxxx\noxoxo\nxxxxx\noxoxo", "output": "YES" }, { "input": "5\nxxxox\nxxxxo\nxoxox\noxoxx\nxoxxx", "output": "NO" }, { "input": "10\nxoxooooooo\noxxoxxxxxo\nxxooxoooxo\noooxxoxoxo\noxxxooooxo\noxooooxxxo\noxoxoxxooo\noxoooxooxx\noxxxxxoxxo\noooooooxox", "output": "YES" }, { "input": "10\nxxxxxxxoox\nxooxxooooo\noxoooxxooo\nxoxxxxxxxx\nxxoxooxxox\nooxoxxooox\nooxxxxxooo\nxxxxoxooox\nxoxxooxxxx\noooooxxoxo", "output": "NO" }, { "input": "19\noxoxoxoxooxoooxxoox\nxxxxxxxxoxxoxoooooo\noxoxoxooxxxooxxxooo\nxxoxxxooxooxxxoxxox\noxoxooxxxooooxxoxox\nxxxoooxoxxoxxoxxxoo\noxooxxxoooooxxoooxo\nxxooxooxoxxoxxoxxoo\noxxxxooooxxxooooxxx\nooxooxoxxoxxoxooxoo\nxxxooooxxxooooxoxox\noooxoxooxxoxooxooxx\nxxoooxxxooooxxoooxo\nooxxxooxoxooxooxxxx\nxoxoxxooxoxxxooxoxo\nxoxxoxoxooxooxxxxxx\noooxxxooxxxooxoxoxo\nxoooooxoxooxxxxxxxo\nxooxxoooxxoxoxoxoxx", "output": "NO" }, { "input": "12\nxxooxxoxxxoo\nxxoooxoxoxoo\nooxoxoxxooxx\nooxxooooxoxo\nxxxxxxxxoxxx\noxooooxxxooo\noxxoxoxoooxx\nxxxxxxxooxox\noxoooooxoxxx\nxxooxxoxxoxx\noxxxxxxxooxx\nooxoxooxxooo", "output": "NO" }, { "input": "2\noo\nxx", "output": "NO" } ]

1,498,712,856

2,147,483,647

Python 3

OK

TESTS

32

62

5,529,600

n = int(input()) rows = [] for x in range(n): string = input() rows.append(string) results = "YES" for x in range(n): for y in range(n): a = y + 1 b = y - 1 c = x + 1 d = x - 1 z = 0 if a < n: if rows[x][a] == "o": z += 1 if b >= 0: if rows[x][b] == "o": z += 1 if c < n: if rows[c][y] == "o": z += 1 if d >= 0: if rows[d][y] == "o": z += 1 if z % 2 != 0: results = "NO" break print(results)

Title: Appleman and Easy Task Time Limit: None seconds Memory Limit: None megabytes Problem Description: Toastman came up with a very easy task. He gives it to Appleman, but Appleman doesn't know how to solve it. Can you help him? Given a *n*<=×<=*n* checkerboard. Each cell of the board has either character 'x', or character 'o'. Is it true that each cell of the board has even number of adjacent cells with 'o'? Two cells of the board are adjacent if they share a side. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Then *n* lines follow containing the description of the checkerboard. Each of them contains *n* characters (either 'x' or 'o') without spaces. Output Specification: Print "YES" or "NO" (without the quotes) depending on the answer to the problem. Demo Input: ['3\nxxo\nxox\noxx\n', '4\nxxxo\nxoxo\noxox\nxxxx\n'] Demo Output: ['YES\n', 'NO\n'] Note: none

```python n = int(input()) rows = [] for x in range(n): string = input() rows.append(string) results = "YES" for x in range(n): for y in range(n): a = y + 1 b = y - 1 c = x + 1 d = x - 1 z = 0 if a < n: if rows[x][a] == "o": z += 1 if b >= 0: if rows[x][b] == "o": z += 1 if c < n: if rows[c][y] == "o": z += 1 if d >= 0: if rows[d][y] == "o": z += 1 if z % 2 != 0: results = "NO" break print(results) ```

3

340

A

The Wall

PROGRAMMING

1,200

[ "math" ]

null

Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on. Iahub has the following scheme of painting: he skips *x*<=-<=1 consecutive bricks, then he paints the *x*-th one. That is, he'll paint bricks *x*, 2·*x*, 3·*x* and so on red. Similarly, Floyd skips *y*<=-<=1 consecutive bricks, then he paints the *y*-th one. Hence he'll paint bricks *y*, 2·*y*, 3·*y* and so on pink. After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number *a* and Floyd has a lucky number *b*. Boys wonder how many bricks numbered no less than *a* and no greater than *b* are painted both red and pink. This is exactly your task: compute and print the answer to the question.

The input will have a single line containing four integers in this order: *x*, *y*, *a*, *b*. (1<=≤<=*x*,<=*y*<=≤<=1000, 1<=≤<=*a*,<=*b*<=≤<=2·109, *a*<=≤<=*b*).

Output a single integer — the number of bricks numbered no less than *a* and no greater than *b* that are painted both red and pink.

[ "2 3 6 18\n" ]

[ "3" ]

Let's look at the bricks from *a* to *b* (*a* = 6, *b* = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.

500

[ { "input": "2 3 6 18", "output": "3" }, { "input": "4 6 20 201", "output": "15" }, { "input": "15 27 100 10000", "output": "74" }, { "input": "105 60 3456 78910", "output": "179" }, { "input": "1 1 1000 100000", "output": "99001" }, { "input": "3 2 5 5", "output": "0" }, { "input": "555 777 1 1000000", "output": "257" }, { "input": "1000 1000 1 32323", "output": "32" }, { "input": "45 125 93451125 100000000", "output": "5821" }, { "input": "101 171 1 1000000000", "output": "57900" }, { "input": "165 255 69696 1000000000", "output": "356482" }, { "input": "555 777 666013 1000000000", "output": "257229" }, { "input": "23 46 123321 900000000", "output": "19562537" }, { "input": "321 123 15 1000000", "output": "75" }, { "input": "819 1000 9532 152901000", "output": "186" }, { "input": "819 1000 10000 1000000", "output": "1" }, { "input": "1 1 1 1", "output": "1" }, { "input": "1 2 2 1000003", "output": "500001" }, { "input": "1 1 1 1000000000", "output": "1000000000" }, { "input": "10 15 69 195610342", "output": "6520342" }, { "input": "2 1 1 1000000000", "output": "500000000" }, { "input": "1000 1000 1 20", "output": "0" }, { "input": "1 1 1 2000000000", "output": "2000000000" }, { "input": "1 2 1 2000000000", "output": "1000000000" }, { "input": "2 1 1 2000000000", "output": "1000000000" }, { "input": "2 3 1 1000000000", "output": "166666666" }, { "input": "2 3 1 2000000000", "output": "333333333" }, { "input": "3 7 1 1000000000", "output": "47619047" }, { "input": "1 1 1000000000 2000000000", "output": "1000000001" }, { "input": "2 2 1 2000000000", "output": "1000000000" }, { "input": "1 1 2 2000000000", "output": "1999999999" }, { "input": "3 2 1 2000000000", "output": "333333333" }, { "input": "1 1 2000000000 2000000000", "output": "1" }, { "input": "2 3 7 7", "output": "0" }, { "input": "3 3 3 7", "output": "2" } ]

1,578,845,534

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

1

248

0

from math import gcd def getLCM(a, b): return a * b // gcd(a, b) s = input().split(" ") print(int((int(s[3]) - int(s[2])) / getLCM(int(s[0]), int(s[1]))) + 1)

Title: The Wall Time Limit: None seconds Memory Limit: None megabytes Problem Description: Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on. Iahub has the following scheme of painting: he skips *x*<=-<=1 consecutive bricks, then he paints the *x*-th one. That is, he'll paint bricks *x*, 2·*x*, 3·*x* and so on red. Similarly, Floyd skips *y*<=-<=1 consecutive bricks, then he paints the *y*-th one. Hence he'll paint bricks *y*, 2·*y*, 3·*y* and so on pink. After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number *a* and Floyd has a lucky number *b*. Boys wonder how many bricks numbered no less than *a* and no greater than *b* are painted both red and pink. This is exactly your task: compute and print the answer to the question. Input Specification: The input will have a single line containing four integers in this order: *x*, *y*, *a*, *b*. (1<=≤<=*x*,<=*y*<=≤<=1000, 1<=≤<=*a*,<=*b*<=≤<=2·109, *a*<=≤<=*b*). Output Specification: Output a single integer — the number of bricks numbered no less than *a* and no greater than *b* that are painted both red and pink. Demo Input: ['2 3 6 18\n'] Demo Output: ['3'] Note: Let's look at the bricks from *a* to *b* (*a* = 6, *b* = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.

```python from math import gcd def getLCM(a, b): return a * b // gcd(a, b) s = input().split(" ") print(int((int(s[3]) - int(s[2])) / getLCM(int(s[0]), int(s[1]))) + 1) ```

0