MatrixStudio/Codeforces-Python-Submissions

44

C

Holidays

PROGRAMMING

1,300

[ "implementation" ]

C. Holidays

2

256

School holidays come in Berland. The holidays are going to continue for *n* days. The students of school №*N* are having the time of their lives and the IT teacher Marina Sergeyevna, who has spent all the summer busy checking the BSE (Berland State Examination) results, has finally taken a vacation break! Some people are in charge of the daily watering of flowers in shifts according to the schedule. However when Marina Sergeyevna was making the schedule, she was so tired from work and so lost in dreams of the oncoming vacation that she perhaps made several mistakes. In fact, it is possible that according to the schedule, on some days during the holidays the flowers will not be watered or will be watered multiple times. Help Marina Sergeyevna to find a mistake.

The first input line contains two numbers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of days in Berland holidays and the number of people in charge of the watering respectively. The next *m* lines contain the description of the duty schedule. Each line contains two integers *a**i* and *b**i* (1<=≤<=*a**i*<=≤<=*b**i*<=≤<=*n*), meaning that the *i*-th person in charge should water the flowers from the *a**i*-th to the *b**i*-th day inclusively, once a day. The duty shifts are described sequentially, i.e. *b**i*<=≤<=*a**i*<=+<=1 for all *i* from 1 to *n*<=-<=1 inclusively.

Print "OK" (without quotes), if the schedule does not contain mistakes. Otherwise you have to find the minimal number of a day when the flowers will not be watered or will be watered multiple times, and output two integers — the day number and the number of times the flowers will be watered that day.

[ "10 5\n1 2\n3 3\n4 6\n7 7\n8 10\n", "10 5\n1 2\n2 3\n4 5\n7 8\n9 10\n", "10 5\n1 2\n3 3\n5 7\n7 7\n7 10\n" ]

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

Keep in mind that in the second sample the mistake occurs not only on the second day, but also on the sixth day, when nobody waters the flowers. However, you have to print the second day, i.e. the day with the minimal number.

0

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

1,592,547,833

2,147,483,647

PyPy 3

OK

TESTS

35

310

0

n,m=map(int,input().split()) a=[0]*(n+1) for _ in range(m): L,R=map(int,input().split()) for x in range(L,R+1): a[x]+=1 x=0 for i in range(1,n+1): if a[i]!=1: x=i break print("OK") if x==0 else print(x, a[x])

Title: Holidays Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: School holidays come in Berland. The holidays are going to continue for *n* days. The students of school №*N* are having the time of their lives and the IT teacher Marina Sergeyevna, who has spent all the summer busy checking the BSE (Berland State Examination) results, has finally taken a vacation break! Some people are in charge of the daily watering of flowers in shifts according to the schedule. However when Marina Sergeyevna was making the schedule, she was so tired from work and so lost in dreams of the oncoming vacation that she perhaps made several mistakes. In fact, it is possible that according to the schedule, on some days during the holidays the flowers will not be watered or will be watered multiple times. Help Marina Sergeyevna to find a mistake. Input Specification: The first input line contains two numbers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of days in Berland holidays and the number of people in charge of the watering respectively. The next *m* lines contain the description of the duty schedule. Each line contains two integers *a**i* and *b**i* (1<=≤<=*a**i*<=≤<=*b**i*<=≤<=*n*), meaning that the *i*-th person in charge should water the flowers from the *a**i*-th to the *b**i*-th day inclusively, once a day. The duty shifts are described sequentially, i.e. *b**i*<=≤<=*a**i*<=+<=1 for all *i* from 1 to *n*<=-<=1 inclusively. Output Specification: Print "OK" (without quotes), if the schedule does not contain mistakes. Otherwise you have to find the minimal number of a day when the flowers will not be watered or will be watered multiple times, and output two integers — the day number and the number of times the flowers will be watered that day. Demo Input: ['10 5\n1 2\n3 3\n4 6\n7 7\n8 10\n', '10 5\n1 2\n2 3\n4 5\n7 8\n9 10\n', '10 5\n1 2\n3 3\n5 7\n7 7\n7 10\n'] Demo Output: ['OK\n', '2 2\n', '4 0\n'] Note: Keep in mind that in the second sample the mistake occurs not only on the second day, but also on the sixth day, when nobody waters the flowers. However, you have to print the second day, i.e. the day with the minimal number.

```python n,m=map(int,input().split()) a=[0]*(n+1) for _ in range(m): L,R=map(int,input().split()) for x in range(L,R+1): a[x]+=1 x=0 for i in range(1,n+1): if a[i]!=1: x=i break print("OK") if x==0 else print(x, a[x]) ```

3.9225

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,678,542,095

2,147,483,647

Python 3

OK

TESTS

30

46

0

ll=(list(map(int,input().split(' ')))) print(min(ll),abs(ll[1]-ll[0])//2)

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 ll=(list(map(int,input().split(' ')))) print(min(ll),abs(ll[1]-ll[0])//2) ```

3

146

B

Lucky Mask

PROGRAMMING

1,300

[ "brute force", "implementation" ]

null

Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya calls a mask of a positive integer *n* the number that is obtained after successive writing of all lucky digits of number *n* from the left to the right. For example, the mask of number 72174994 is number 7744, the mask of 7 is 7, the mask of 9999047 is 47. Obviously, mask of any number is always a lucky number. Petya has two numbers — an arbitrary integer *a* and a lucky number *b*. Help him find the minimum number *c* (*c*<=><=*a*) such that the mask of number *c* equals *b*.

The only line contains two integers *a* and *b* (1<=≤<=*a*,<=*b*<=≤<=105). It is guaranteed that number *b* is lucky.

In the only line print a single number — the number *c* that is sought by Petya.

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

[ "7\n", "147\n" ]

none

1,000

[ { "input": "1 7", "output": "7" }, { "input": "100 47", "output": "147" }, { "input": "458 47", "output": "467" }, { "input": "7 7", "output": "17" }, { "input": "547 47", "output": "647" }, { "input": "77 77", "output": "177" }, { "input": "44 4", "output": "45" }, { "input": "740 4", "output": "804" }, { "input": "100000 77777", "output": "177777" }, { "input": "77777 77777", "output": "177777" }, { "input": "47 74", "output": "74" }, { "input": "74 77", "output": "77" }, { "input": "77 74", "output": "174" }, { "input": "98545 7474", "output": "107474" }, { "input": "99997 4", "output": "100004" }, { "input": "100000 7", "output": "100007" }, { "input": "99997 47", "output": "100047" }, { "input": "47774 774", "output": "50774" }, { "input": "47744 7", "output": "50007" }, { "input": "45896 4", "output": "45898" }, { "input": "45679 77777", "output": "77777" }, { "input": "99979 77", "output": "100077" }, { "input": "10 77777", "output": "77777" }, { "input": "1 47774", "output": "47774" }, { "input": "47774 47774", "output": "147774" }, { "input": "47580 47774", "output": "47774" }, { "input": "55557 74", "output": "55574" }, { "input": "59765 4774", "output": "64774" }, { "input": "76492 447", "output": "80447" }, { "input": "69700 77477", "output": "77477" }, { "input": "31975 74", "output": "32074" }, { "input": "369 47", "output": "407" }, { "input": "39999 4", "output": "40000" }, { "input": "39999 4774", "output": "40774" }, { "input": "474 74", "output": "574" }, { "input": "40007 74444", "output": "74444" }, { "input": "40007 74", "output": "50074" }, { "input": "1 4", "output": "4" }, { "input": "4 4", "output": "14" }, { "input": "700 74", "output": "704" }, { "input": "476 47", "output": "478" }, { "input": "99999 77", "output": "100077" }, { "input": "46 7", "output": "57" } ]

1,635,961,003

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

92

4,505,600

a,b=map(int,input().split()) c=b while c<=a: c+=10**(len(str(b))) if (a-c)>0 and (a-c)<10**(len(str(a))): c+=(a-c)+1 print(c)

Title: Lucky Mask Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya calls a mask of a positive integer *n* the number that is obtained after successive writing of all lucky digits of number *n* from the left to the right. For example, the mask of number 72174994 is number 7744, the mask of 7 is 7, the mask of 9999047 is 47. Obviously, mask of any number is always a lucky number. Petya has two numbers — an arbitrary integer *a* and a lucky number *b*. Help him find the minimum number *c* (*c*<=><=*a*) such that the mask of number *c* equals *b*. Input Specification: The only line contains two integers *a* and *b* (1<=≤<=*a*,<=*b*<=≤<=105). It is guaranteed that number *b* is lucky. Output Specification: In the only line print a single number — the number *c* that is sought by Petya. Demo Input: ['1 7\n', '100 47\n'] Demo Output: ['7\n', '147\n'] Note: none

```python a,b=map(int,input().split()) c=b while c<=a: c+=10**(len(str(b))) if (a-c)>0 and (a-c)<10**(len(str(a))): c+=(a-c)+1 print(c) ```

0

676

C

Vasya and String

PROGRAMMING

1,500

[ "binary search", "dp", "strings", "two pointers" ]

null

High school student Vasya got a string of length *n* as a birthday present. This string consists of letters 'a' and 'b' only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequence) consisting of equal letters. Vasya can change no more than *k* characters of the original string. What is the maximum beauty of the string he can achieve?

The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000,<=0<=≤<=*k*<=≤<=*n*) — the length of the string and the maximum number of characters to change. The second line contains the string, consisting of letters 'a' and 'b' only.

Print the only integer — the maximum beauty of the string Vasya can achieve by changing no more than *k* characters.

[ "4 2\nabba\n", "8 1\naabaabaa\n" ]

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

In the first sample, Vasya can obtain both strings "aaaa" and "bbbb". In the second sample, the optimal answer is obtained with the string "aaaaabaa" or with the string "aabaaaaa".

1,500

[ { "input": "4 2\nabba", "output": "4" }, { "input": "8 1\naabaabaa", "output": "5" }, { "input": "1 0\na", "output": "1" }, { "input": "1 1\nb", "output": "1" }, { "input": "1 0\nb", "output": "1" }, { "input": "1 1\na", "output": "1" }, { "input": "10 10\nbbbbbbbbbb", "output": "10" }, { "input": "10 2\nbbbbbbbbbb", "output": "10" }, { "input": "10 1\nbbabbabbba", "output": "6" }, { "input": "10 10\nbbabbbaabb", "output": "10" }, { "input": "10 9\nbabababbba", "output": "10" }, { "input": "10 4\nbababbaaab", "output": "9" }, { "input": "10 10\naabaaabaaa", "output": "10" }, { "input": "10 10\naaaabbbaaa", "output": "10" }, { "input": "10 1\nbaaaaaaaab", "output": "9" }, { "input": "10 5\naaaaabaaaa", "output": "10" }, { "input": "10 4\naaaaaaaaaa", "output": "10" }, { "input": "100 10\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "100" }, { "input": "100 7\nbbbbabbbbbaabbbabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbabbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbab", "output": "93" }, { "input": "100 30\nbbaabaaabbbbbbbbbbaababababbbbbbaabaabbbbbbbbabbbbbabbbbabbbbbbbbaabbbbbbbbbabbbbbabbbbbbbbbaaaaabba", "output": "100" }, { "input": "100 6\nbaababbbaabbabbaaabbabbaabbbbbbbbaabbbabbbbaabbabbbbbabababbbbabbbbbbabbbbbbbbbaaaabbabbbbaabbabaabb", "output": "34" }, { "input": "100 45\naabababbabbbaaabbbbbbaabbbabbaabbbbbabbbbbbbbabbbbbbabbaababbaabbababbbbbbababbbbbaabbbbbbbaaaababab", "output": "100" }, { "input": "100 2\nababaabababaaababbaaaabbaabbbababbbaaabbbbabababbbabababaababaaabaabbbbaaabbbabbbbbabbbbbbbaabbabbba", "output": "17" }, { "input": "100 25\nbabbbaaababaaabbbaabaabaabbbabbabbbbaaaaaaabaaabaaaaaaaaaabaaaabaaabbbaaabaaababaaabaabbbbaaaaaaaaaa", "output": "80" }, { "input": "100 14\naabaaaaabababbabbabaaaabbaaaabaaabbbaaabaaaaaaaabaaaaabbaaaaaaaaabaaaaaaabbaababaaaababbbbbabaaaabaa", "output": "61" }, { "input": "100 8\naaaaabaaaabaabaaaaaaaabaaaabaaaaaaaaaaaaaabaaaaabaaaaaaaaaaaaaaaaabaaaababaabaaaaaaaaaaaaabbabaaaaaa", "output": "76" }, { "input": "100 12\naaaaaaaaaaaaaaaabaaabaaaaaaaaaabbaaaabbabaaaaaaaaaaaaaaaaaaaaabbaaabaaaaaaaaaaaabaaaaaaaabaaaaaaaaaa", "output": "100" }, { "input": "100 65\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "100" }, { "input": "10 0\nbbbbbbbbbb", "output": "10" }, { "input": "10 0\nbbbbabbbbb", "output": "5" }, { "input": "10 0\nbbabbbabba", "output": "3" }, { "input": "10 0\nbaabbbbaba", "output": "4" }, { "input": "10 0\naababbbbaa", "output": "4" }, { "input": "10 2\nabbbbbaaba", "output": "8" }, { "input": "10 0\nabbaaabaaa", "output": "3" }, { "input": "10 0\naabbaaabaa", "output": "3" }, { "input": "10 1\naaaaaababa", "output": "8" }, { "input": "10 0\nbaaaaaaaaa", "output": "9" }, { "input": "10 0\naaaaaaaaaa", "output": "10" }, { "input": "100 0\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "100" }, { "input": "100 0\nbbbbbbbbbbabbbbaaabbbbbbbbbbbabbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbabbbbbbbbbbbbbab", "output": "40" }, { "input": "100 11\nbaabbbbbababbbbabbbbbbbabbbbbbbbbbbbbbabbbbbbababbbbababbbbaaabbbbabbbbbabbbbbbbbabababbbabbbbbbbabb", "output": "65" }, { "input": "100 8\nbbababbbbbaabbbaaababbbbababababbbbababbabbbabbbbbaabbbabbbababbabbbbabbbabbbbaabbbbabbbaabbbbaaaabb", "output": "33" }, { "input": "100 21\nabbaaaabbbababaabbbababbbbbbbbabbaababababbbabbbaaabbaaabbbbabbabbbabbbabaababbbabbbbbabbbbbbabbbbab", "output": "65" }, { "input": "100 9\nabbbaabaabaaaaaaabbabbbababbaaabbbaaabbaabaaaaabbbbbabbaabaabbbbbaaaaababbaaabbabaabaaabababbaababbb", "output": "26" }, { "input": "100 5\naababababbaaaaaaaabbbabaaaabbabaaaabbaabaaaaabababbabaabaaabaaaaaaaabaababbabbaaabaabbabbaaaaabbabba", "output": "22" }, { "input": "100 9\naababaabaaaaaaaaabbbaabaaaaaaabaaaaaaaaaaaaabaaabaabaabbbbabbaababbabbaaaabbababaabaababaabaaaaaaaaa", "output": "49" }, { "input": "100 6\naaaaabbaaaaaaaaaaabaaaabaaaaaaaaabaaabaaaaaabaaaaaaaaaaabaabaaaabaaaaaaaaaaaaaaabaabbaaaaaaaaaaaaaaa", "output": "56" }, { "input": "100 7\nabaaabaabaabaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaabaaaaaaabbabaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaba", "output": "86" }, { "input": "100 0\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "100" } ]

1,666,423,224

2,147,483,647

PyPy 3-64

OK

TESTS

117

93

3,481,600

import sys import math import bisect import heapq import itertools from sys import stdin,stdout from math import gcd,floor,sqrt,log from collections import defaultdict, Counter, deque from bisect import bisect_left,bisect_right, insort_left, insort_right mod=1000000007 def get_ints(): return map(int, sys.stdin.readline().strip().split()) def get_list(): return list(map(int, sys.stdin.readline().strip().split())) def get_string(): return sys.stdin.readline().strip() def get_int(): return int(sys.stdin.readline().strip()) def get_list_strings(): return list(map(str, sys.stdin.readline().strip().split())) def solve(char, k): left = 0 ans = 0 count = 0 for right in range(len(s)): if s[right] == char: count += 1 if count > k: while count > k: count -= int(s[left] == char) left += 1 ans = max(ans, right - left + 1) return ans if __name__ == "__main__": n, k = get_ints() s = get_string() print(max(solve('a', k), solve('b', k)))

Title: Vasya and String Time Limit: None seconds Memory Limit: None megabytes Problem Description: High school student Vasya got a string of length *n* as a birthday present. This string consists of letters 'a' and 'b' only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequence) consisting of equal letters. Vasya can change no more than *k* characters of the original string. What is the maximum beauty of the string he can achieve? Input Specification: The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000,<=0<=≤<=*k*<=≤<=*n*) — the length of the string and the maximum number of characters to change. The second line contains the string, consisting of letters 'a' and 'b' only. Output Specification: Print the only integer — the maximum beauty of the string Vasya can achieve by changing no more than *k* characters. Demo Input: ['4 2\nabba\n', '8 1\naabaabaa\n'] Demo Output: ['4\n', '5\n'] Note: In the first sample, Vasya can obtain both strings "aaaa" and "bbbb". In the second sample, the optimal answer is obtained with the string "aaaaabaa" or with the string "aabaaaaa".

```python import sys import math import bisect import heapq import itertools from sys import stdin,stdout from math import gcd,floor,sqrt,log from collections import defaultdict, Counter, deque from bisect import bisect_left,bisect_right, insort_left, insort_right mod=1000000007 def get_ints(): return map(int, sys.stdin.readline().strip().split()) def get_list(): return list(map(int, sys.stdin.readline().strip().split())) def get_string(): return sys.stdin.readline().strip() def get_int(): return int(sys.stdin.readline().strip()) def get_list_strings(): return list(map(str, sys.stdin.readline().strip().split())) def solve(char, k): left = 0 ans = 0 count = 0 for right in range(len(s)): if s[right] == char: count += 1 if count > k: while count > k: count -= int(s[left] == char) left += 1 ans = max(ans, right - left + 1) return ans if __name__ == "__main__": n, k = get_ints() s = get_string() print(max(solve('a', k), solve('b', k))) ```

3

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,537,648,598

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

11

340

0

readints=lambda:map(int, input().strip('\n').split()) n,m,a,b=readints() a-=1 b-=1 # 0-index ra=a//m rb=b//m ia=a%m ib=b%m if (ra==rb) or (ia==0 and b==n-1) or (ia==0 and ib==m-1): print(1) elif (ia==0 and ib<m-1 and b!=n-1) or (ia>0 and ib==m-1) or (ra+1==rb) or (ib+1==ia): print(2) else: print(3)

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 readints=lambda:map(int, input().strip('\n').split()) n,m,a,b=readints() a-=1 b-=1 # 0-index ra=a//m rb=b//m ia=a%m ib=b%m if (ra==rb) or (ia==0 and b==n-1) or (ia==0 and ib==m-1): print(1) elif (ia==0 and ib<m-1 and b!=n-1) or (ia>0 and ib==m-1) or (ra+1==rb) or (ib+1==ia): print(2) else: print(3) ```

0

625

C

K-special Tables

PROGRAMMING

1,300

[ "constructive algorithms", "implementation" ]

null

People do many crazy things to stand out in a crowd. Some of them dance, some learn by heart rules of Russian language, some try to become an outstanding competitive programmers, while others collect funny math objects. Alis is among these collectors. Right now she wants to get one of *k*-special tables. In case you forget, the table *n*<=×<=*n* is called *k*-special if the following three conditions are satisfied: - every integer from 1 to *n*2 appears in the table exactly once; - in each row numbers are situated in increasing order; - the sum of numbers in the *k*-th column is maximum possible. Your goal is to help Alice and find at least one *k*-special table of size *n*<=×<=*n*. Both rows and columns are numbered from 1 to *n*, with rows numbered from top to bottom and columns numbered from left to right.

The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=500,<=1<=≤<=*k*<=≤<=*n*) — the size of the table Alice is looking for and the column that should have maximum possible sum.

First print the sum of the integers in the *k*-th column of the required table. Next *n* lines should contain the description of the table itself: first line should contains *n* elements of the first row, second line should contain *n* elements of the second row and so on. If there are multiple suitable table, you are allowed to print any.

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

[ "28\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16\n", "85\n5 6 17 18 19\n9 10 23 24 25\n7 8 20 21 22\n3 4 14 15 16\n1 2 11 12 13\n\n" ]

none

1,000

[ { "input": "4 1", "output": "28\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16" }, { "input": "5 3", "output": "85\n1 2 11 12 13\n3 4 14 15 16\n5 6 17 18 19\n7 8 20 21 22\n9 10 23 24 25" }, { "input": "1 1", "output": "1\n1" }, { "input": "2 1", "output": "4\n1 2\n3 4" }, { "input": "2 2", "output": "7\n1 3\n2 4" }, { "input": "500 1", "output": "62375500\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "3 1", "output": "12\n1 2 3\n4 5 6\n7 8 9" }, { "input": "3 2", "output": "18\n1 4 5\n2 6 7\n3 8 9" }, { "input": "3 3", "output": "24\n1 2 7\n3 4 8\n5 6 9" }, { "input": "4 2", "output": "38\n1 5 6 7\n2 8 9 10\n3 11 12 13\n4 14 15 16" }, { "input": "4 3", "output": "48\n1 2 9 10\n3 4 11 12\n5 6 13 14\n7 8 15 16" }, { "input": "4 4", "output": "58\n1 2 3 13\n4 5 6 14\n7 8 9 15\n10 11 12 16" }, { "input": "5 1", "output": "55\n1 2 3 4 5\n6 7 8 9 10\n11 12 13 14 15\n16 17 18 19 20\n21 22 23 24 25" }, { "input": "5 2", "output": "70\n1 6 7 8 9\n2 10 11 12 13\n3 14 15 16 17\n4 18 19 20 21\n5 22 23 24 25" }, { "input": "5 4", "output": "100\n1 2 3 16 17\n4 5 6 18 19\n7 8 9 20 21\n10 11 12 22 23\n13 14 15 24 25" }, { "input": "5 5", "output": "115\n1 2 3 4 21\n5 6 7 8 22\n9 10 11 12 23\n13 14 15 16 24\n17 18 19 20 25" }, { "input": "6 1", "output": "96\n1 2 3 4 5 6\n7 8 9 10 11 12\n13 14 15 16 17 18\n19 20 21 22 23 24\n25 26 27 28 29 30\n31 32 33 34 35 36" }, { "input": "6 2", "output": "117\n1 7 8 9 10 11\n2 12 13 14 15 16\n3 17 18 19 20 21\n4 22 23 24 25 26\n5 27 28 29 30 31\n6 32 33 34 35 36" }, { "input": "6 3", "output": "138\n1 2 13 14 15 16\n3 4 17 18 19 20\n5 6 21 22 23 24\n7 8 25 26 27 28\n9 10 29 30 31 32\n11 12 33 34 35 36" }, { "input": "6 4", "output": "159\n1 2 3 19 20 21\n4 5 6 22 23 24\n7 8 9 25 26 27\n10 11 12 28 29 30\n13 14 15 31 32 33\n16 17 18 34 35 36" }, { "input": "6 5", "output": "180\n1 2 3 4 25 26\n5 6 7 8 27 28\n9 10 11 12 29 30\n13 14 15 16 31 32\n17 18 19 20 33 34\n21 22 23 24 35 36" }, { "input": "6 6", "output": "201\n1 2 3 4 5 31\n6 7 8 9 10 32\n11 12 13 14 15 33\n16 17 18 19 20 34\n21 22 23 24 25 35\n26 27 28 29 30 36" }, { "input": "500 500", "output": "124875250\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 ..." }, { "input": "500 250", "output": "93562750\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "94 3", "output": "419898\n1 2 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280\n3 4 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 31..." }, { "input": "22 4", "output": "5863\n1 2 3 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85\n4 5 6 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104\n7 8 9 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123\n10 11 12 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142\n13 14 15 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161\n16 17 18 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180\n19 20 21 181 182 183 184 185 18..." }, { "input": "15 12", "output": "2910\n1 2 3 4 5 6 7 8 9 10 11 166 167 168 169\n12 13 14 15 16 17 18 19 20 21 22 170 171 172 173\n23 24 25 26 27 28 29 30 31 32 33 174 175 176 177\n34 35 36 37 38 39 40 41 42 43 44 178 179 180 181\n45 46 47 48 49 50 51 52 53 54 55 182 183 184 185\n56 57 58 59 60 61 62 63 64 65 66 186 187 188 189\n67 68 69 70 71 72 73 74 75 76 77 190 191 192 193\n78 79 80 81 82 83 84 85 86 87 88 194 195 196 197\n89 90 91 92 93 94 95 96 97 98 99 198 199 200 201\n100 101 102 103 104 105 106 107 108 109 110 202 203 204 205\n111..." }, { "input": "37 35", "output": "48581\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 1259 1260 1261\n35 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 1262 1263 1264\n69 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 101 102 1265 1266 1267\n103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 1268 1269 1270\n137 ..." }, { "input": "87 51", "output": "516954\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 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387\n51 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 4388 4389 4390 4391 4392 ..." }, { "input": "15 4", "output": "1950\n1 2 3 46 47 48 49 50 51 52 53 54 55 56 57\n4 5 6 58 59 60 61 62 63 64 65 66 67 68 69\n7 8 9 70 71 72 73 74 75 76 77 78 79 80 81\n10 11 12 82 83 84 85 86 87 88 89 90 91 92 93\n13 14 15 94 95 96 97 98 99 100 101 102 103 104 105\n16 17 18 106 107 108 109 110 111 112 113 114 115 116 117\n19 20 21 118 119 120 121 122 123 124 125 126 127 128 129\n22 23 24 130 131 132 133 134 135 136 137 138 139 140 141\n25 26 27 142 143 144 145 146 147 148 149 150 151 152 153\n28 29 30 154 155 156 157 158 159 160 161 162 1..." }, { "input": "183 2", "output": "3064518\n1 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 ..." }, { "input": "103 6", "output": "567942\n1 2 3 4 5 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613\n6 7 8 9 10 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 6..." }, { "input": "131 11", "output": "1202056\n1 2 3 4 5 6 7 8 9 10 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1..." }, { "input": "193 186", "output": "7039482\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." }, { "input": "117 109", "output": "1539603\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 101 102 103 104 105 106 107 108 12637 12638 12639 12640 12641 12642 12643 12644 12645\n109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139..." }, { "input": "116 91", "output": "1384576\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 10441 10442 10443 10444 10445 10446 10447 10448 10449 10450 10451 10452 10453 10454 10455 10456 10457 10458 10459 10460 10461 10462 10463 10464 10465 10466\n91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 1..." }, { "input": "140 79", "output": "2132200\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 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938 10939 10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 1..." }, { "input": "350 14", "output": "22175125\n1 2 3 4 5 6 7 8 9 10 11 12 13 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4..." }, { "input": "374 9", "output": "26648248\n1 2 3 4 5 6 7 8 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 ..." }, { "input": "265 255", "output": "18222195\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "289 287", "output": "24012143\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "276 11", "output": "10856736\n1 2 3 4 5 6 7 8 9 10 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 ..." }, { "input": "204 7", "output": "4349688\n1 2 3 4 5 6 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 ..." }, { "input": "425 15", "output": "39560275\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 604..." }, { "input": "449 6", "output": "45664198\n1 2 3 4 5 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2..." }, { "input": "477 19", "output": "56204433\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8..." }, { "input": "448 437", "output": "88708928\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "472 459", "output": "103591728\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 ..." }, { "input": "500 494", "output": "124123750\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 ..." }, { "input": "462 318", "output": "83103405\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "486 481", "output": "114081696\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 ..." }, { "input": "410 361", "output": "64708660\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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." } ]

1,558,607,754

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

93

0

n, k = map(int, input().split()) a = [] for i in range(n): a.append([0]*n) st = 1 for i in range(k-1): for j in range(n): a[j][i] = st st += 1 for i in range(n): for j in range(k-1, n): a[i][j] = st st += 1 ans = 0 for i in range(n): ans += a[i][k-1] for i in range(n): for j in range(n): print(a[i][j], end = ' ') print('\n')

Title: K-special Tables Time Limit: None seconds Memory Limit: None megabytes Problem Description: People do many crazy things to stand out in a crowd. Some of them dance, some learn by heart rules of Russian language, some try to become an outstanding competitive programmers, while others collect funny math objects. Alis is among these collectors. Right now she wants to get one of *k*-special tables. In case you forget, the table *n*<=×<=*n* is called *k*-special if the following three conditions are satisfied: - every integer from 1 to *n*2 appears in the table exactly once; - in each row numbers are situated in increasing order; - the sum of numbers in the *k*-th column is maximum possible. Your goal is to help Alice and find at least one *k*-special table of size *n*<=×<=*n*. Both rows and columns are numbered from 1 to *n*, with rows numbered from top to bottom and columns numbered from left to right. Input Specification: The first line of the input contains two integers *n* and *k* (1<=≤<=*n*<=≤<=500,<=1<=≤<=*k*<=≤<=*n*) — the size of the table Alice is looking for and the column that should have maximum possible sum. Output Specification: First print the sum of the integers in the *k*-th column of the required table. Next *n* lines should contain the description of the table itself: first line should contains *n* elements of the first row, second line should contain *n* elements of the second row and so on. If there are multiple suitable table, you are allowed to print any. Demo Input: ['4 1\n', '5 3\n'] Demo Output: ['28\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16\n', '85\n5 6 17 18 19\n9 10 23 24 25\n7 8 20 21 22\n3 4 14 15 16\n1 2 11 12 13\n\n'] Note: none

```python n, k = map(int, input().split()) a = [] for i in range(n): a.append([0]*n) st = 1 for i in range(k-1): for j in range(n): a[j][i] = st st += 1 for i in range(n): for j in range(k-1, n): a[i][j] = st st += 1 ans = 0 for i in range(n): ans += a[i][k-1] for i in range(n): for j in range(n): print(a[i][j], end = ' ') print('\n') ```

0

94

A

Restoring Password

PROGRAMMING

900

[ "implementation", "strings" ]

A. Restoring Password

2

256

Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password". Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" — thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address. Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits. Help Igor K. restore his ISQ account by the encrypted password and encryption specification.

The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.

Print one line containing 8 characters — The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.

[ "01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110\n", "10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000\n" ]

[ "12345678\n", "30234919\n" ]

none

500

[ { "input": "01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110", "output": "12345678" }, { "input": "10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000", "output": "30234919" }, { "input": "00010101101110110101100110101100010101100010101111000101011010011010110010000011\n0101010110\n0001001101\n1001101011\n0000100011\n0010101111\n1110110101\n0001010110\n0110111000\n0000111110\n0010000011", "output": "65264629" }, { "input": "10100100010010010011011001101000100100110110011010011001101011000100110110011010\n1111110011\n1001000111\n1001000100\n1100010011\n0110011010\n0010000001\n1110101110\n0010000110\n0010010011\n1010010001", "output": "98484434" }, { "input": "00101100011111010001001000000110110000000110010011001111111010110010001011000000\n0010000001\n0110010011\n0010000010\n1011001000\n0011111110\n0110001000\n1111010001\n1011000000\n0000100110\n0010110001", "output": "96071437" }, { "input": "10001110111110000001000010001010001110110000100010100010111101101101010000100010\n0000010110\n1101010111\n1000101111\n0001011110\n0011110101\n0101100100\n0110110101\n0000100010\n1000111011\n1110000001", "output": "89787267" }, { "input": "10010100011001010001010101001101010100110100111011001010111100011001000010100000\n0011100000\n1001100100\n0001100100\n0010100000\n0101010011\n0010101110\n0010101111\n0100111011\n1001010001\n1111111110", "output": "88447623" }, { "input": "01101100111000000101011011001110000001011111111000111111100001011010001001011001\n1000000101\n0101101000\n0101110101\n1101011110\n0000101100\n1111111000\n0001001101\n0110111011\n0110110011\n1001011001", "output": "80805519" }, { "input": "11100011000100010110010011101010101010011110001100011010111110011000011010110111\n1110001100\n0110101111\n0100111010\n0101000000\n1001100001\n1010101001\n0000100010\n1010110111\n1100011100\n0100010110", "output": "09250147" }, { "input": "10000110110000010100000010001000111101110110101011110111000100001101000000100010\n0000010100\n0000110001\n0110101011\n1101110001\n1000011011\n0000110100\n0011110111\n1000110010\n0000100010\n0000011011", "output": "40862358" }, { "input": "01000000010000000110100101000110110000100100000001101100001000011111111001010001\n1011000010\n1111101010\n0111110011\n0000000110\n0000001001\n0001111111\n0110010010\n0100000001\n1011001000\n1001010001", "output": "73907059" }, { "input": "01111000111110011001110101110011110000111110010001101100110110100111101011001101\n1110010001\n1001100000\n1100001000\n1010011110\n1011001101\n0111100011\n1101011100\n1110011001\n1111000011\n0010000101", "output": "57680434" }, { "input": "01001100101000100010001011110001000101001001100010010000001001001100101001011111\n1001011111\n1110010111\n0111101011\n1000100010\n0011100101\n0100000010\n0010111100\n0100010100\n1001100010\n0100110010", "output": "93678590" }, { "input": "01110111110000111011101010110110101011010100110111000011101101110101011101001000\n0110000101\n1010101101\n1101010111\n1101011100\n0100110111\n0111011111\n1100011001\n0111010101\n0000111011\n1101001000", "output": "58114879" }, { "input": "11101001111100110101110011010100110011011110100111010110110011000111000011001101\n1100011100\n1100110101\n1011101000\n0011011110\n0011001101\n0100010001\n1110100111\n1010101100\n1110110100\n0101101100", "output": "61146904" }, { "input": "10101010001011010001001001011000100101100001011011101010101110101010001010101000\n0010110101\n1010011010\n1010101000\n1011010001\n1010101011\n0010010110\n0110100010\n1010100101\n0001011011\n0110100001", "output": "23558422" }, { "input": "11110101001100010000110100001110101011011111010100110001000001001010001001101111\n0101101100\n1001101111\n1010101101\n0100101000\n1111110000\n0101010010\n1100010000\n1111010100\n1101000011\n1011111111", "output": "76827631" }, { "input": "10001100110000110111100011001101111110110011110101000011011100001101110000110111\n0011110101\n0101100011\n1000110011\n1011011001\n0111111011\n0101111011\n0000110111\n0100001110\n1000000111\n0110110111", "output": "26240666" }, { "input": "10000100010000111101100100111101111011101000001001100001000110000010010000111101\n1001001111\n0000111101\n1000010001\n0110011101\n0110101000\n1011111001\n0111101110\n1000001001\n1101011111\n0001010100", "output": "21067271" }, { "input": "01101111000110111100011011110001101111001010001100101000110001010101100100000010\n1010001100\n0011010011\n0101010110\n1111001100\n1100011000\n0100101100\n1001100101\n0110111100\n0011001101\n0100000010", "output": "77770029" }, { "input": "10100111011010001011111000000111100000010101000011000010111101010000111010011101\n1010011101\n1010111111\n0110100110\n1111000100\n1110000001\n0000101111\n0011111000\n1000110001\n0101000011\n1010001011", "output": "09448580" }, { "input": "10000111111000011111001010101010010011111001001111000010010100100011000010001100\n1101101110\n1001001111\n0000100101\n1100111010\n0010101010\n1110000110\n1100111101\n0010001100\n1110000001\n1000011111", "output": "99411277" }, { "input": "10110110111011001111101100111100111111011011011011001111110110010011100010000111\n0111010011\n0111101100\n1001101010\n0101000101\n0010000111\n0011111101\n1011001111\n1101111000\n1011011011\n1001001110", "output": "86658594" }, { "input": "01001001100101100011110110111100000110001111001000100000110111110010000000011000\n0100100110\n1000001011\n1000111110\n0000011000\n0101100011\n1101101111\n1111001000\n1011011001\n1000001101\n0010101000", "output": "04536863" }, { "input": "10010100011101000011100100001100101111000010111100000010010000001001001101011101\n1001000011\n1101000011\n1001010001\n1101011101\n1000010110\n0011111101\n0010111100\n0000100100\n1010001000\n0101000110", "output": "21066773" }, { "input": "01111111110101111111011111111111010010000001100000101000100100111001011010001001\n0111111111\n0101111111\n0100101101\n0001100000\n0011000101\n0011100101\n1101001000\n0010111110\n1010001001\n1111000111", "output": "01063858" }, { "input": "00100011111001001010001111000011101000001110100000000100101011101000001001001010\n0010001111\n1001001010\n1010011001\n0011100111\n1000111000\n0011110000\n0000100010\n0001001010\n1111110111\n1110100000", "output": "01599791" }, { "input": "11011101000100110100110011010101100011111010011010010011010010010010100110101111\n0100110100\n1001001010\n0001111101\n1101011010\n1101110100\n1100110101\n0110101111\n0110001111\n0001101000\n1010011010", "output": "40579016" }, { "input": "10000010111101110110011000111110000011100110001111100100000111000011011000001011\n0111010100\n1010110110\n1000001110\n1110000100\n0110001111\n1101110110\n1100001101\n1000001011\n0000000101\n1001000001", "output": "75424967" }, { "input": "11101100101110111110111011111010001111111111000001001001000010001111111110110010\n0101100001\n1111010011\n1110111110\n0100110100\n1110011111\n1000111111\n0010010000\n1110110010\n0011000010\n1111000001", "output": "72259657" }, { "input": "01011110100101111010011000001001100000101001110011010111101011010000110110010101\n0100111100\n0101110011\n0101111010\n0110000010\n0101001111\n1101000011\n0110010101\n0111011010\n0001101110\n1001110011", "output": "22339256" }, { "input": "01100000100101111000100001100010000110000010100100100001100000110011101001110000\n0101111000\n1001110000\n0001000101\n0110110111\n0010100100\n1000011000\n1101110110\n0110000010\n0001011010\n0011001110", "output": "70554591" }, { "input": "11110011011000001001111100110101001000010100100000110011001110011111100100100001\n1010011000\n1111001101\n0100100001\n1111010011\n0100100000\n1001111110\n1010100111\n1000100111\n1000001001\n1100110011", "output": "18124952" }, { "input": "10001001011000100101010110011101011001110010000001010110000101000100101111101010\n0101100001\n1100001100\n1111101010\n1000100101\n0010000001\n0100010010\n0010110110\n0101100111\n0000001110\n1101001110", "output": "33774052" }, { "input": "00110010000111001001001100100010010111101011011110001011111100000101000100000001\n0100000001\n1011011110\n0010111111\n0111100111\n0100111001\n0000010100\n1001011110\n0111001001\n0100010011\n0011001000", "output": "97961250" }, { "input": "01101100001000110101101100101111101110010011010111100011010100010001101000110101\n1001101001\n1000110101\n0110110000\n0111100100\n0011010111\n1110111001\n0001000110\n0000000100\n0001101001\n1011001011", "output": "21954161" }, { "input": "10101110000011010110101011100000101101000110100000101101101101110101000011110010\n0110100000\n1011011011\n0011110010\n0001110110\n0010110100\n1100010010\n0001101011\n1010111000\n0011010110\n0111010100", "output": "78740192" }, { "input": "11000101011100100111010000010001000001001100101100000011000000001100000101011010\n1100010101\n1111101011\n0101011010\n0100000100\n1000110111\n1100100111\n1100101100\n0111001000\n0000110000\n0110011111", "output": "05336882" }, { "input": "11110100010000101110010110001000001011100101100010110011011011111110001100110110\n0101100010\n0100010001\n0000101110\n1100110110\n0101000101\n0011001011\n1111010001\n1000110010\n1111111000\n1010011111", "output": "62020383" }, { "input": "00011001111110000011101011010001010111100110100101000110011111011001100000001100\n0111001101\n0101011110\n0001100111\n1101011111\n1110000011\n0000001100\n0111010001\n1101100110\n1010110100\n0110100101", "output": "24819275" }, { "input": "10111110010011111001001111100101010111010011111001001110101000111110011001111101\n0011111001\n0101011101\n0100001010\n0001110010\n1001111101\n0011101010\n1111001001\n1100100001\n1001101000\n1011111001", "output": "90010504" }, { "input": "01111101111100101010001001011110111001110111110111011111011110110111111011011111\n1111110111\n0010000101\n0110000100\n0111111011\n1011100111\n1100101010\n1011011111\n1100010001\n0111110111\n0010010111", "output": "85948866" }, { "input": "01111100000111110000110010111001111100001001101010110010111010001000101001101010\n0100010101\n1011110101\n1010100100\n1010000001\n1001101010\n0101100110\n1000100010\n0111110000\n1100101110\n0110010110", "output": "77874864" }, { "input": "11100011010000000010011110010111001011111001000111000000001000000000100111100101\n0000000010\n1110001101\n0011010101\n0111100101\n1001000111\n1101001111\n0111010110\n1100101111\n0110000000\n1101101011", "output": "10374003" }, { "input": "01111011100111101110011001000110001111101000111110100100100001011111001011100010\n0110010100\n1100010001\n0111101110\n1001001000\n1010011011\n1000111110\n0010110101\n1011100010\n0101111100\n0110010001", "output": "22955387" }, { "input": "11011010001100000011000100110011010101000110011110110000001100111100001000011111\n0000100010\n1000011111\n1101101000\n0110011110\n0011110000\n1100000011\n0010001100\n0101101000\n0001001100\n1101010100", "output": "25893541" }, { "input": "01011001011111010010101111011001000011001100011101101111011011010011101011110110\n0100001100\n0101100101\n1111111011\n1111010010\n1111101100\n1100011101\n1011000011\n1101001110\n1011110110\n0110001010", "output": "13805878" }, { "input": "11110011011000111111001100111110001111111100000010111100110100110011111111001101\n1111001101\n1001101010\n1100110010\n0011001111\n0001011110\n1000110011\n1000111111\n0110001010\n1001011101\n1100000010", "output": "06369030" }, { "input": "01110011110010000011011001011000001000010110010110011001100001100110001100101000\n0000100001\n0110011000\n1010000010\n1110011101\n0111001111\n1100101000\n0010000011\n0110010000\n1100100101\n0110010110", "output": "46909115" }, { "input": "00001011001111110111111111011111111101110101110100010111010010100101100001010110\n1111110111\n0001010110\n0111011011\n0111000001\n1010010110\n0101110100\n0001000101\n0000111000\n0110100001\n0000101100", "output": "90005541" } ]

1,382,962,756

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

31

204,800

s = input() A = dict() res = "" for i in range(10): a = input() A[a] = i j = 0 while j < 80: res += str(A[s[j : (j + 9)]]) j += 10 print(res)

Title: Restoring Password Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password". Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" — thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address. Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits. Help Igor K. restore his ISQ account by the encrypted password and encryption specification. Input Specification: The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9. Output Specification: Print one line containing 8 characters — The password to Igor K.'s ISQ account. It is guaranteed that the solution exists. Demo Input: ['01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110\n', '10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000\n'] Demo Output: ['12345678\n', '30234919\n'] Note: none

```python s = input() A = dict() res = "" for i in range(10): a = input() A[a] = i j = 0 while j < 80: res += str(A[s[j : (j + 9)]]) j += 10 print(res) ```

-1

832

A

Sasha and Sticks

PROGRAMMING

800

[ "games", "math" ]

null

It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends. Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws *n* sticks in a row. After that the players take turns crossing out exactly *k* sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than *k* sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.

The first line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1018, *k*<=≤<=*n*) — the number of sticks drawn by Sasha and the number *k* — the number of sticks to be crossed out on each turn.

If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes). You can print each letter in arbitrary case (upper of lower).

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

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

In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins. In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.

500

[ { "input": "1 1", "output": "YES" }, { "input": "10 4", "output": "NO" }, { "input": "251656215122324104 164397544865601257", "output": "YES" }, { "input": "963577813436662285 206326039287271924", "output": "NO" }, { "input": "1000000000000000000 1", "output": "NO" }, { "input": "253308697183523656 25332878317796706", "output": "YES" }, { "input": "669038685745448997 501718093668307460", "output": "YES" }, { "input": "116453141993601660 87060381463547965", "output": "YES" }, { "input": "766959657 370931668", "output": "NO" }, { "input": "255787422422806632 146884995820359999", "output": "YES" }, { "input": "502007866464507926 71266379084204128", "output": "YES" }, { "input": "257439908778973480 64157133126869976", "output": "NO" }, { "input": "232709385 91708542", "output": "NO" }, { "input": "252482458300407528 89907711721009125", "output": "NO" }, { "input": "6 2", "output": "YES" }, { "input": "6 3", "output": "NO" }, { "input": "6 4", "output": "YES" }, { "input": "6 5", "output": "YES" }, { "input": "6 6", "output": "YES" }, { "input": "258266151957056904 30153168463725364", "output": "NO" }, { "input": "83504367885565783 52285355047292458", "output": "YES" }, { "input": "545668929424440387 508692735816921376", "output": "YES" }, { "input": "547321411485639939 36665750286082900", "output": "NO" }, { "input": "548973893546839491 183137237979822911", "output": "NO" }, { "input": "544068082 193116851", "output": "NO" }, { "input": "871412474 749817171", "output": "YES" }, { "input": "999999999 1247", "output": "NO" }, { "input": "851941088 712987048", "output": "YES" }, { "input": "559922900 418944886", "output": "YES" }, { "input": "293908937 37520518", "output": "YES" }, { "input": "650075786 130049650", "output": "NO" }, { "input": "1000000000 1000000000", "output": "YES" }, { "input": "548147654663723363 107422751713800746", "output": "YES" }, { "input": "828159210 131819483", "output": "NO" }, { "input": "6242634 4110365", "output": "YES" }, { "input": "458601973 245084155", "output": "YES" }, { "input": "349593257 18089089", "output": "YES" }, { "input": "814768821 312514745", "output": "NO" }, { "input": "697884949 626323363", "output": "YES" }, { "input": "667011589 54866795", "output": "NO" }, { "input": "1000000000000000000 2", "output": "NO" }, { "input": "1000000000000000000 3", "output": "YES" }, { "input": "1000000000000000000 4", "output": "NO" }, { "input": "999999999999999 1", "output": "YES" }, { "input": "17 4", "output": "NO" }, { "input": "2 2", "output": "YES" }, { "input": "1000000000000000 2", "output": "NO" }, { "input": "12 4", "output": "YES" }, { "input": "6 1", "output": "NO" }, { "input": "2 1", "output": "NO" }, { "input": "10000000005 1", "output": "YES" }, { "input": "10000000000000009 2", "output": "NO" }, { "input": "12457895452123 1", "output": "YES" }, { "input": "999999999999999999 9", "output": "YES" }, { "input": "1000000000000 3", "output": "YES" }, { "input": "13099714659575475 6549849616514894", "output": "NO" }, { "input": "100000000000000001 1", "output": "YES" }, { "input": "825175814723458 324", "output": "YES" }, { "input": "20 4", "output": "YES" }, { "input": "100000176877 4", "output": "YES" }, { "input": "100000 3", "output": "YES" }, { "input": "946744073709551614 10", "output": "YES" } ]

1,590,326,670

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

4

2,000

0

l = list(map(int, input().split())) def sticks(n,k): if n==k: return "YES" else: s=1 while True: n-=k if n<k and s%2==1: return "YES" elif n<k and s%2==0: return "NO" s+=1 print(sticks(l[0],l[1]))

Title: Sasha and Sticks Time Limit: None seconds Memory Limit: None megabytes Problem Description: It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends. Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws *n* sticks in a row. After that the players take turns crossing out exactly *k* sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than *k* sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him. Input Specification: The first line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1018, *k*<=≤<=*n*) — the number of sticks drawn by Sasha and the number *k* — the number of sticks to be crossed out on each turn. Output Specification: If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes). You can print each letter in arbitrary case (upper of lower). Demo Input: ['1 1\n', '10 4\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins. In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.

```python l = list(map(int, input().split())) def sticks(n,k): if n==k: return "YES" else: s=1 while True: n-=k if n<k and s%2==1: return "YES" elif n<k and s%2==0: return "NO" s+=1 print(sticks(l[0],l[1])) ```

0

268

A

Games

PROGRAMMING

800

[ "brute force" ]

null

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

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

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

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

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

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

500

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

1,678,114,970

2,147,483,647

PyPy 3

OK

TESTS

31

184

0

def f(): n=int(input()) ans=[] for i in range(n): temp=list(map(int,input().split(" "))) ans.append(temp) count=0 for i in range(len(ans)): for j in range(i+1,len(ans)): if ans[i][0]==ans[j][1]: count=count+1 if ans[i][1]==ans[j][0]: count=count+1 return count print(f())

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

```python def f(): n=int(input()) ans=[] for i in range(n): temp=list(map(int,input().split(" "))) ans.append(temp) count=0 for i in range(len(ans)): for j in range(i+1,len(ans)): if ans[i][0]==ans[j][1]: count=count+1 if ans[i][1]==ans[j][0]: count=count+1 return count print(f()) ```

3

298

A

Snow Footprints

PROGRAMMING

1,300

[ "greedy", "implementation" ]

null

There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *i*-th block. Similarly, if one moves from the *i*-th block to the (*i*<=-<=1)-th block, he will leave a left footprint on the *i*-th block. If there already is a footprint on the *i*-th block, the new footprint will cover the old one. At the beginning, there were no footprints. Then polar bear Alice starts from the *s*-th block, makes a sequence of moves and ends in the *t*-th block. It is known that Alice never moves outside of the road. You are given the description of Alice's footprints. Your task is to find a pair of possible values of *s*,<=*t* by looking at the footprints.

The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=1000). The second line contains the description of the road — the string that consists of *n* characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint). It's guaranteed that the given string contains at least one character not equal to ".". Also, the first and the last character will always be ".". It's guaranteed that a solution exists.

Print two space-separated integers — the values of *s* and *t*. If there are several possible solutions you can print any of them.

[ "9\n..RRLL...\n", "11\n.RRRLLLLL..\n" ]

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

The first test sample is the one in the picture.

500

[ { "input": "11\n.RRRLLLLL..", "output": "7 5" }, { "input": "4\n.RL.", "output": "3 2" }, { "input": "3\n.L.", "output": "2 1" }, { "input": "3\n.R.", "output": "2 3" } ]

1,552,164,658

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

216

0

n = int(input()) s = list(input()) r = s.count('R') l = s.count('L') if 'R' not in s: for i in range(n-1, 0, -1): if s[i] == 'L': print(i, end=' ') break for i in range(n): if s[i] == 'L': print(i) exit() if 'L' not in s: for i in range(n): if s[i] == 'R': print(i, end=' ') break for i in range(n-1, 0, -1): if s[i] == 'R': print(i) exit() for i in range(n): if s[i] == 'R': inxr = i break for i in range(n): if s[i] == 'L': inxl = i break print(inxr+1, inxl)

Title: Snow Footprints Time Limit: None seconds Memory Limit: None megabytes Problem Description: There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *i*-th block. Similarly, if one moves from the *i*-th block to the (*i*<=-<=1)-th block, he will leave a left footprint on the *i*-th block. If there already is a footprint on the *i*-th block, the new footprint will cover the old one. At the beginning, there were no footprints. Then polar bear Alice starts from the *s*-th block, makes a sequence of moves and ends in the *t*-th block. It is known that Alice never moves outside of the road. You are given the description of Alice's footprints. Your task is to find a pair of possible values of *s*,<=*t* by looking at the footprints. Input Specification: The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=1000). The second line contains the description of the road — the string that consists of *n* characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint). It's guaranteed that the given string contains at least one character not equal to ".". Also, the first and the last character will always be ".". It's guaranteed that a solution exists. Output Specification: Print two space-separated integers — the values of *s* and *t*. If there are several possible solutions you can print any of them. Demo Input: ['9\n..RRLL...\n', '11\n.RRRLLLLL..\n'] Demo Output: ['3 4\n', '7 5\n'] Note: The first test sample is the one in the picture.

```python n = int(input()) s = list(input()) r = s.count('R') l = s.count('L') if 'R' not in s: for i in range(n-1, 0, -1): if s[i] == 'L': print(i, end=' ') break for i in range(n): if s[i] == 'L': print(i) exit() if 'L' not in s: for i in range(n): if s[i] == 'R': print(i, end=' ') break for i in range(n-1, 0, -1): if s[i] == 'R': print(i) exit() for i in range(n): if s[i] == 'R': inxr = i break for i in range(n): if s[i] == 'L': inxl = i break print(inxr+1, inxl) ```

0

495

B

Modular Equations

PROGRAMMING

1,600

[ "math", "number theory" ]

null

Last week, Hamed learned about a new type of equations in his math class called Modular Equations. Lets define *i* modulo *j* as the remainder of division of *i* by *j* and denote it by . A Modular Equation, as Hamed's teacher described, is an equation of the form in which *a* and *b* are two non-negative integers and *x* is a variable. We call a positive integer *x* for which a solution of our equation. Hamed didn't pay much attention to the class since he was watching a movie. He only managed to understand the definitions of these equations. Now he wants to write his math exercises but since he has no idea how to do that, he asked you for help. He has told you all he knows about Modular Equations and asked you to write a program which given two numbers *a* and *b* determines how many answers the Modular Equation has.

In the only line of the input two space-separated integers *a* and *b* (0<=≤<=*a*,<=*b*<=≤<=109) are given.

If there is an infinite number of answers to our equation, print "infinity" (without the quotes). Otherwise print the number of solutions of the Modular Equation .

[ "21 5\n", "9435152 272\n", "10 10\n" ]

[ "2\n", "282\n", "infinity\n" ]

In the first sample the answers of the Modular Equation are 8 and 16 since <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6f5ff39ebd209bf990adaf91f4b82f9687097224.png" style="max-width: 100.0%;max-height: 100.0%;"/>

1,000

[ { "input": "21 5", "output": "2" }, { "input": "9435152 272", "output": "282" }, { "input": "10 10", "output": "infinity" }, { "input": "0 1000000000", "output": "0" }, { "input": "11 2", "output": "2" }, { "input": "1 0", "output": "1" }, { "input": "0 0", "output": "infinity" }, { "input": "121 0", "output": "3" }, { "input": "772930485 686893955", "output": "0" }, { "input": "257424 24", "output": "127" }, { "input": "295138437 589952171", "output": "0" }, { "input": "223093836 966", "output": "399" }, { "input": "233758336 10665466", "output": "13" }, { "input": "223092887 17", "output": "500" }, { "input": "223094728 1858", "output": "371" }, { "input": "223092899 29", "output": "495" }, { "input": "997920 0", "output": "240" }, { "input": "887043 3", "output": "213" }, { "input": "124 24", "output": "3" }, { "input": "982901 101", "output": "193" }, { "input": "357987 35", "output": "45" }, { "input": "954374 1030", "output": "32" }, { "input": "49106 46", "output": "15" }, { "input": "325508499 119510657", "output": "1" }, { "input": "89768760 885778845", "output": "0" }, { "input": "944387968 700818251", "output": "0" }, { "input": "12 3", "output": "1" }, { "input": "1000000000 1", "output": "19" }, { "input": "923456789 3", "output": "14" }, { "input": "1000000000 6", "output": "6" }, { "input": "1000000000 333333300", "output": "2" }, { "input": "5 2", "output": "1" }, { "input": "1 10", "output": "0" }, { "input": "15 3", "output": "3" }, { "input": "2 0", "output": "2" }, { "input": "77 75", "output": "0" }, { "input": "1000000000 1000000000", "output": "infinity" } ]

1,694,308,379

2,147,483,647

PyPy 3-64

RUNTIME_ERROR

TESTS

3

77

2,764,800

import math def findDivisors(n): d = [] q = [] intRoot = math.isqrt(n) hasExactRoot = intRoot == math.sqrt(n) for i in range(1,intRoot+1): if n % i == 0: div = n // i d.append(i) if not hasExactRoot: q.append(div) elif hasExactRoot and i != intRoot: q.append(div) for i in range(len(q)-1,-1,-1): d.append(q[i]) return d a,b = list(map(int,input().split())) out = "infinity" count = 0 if a != b: # se a = b , n pode assumir qualquer valor c = a - b # se a ≡ b (mod x), (a-b) ≡ 0 (mod x) ds = findDivisors(c) for d in ds: if a % d == b: count += 1 out = count print(out)

Title: Modular Equations Time Limit: None seconds Memory Limit: None megabytes Problem Description: Last week, Hamed learned about a new type of equations in his math class called Modular Equations. Lets define *i* modulo *j* as the remainder of division of *i* by *j* and denote it by . A Modular Equation, as Hamed's teacher described, is an equation of the form in which *a* and *b* are two non-negative integers and *x* is a variable. We call a positive integer *x* for which a solution of our equation. Hamed didn't pay much attention to the class since he was watching a movie. He only managed to understand the definitions of these equations. Now he wants to write his math exercises but since he has no idea how to do that, he asked you for help. He has told you all he knows about Modular Equations and asked you to write a program which given two numbers *a* and *b* determines how many answers the Modular Equation has. Input Specification: In the only line of the input two space-separated integers *a* and *b* (0<=≤<=*a*,<=*b*<=≤<=109) are given. Output Specification: If there is an infinite number of answers to our equation, print "infinity" (without the quotes). Otherwise print the number of solutions of the Modular Equation . Demo Input: ['21 5\n', '9435152 272\n', '10 10\n'] Demo Output: ['2\n', '282\n', 'infinity\n'] Note: In the first sample the answers of the Modular Equation are 8 and 16 since <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6f5ff39ebd209bf990adaf91f4b82f9687097224.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python import math def findDivisors(n): d = [] q = [] intRoot = math.isqrt(n) hasExactRoot = intRoot == math.sqrt(n) for i in range(1,intRoot+1): if n % i == 0: div = n // i d.append(i) if not hasExactRoot: q.append(div) elif hasExactRoot and i != intRoot: q.append(div) for i in range(len(q)-1,-1,-1): d.append(q[i]) return d a,b = list(map(int,input().split())) out = "infinity" count = 0 if a != b: # se a = b , n pode assumir qualquer valor c = a - b # se a ≡ b (mod x), (a-b) ≡ 0 (mod x) ds = findDivisors(c) for d in ds: if a % d == b: count += 1 out = count print(out) ```

-1

24

A

Ring road

PROGRAMMING

1,400

[ "graphs" ]

A. Ring road

2

256

Nowadays the one-way traffic is introduced all over the world in order to improve driving safety and reduce traffic jams. The government of Berland decided to keep up with new trends. Formerly all *n* cities of Berland were connected by *n* two-way roads in the ring, i. e. each city was connected directly to exactly two other cities, and from each city it was possible to get to any other city. Government of Berland introduced one-way traffic on all *n* roads, but it soon became clear that it's impossible to get from some of the cities to some others. Now for each road is known in which direction the traffic is directed at it, and the cost of redirecting the traffic. What is the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other?

The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of cities (and roads) in Berland. Next *n* lines contain description of roads. Each road is described by three integers *a**i*, *b**i*, *c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*,<=*a**i*<=≠<=*b**i*,<=1<=≤<=*c**i*<=≤<=100) — road is directed from city *a**i* to city *b**i*, redirecting the traffic costs *c**i*.

Output single integer — the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other.

[ "3\n1 3 1\n1 2 1\n3 2 1\n", "3\n1 3 1\n1 2 5\n3 2 1\n", "6\n1 5 4\n5 3 8\n2 4 15\n1 6 16\n2 3 23\n4 6 42\n", "4\n1 2 9\n2 3 8\n3 4 7\n4 1 5\n" ]

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

none

0

[ { "input": "3\n1 3 1\n1 2 1\n3 2 1", "output": "1" }, { "input": "3\n1 3 1\n1 2 5\n3 2 1", "output": "2" }, { "input": "6\n1 5 4\n5 3 8\n2 4 15\n1 6 16\n2 3 23\n4 6 42", "output": "39" }, { "input": "4\n1 2 9\n2 3 8\n3 4 7\n4 1 5", "output": "0" }, { "input": "5\n5 3 89\n2 3 43\n4 2 50\n1 4 69\n1 5 54", "output": "143" }, { "input": "10\n1 8 16\n6 1 80\n6 5 27\n5 7 86\n7 9 72\n4 9 20\n4 3 54\n3 2 57\n10 2 61\n8 10 90", "output": "267" }, { "input": "17\n8 12 43\n13 12 70\n7 13 68\n11 7 19\n5 11 24\n5 1 100\n4 1 10\n3 4 68\n2 3 46\n15 2 58\n15 6 38\n6 9 91\n9 10 72\n14 10 32\n14 17 97\n17 16 67\n8 16 40", "output": "435" }, { "input": "22\n18 22 46\n18 21 87\n5 21 17\n5 10 82\n10 12 81\n17 12 98\n16 17 17\n16 13 93\n4 13 64\n4 11 65\n15 11 18\n6 15 35\n6 7 61\n7 19 12\n19 1 65\n8 1 32\n8 2 46\n9 2 19\n9 3 58\n3 14 65\n20 14 67\n20 22 2", "output": "413" }, { "input": "39\n18 11 10\n5 18 97\n5 39 77\n39 24 64\n24 28 79\n28 14 6\n34 14 72\n6 34 64\n6 12 93\n12 8 66\n13 8 40\n35 13 20\n35 32 4\n32 19 55\n19 3 18\n3 21 26\n30 21 54\n30 27 5\n4 27 8\n22 4 89\n15 22 54\n15 2 90\n36 2 58\n33 36 4\n33 17 50\n17 16 21\n31 16 64\n1 31 77\n1 23 89\n23 7 62\n38 7 74\n9 38 15\n9 25 93\n25 10 32\n10 26 78\n20 26 63\n37 20 9\n29 37 33\n11 29 45", "output": "950" }, { "input": "50\n30 34 48\n11 30 15\n11 5 98\n4 5 57\n43 4 21\n14 43 74\n14 19 52\n45 19 60\n45 28 52\n24 28 94\n24 26 2\n48 26 48\n48 13 53\n13 42 7\n42 37 23\n37 17 70\n17 7 29\n20 7 93\n33 20 21\n33 2 53\n21 2 83\n49 21 33\n46 49 28\n18 46 1\n36 18 99\n47 36 52\n47 29 41\n41 29 40\n31 41 45\n31 38 25\n38 25 41\n25 8 18\n9 8 60\n9 27 29\n16 27 17\n16 22 6\n22 39 1\n1 39 8\n1 50 89\n50 12 64\n40 12 7\n40 44 71\n44 10 23\n15 10 70\n15 32 53\n23 32 92\n35 23 14\n35 3 25\n3 6 93\n6 34 99", "output": "1117" }, { "input": "3\n3 1 1\n2 1 1\n2 3 1", "output": "1" } ]

1,603,915,375

2,147,483,647

Python 3

OK

TESTS

21

216

0

source=set() dest=set() c1=0 c2=0 for i in range(int(input())): s,d,w=map(int,input().split()) if s in source or d in dest: c1=c1+w s,d=d,s else: c2=c2+w source.add(s) dest.add(d) print(min(c1,c2))

Title: Ring road Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Nowadays the one-way traffic is introduced all over the world in order to improve driving safety and reduce traffic jams. The government of Berland decided to keep up with new trends. Formerly all *n* cities of Berland were connected by *n* two-way roads in the ring, i. e. each city was connected directly to exactly two other cities, and from each city it was possible to get to any other city. Government of Berland introduced one-way traffic on all *n* roads, but it soon became clear that it's impossible to get from some of the cities to some others. Now for each road is known in which direction the traffic is directed at it, and the cost of redirecting the traffic. What is the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other? Input Specification: The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of cities (and roads) in Berland. Next *n* lines contain description of roads. Each road is described by three integers *a**i*, *b**i*, *c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*,<=*a**i*<=≠<=*b**i*,<=1<=≤<=*c**i*<=≤<=100) — road is directed from city *a**i* to city *b**i*, redirecting the traffic costs *c**i*. Output Specification: Output single integer — the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other. Demo Input: ['3\n1 3 1\n1 2 1\n3 2 1\n', '3\n1 3 1\n1 2 5\n3 2 1\n', '6\n1 5 4\n5 3 8\n2 4 15\n1 6 16\n2 3 23\n4 6 42\n', '4\n1 2 9\n2 3 8\n3 4 7\n4 1 5\n'] Demo Output: ['1\n', '2\n', '39\n', '0\n'] Note: none

```python source=set() dest=set() c1=0 c2=0 for i in range(int(input())): s,d,w=map(int,input().split()) if s in source or d in dest: c1=c1+w s,d=d,s else: c2=c2+w source.add(s) dest.add(d) print(min(c1,c2)) ```

3.946

616

B

Dinner with Emma

PROGRAMMING

1,000

[ "games", "greedy" ]

null

Jack decides to invite Emma out for a dinner. Jack is a modest student, he doesn't want to go to an expensive restaurant. Emma is a girl with high taste, she prefers elite places. Munhattan consists of *n* streets and *m* avenues. There is exactly one restaurant on the intersection of each street and avenue. The streets are numbered with integers from 1 to *n* and the avenues are numbered with integers from 1 to *m*. The cost of dinner in the restaurant at the intersection of the *i*-th street and the *j*-th avenue is *c**ij*. Jack and Emma decide to choose the restaurant in the following way. Firstly Emma chooses the street to dinner and then Jack chooses the avenue. Emma and Jack makes their choice optimally: Emma wants to maximize the cost of the dinner, Jack wants to minimize it. Emma takes into account that Jack wants to minimize the cost of the dinner. Find the cost of the dinner for the couple in love.

The first line contains two integers *n*,<=*m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of streets and avenues in Munhattan. Each of the next *n* lines contains *m* integers *c**ij* (1<=≤<=*c**ij*<=≤<=109) — the cost of the dinner in the restaurant on the intersection of the *i*-th street and the *j*-th avenue.

Print the only integer *a* — the cost of the dinner for Jack and Emma.

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

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

In the first example if Emma chooses the first or the third streets Jack can choose an avenue with the cost of the dinner 1. So she chooses the second street and Jack chooses any avenue. The cost of the dinner is 2. In the second example regardless of Emma's choice Jack can choose a restaurant with the cost of the dinner 1.

0

[ { "input": "3 4\n4 1 3 5\n2 2 2 2\n5 4 5 1", "output": "2" }, { "input": "3 3\n1 2 3\n2 3 1\n3 1 2", "output": "1" }, { "input": "1 1\n1", "output": "1" }, { "input": "1 10\n74 35 82 39 1 84 29 41 70 12", "output": "1" }, { "input": "10 1\n44\n23\n65\n17\n48\n29\n49\n88\n91\n85", "output": "91" }, { "input": "10 10\n256 72 455 45 912 506 235 68 951 92\n246 305 45 212 788 621 449 876 459 899\n732 107 230 357 370 610 997 669 61 192\n131 93 481 527 983 920 825 540 435 54\n777 682 984 20 337 480 264 137 249 502\n51 467 479 228 923 752 714 436 199 973\n3 91 612 571 631 212 751 84 886 948\n252 130 583 23 194 985 234 978 709 16\n636 991 203 469 719 540 184 902 503 652\n826 680 150 284 37 987 360 183 447 51", "output": "184" }, { "input": "1 1\n1000000000", "output": "1000000000" }, { "input": "2 1\n999999999\n1000000000", "output": "1000000000" } ]

1,628,389,975

2,147,483,647

Python 3

OK

TESTS

16

77

6,963,200

a,b=list(map(int,input().split())) d=[] for i in range(a): c=list(map(int,input().split())) d+=[min(c)] print(max(d))

Title: Dinner with Emma Time Limit: None seconds Memory Limit: None megabytes Problem Description: Jack decides to invite Emma out for a dinner. Jack is a modest student, he doesn't want to go to an expensive restaurant. Emma is a girl with high taste, she prefers elite places. Munhattan consists of *n* streets and *m* avenues. There is exactly one restaurant on the intersection of each street and avenue. The streets are numbered with integers from 1 to *n* and the avenues are numbered with integers from 1 to *m*. The cost of dinner in the restaurant at the intersection of the *i*-th street and the *j*-th avenue is *c**ij*. Jack and Emma decide to choose the restaurant in the following way. Firstly Emma chooses the street to dinner and then Jack chooses the avenue. Emma and Jack makes their choice optimally: Emma wants to maximize the cost of the dinner, Jack wants to minimize it. Emma takes into account that Jack wants to minimize the cost of the dinner. Find the cost of the dinner for the couple in love. Input Specification: The first line contains two integers *n*,<=*m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of streets and avenues in Munhattan. Each of the next *n* lines contains *m* integers *c**ij* (1<=≤<=*c**ij*<=≤<=109) — the cost of the dinner in the restaurant on the intersection of the *i*-th street and the *j*-th avenue. Output Specification: Print the only integer *a* — the cost of the dinner for Jack and Emma. Demo Input: ['3 4\n4 1 3 5\n2 2 2 2\n5 4 5 1\n', '3 3\n1 2 3\n2 3 1\n3 1 2\n'] Demo Output: ['2\n', '1\n'] Note: In the first example if Emma chooses the first or the third streets Jack can choose an avenue with the cost of the dinner 1. So she chooses the second street and Jack chooses any avenue. The cost of the dinner is 2. In the second example regardless of Emma's choice Jack can choose a restaurant with the cost of the dinner 1.

```python a,b=list(map(int,input().split())) d=[] for i in range(a): c=list(map(int,input().split())) d+=[min(c)] print(max(d)) ```

3

938

A

Word Correction

PROGRAMMING

800

[ "implementation" ]

null

Victor tries to write his own text editor, with word correction included. However, the rules of word correction are really strange. Victor thinks that if a word contains two consecutive vowels, then it's kinda weird and it needs to be replaced. So the word corrector works in such a way: as long as there are two consecutive vowels in the word, it deletes the first vowel in a word such that there is another vowel right before it. If there are no two consecutive vowels in the word, it is considered to be correct. You are given a word *s*. Can you predict what will it become after correction? In this problem letters a, e, i, o, u and y are considered to be vowels.

The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the number of letters in word *s* before the correction. The second line contains a string *s* consisting of exactly *n* lowercase Latin letters — the word before the correction.

Output the word *s* after the correction.

[ "5\nweird\n", "4\nword\n", "5\naaeaa\n" ]

[ "werd\n", "word\n", "a\n" ]

Explanations of the examples: 1. There is only one replace: weird <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> werd;1. No replace needed since there are no two consecutive vowels;1. aaeaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aeaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> a.

0

[ { "input": "5\nweird", "output": "werd" }, { "input": "4\nword", "output": "word" }, { "input": "5\naaeaa", "output": "a" }, { "input": "100\naaaaabbbbboyoyoyoyoyacadabbbbbiuiufgiuiuaahjabbbklboyoyoyoyoyaaaaabbbbbiuiuiuiuiuaaaaabbbbbeyiyuyzyw", "output": "abbbbbocadabbbbbifgihjabbbklbobbbbbibbbbbezyw" }, { "input": "69\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, { "input": "12\nmmmmmmmmmmmm", "output": "mmmmmmmmmmmm" }, { "input": "18\nyaywptqwuyiqypwoyw", "output": "ywptqwuqypwow" }, { "input": "85\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, { "input": "13\nmmmmmmmmmmmmm", "output": "mmmmmmmmmmmmm" }, { "input": "10\nmmmmmmmmmm", "output": "mmmmmmmmmm" }, { "input": "11\nmmmmmmmmmmm", "output": "mmmmmmmmmmm" }, { "input": "15\nmmmmmmmmmmmmmmm", "output": "mmmmmmmmmmmmmmm" }, { "input": "1\na", "output": "a" }, { "input": "14\nmmmmmmmmmmmmmm", "output": "mmmmmmmmmmmmmm" }, { "input": "33\nmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm", "output": "mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm" }, { "input": "79\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, { "input": "90\nbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, { "input": "2\naa", "output": "a" }, { "input": "18\niuiuqpyyaoaetiwliu", "output": "iqpytiwli" }, { "input": "5\nxxxxx", "output": "xxxxx" }, { "input": "6\nxxxahg", "output": "xxxahg" }, { "input": "3\nzcv", "output": "zcv" }, { "input": "4\naepo", "output": "apo" }, { "input": "5\nqqqqq", "output": "qqqqq" }, { "input": "6\naaaaaa", "output": "a" }, { "input": "4\naeta", "output": "ata" }, { "input": "20\nttyttlwaoieulyiluuri", "output": "ttyttlwalyluri" }, { "input": "1\nb", "output": "b" }, { "input": "3\nanc", "output": "anc" }, { "input": "1\ne", "output": "e" }, { "input": "3\naie", "output": "a" }, { "input": "3\nvio", "output": "vi" }, { "input": "2\nea", "output": "e" }, { "input": "3\nuas", "output": "us" }, { "input": "2\nba", "output": "ba" }, { "input": "2\naq", "output": "aq" }, { "input": "2\nya", "output": "y" }, { "input": "2\nou", "output": "o" }, { "input": "2\nbb", "output": "bb" }, { "input": "7\nayylmao", "output": "alma" }, { "input": "2\nab", "output": "ab" }, { "input": "19\nyuouiyaoiiweqrryqqp", "output": "yweqrryqqp" }, { "input": "25\niqypwqpriiioetiuqqqttouei", "output": "iqypwqpritiqqqtto" }, { "input": "100\naaaaabbbbboyoyoyoyoyacadabbbbbiuiufgiuiuaahjabbbklboyoyoyoyoyaaaaabbbbbiuiuiuiuiuaaaaabbbbbeyiyuyzyz", "output": "abbbbbocadabbbbbifgihjabbbklbobbbbbibbbbbezyz" }, { "input": "17\naccccccccccccccca", "output": "accccccccccccccca" }, { "input": "5\nababa", "output": "ababa" }, { "input": "10\naaaaaaaaaa", "output": "a" }, { "input": "22\naaaaabbbbboyoyoyoyoyac", "output": "abbbbboc" }, { "input": "7\nmahmoud", "output": "mahmod" } ]

1,590,888,541

2,147,483,647

PyPy 3

OK

TESTS

49

140

0

n = input() word = input() vowels = ['a', 'e', 'i', 'o', 'u', 'y'] res = [] last_is_vowel = False for letter in word: if(letter in vowels): if(last_is_vowel == False): res.append(letter) last_is_vowel = True else: res.append(letter) last_is_vowel = False for i in res: print(i, end='') print()

Title: Word Correction Time Limit: None seconds Memory Limit: None megabytes Problem Description: Victor tries to write his own text editor, with word correction included. However, the rules of word correction are really strange. Victor thinks that if a word contains two consecutive vowels, then it's kinda weird and it needs to be replaced. So the word corrector works in such a way: as long as there are two consecutive vowels in the word, it deletes the first vowel in a word such that there is another vowel right before it. If there are no two consecutive vowels in the word, it is considered to be correct. You are given a word *s*. Can you predict what will it become after correction? In this problem letters a, e, i, o, u and y are considered to be vowels. Input Specification: The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the number of letters in word *s* before the correction. The second line contains a string *s* consisting of exactly *n* lowercase Latin letters — the word before the correction. Output Specification: Output the word *s* after the correction. Demo Input: ['5\nweird\n', '4\nword\n', '5\naaeaa\n'] Demo Output: ['werd\n', 'word\n', 'a\n'] Note: Explanations of the examples: 1. There is only one replace: weird <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> werd;1. No replace needed since there are no two consecutive vowels;1. aaeaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aeaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aaa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> aa <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/70a0795f45d32287dba0eb83fc4a3f470c6e5537.png" style="max-width: 100.0%;max-height: 100.0%;"/> a.

```python n = input() word = input() vowels = ['a', 'e', 'i', 'o', 'u', 'y'] res = [] last_is_vowel = False for letter in word: if(letter in vowels): if(last_is_vowel == False): res.append(letter) last_is_vowel = True else: res.append(letter) last_is_vowel = False for i in res: print(i, end='') print() ```

3

729

A

Interview with Oleg

PROGRAMMING

900

[ "implementation", "strings" ]

null

Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string *s* consisting of *n* lowercase English letters. There is a filler word ogo in Oleg's speech. All words that can be obtained from ogo by adding go several times to the end of it are also considered to be fillers. For example, the words ogo, ogogo, ogogogo are fillers, but the words go, og, ogog, ogogog and oggo are not fillers. The fillers have maximal size, for example, for ogogoo speech we can't consider ogo a filler and goo as a normal phrase. We should consider ogogo as a filler here. To print the interview, Polycarp has to replace each of the fillers with three asterisks. Note that a filler word is replaced with exactly three asterisks regardless of its length. Polycarp has dealt with this problem in no time. Can you do the same? The clock is ticking!

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the length of the interview. The second line contains the string *s* of length *n*, consisting of lowercase English letters.

Print the interview text after the replacement of each of the fillers with "***". It is allowed for the substring "***" to have several consecutive occurences.

[ "7\naogogob\n", "13\nogogmgogogogo\n", "9\nogoogoogo\n" ]

[ "a***b\n", "***gmg***\n", "*********\n" ]

The first sample contains one filler word ogogo, so the interview for printing is "a***b". The second sample contains two fillers ogo and ogogogo. Thus, the interview is transformed to "***gmg***".

500

[ { "input": "7\naogogob", "output": "a***b" }, { "input": "13\nogogmgogogogo", "output": "***gmg***" }, { "input": "9\nogoogoogo", "output": "*********" }, { "input": "32\nabcdefogoghijklmnogoopqrstuvwxyz", "output": "abcdef***ghijklmn***opqrstuvwxyz" }, { "input": "100\nggogogoooggogooggoggogggggogoogoggooooggooggoooggogoooggoggoogggoogoggogggoooggoggoggogggogoogggoooo", "output": "gg***oogg***oggoggoggggg******ggooooggooggooogg***ooggoggoogggo***ggogggoooggoggoggoggg***ogggoooo" }, { "input": "10\nogooggoggo", "output": "***oggoggo" }, { "input": "20\nooggooogooogooogooog", "output": "ooggoo***o***o***oog" }, { "input": "30\ngoggogoooggooggggoggoggoogoggo", "output": "gogg***ooggooggggoggoggo***ggo" }, { "input": "40\nogggogooggoogoogggogooogogggoogggooggooo", "output": "oggg***oggo***oggg***o***gggoogggooggooo" }, { "input": "50\noggggogoogggggggoogogggoooggooogoggogooogogggogooo", "output": "ogggg***ogggggggo***gggoooggoo***gg***o***ggg***oo" }, { "input": "60\nggoooogoggogooogogooggoogggggogogogggggogggogooogogogggogooo", "output": "ggooo***gg***o***oggooggggg***gggggoggg***o***ggg***oo" }, { "input": "70\ngogoooggggoggoggggggoggggoogooogogggggooogggogoogoogoggogggoggogoooooo", "output": "g***ooggggoggoggggggoggggo***o***gggggoooggg*********ggogggogg***ooooo" }, { "input": "80\nooogoggoooggogogoggooooogoogogooogoggggogggggogoogggooogooooooggoggoggoggogoooog", "output": "oo***ggooogg***ggoooo******o***ggggoggggg***ogggoo***oooooggoggoggogg***ooog" }, { "input": "90\nooogoggggooogoggggoooogggggooggoggoggooooooogggoggogggooggggoooooogoooogooggoooogggggooooo", "output": "oo***ggggoo***ggggoooogggggooggoggoggooooooogggoggogggooggggooooo***oo***oggoooogggggooooo" }, { "input": "100\ngooogoggooggggoggoggooooggogoogggoogogggoogogoggogogogoggogggggogggggoogggooogogoggoooggogoooooogogg", "output": "goo***ggooggggoggoggoooogg***ogggo***gggo***gg***ggogggggogggggoogggoo***ggooogg***oooo***gg" }, { "input": "100\ngoogoogggogoooooggoogooogoogoogogoooooogooogooggggoogoggogooogogogoogogooooggoggogoooogooooooggogogo", "output": "go***oggg***ooooggo***o*********oooo***o***oggggo***gg***o******oooggogg***oo***ooooogg***" }, { "input": "100\ngoogoggggogggoooggoogoogogooggoggooggggggogogggogogggoogogggoogoggoggogooogogoooogooggggogggogggoooo", "output": "go***ggggogggoooggo******oggoggoogggggg***ggg***gggo***gggo***ggogg***o***oo***oggggogggogggoooo" }, { "input": "100\nogogogogogoggogogogogogogoggogogogoogoggoggooggoggogoogoooogogoogggogogogogogoggogogogogogogogogogoe", "output": "***gg***gg******ggoggooggogg******oo***oggg***gg***e" }, { "input": "5\nogoga", "output": "***ga" }, { "input": "1\no", "output": "o" }, { "input": "100\nogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogog", "output": "***g" }, { "input": "99\nogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogogo", "output": "***" }, { "input": "5\nggggg", "output": "ggggg" }, { "input": "6\ngoogoo", "output": "go***o" }, { "input": "7\nooogooo", "output": "oo***oo" }, { "input": "8\ngggggggg", "output": "gggggggg" }, { "input": "9\nogggogggg", "output": "ogggogggg" }, { "input": "10\nogogoggogo", "output": "***gg***" }, { "input": "11\noooggooggog", "output": "oooggooggog" }, { "input": "12\nogggooooggog", "output": "ogggooooggog" }, { "input": "13\nogoggogogooog", "output": "***gg***oog" }, { "input": "15\nggooogoooggoggg", "output": "ggoo***ooggoggg" }, { "input": "14\noogooooggooggo", "output": "o***oooggooggo" }, { "input": "1\na", "output": "a" }, { "input": "1\ng", "output": "g" }, { "input": "1\nz", "output": "z" }, { "input": "46\nsdfkogogogogergergogogergerogogogogoergoegogog", "output": "sdfk***gergerg***gerger***ergoeg***g" }, { "input": "86\ngdfggogogodfogogdofgoodfogodgodgfogoogdodhbofgobgbgfogoogdfogogogogogoogggsgfosogodgon", "output": "gdfgg***df***gdofgoodf***dgodgf***ogdodhbofgobgbgf***ogdf***ogggsgfos***dgon" }, { "input": "83\nergegergoogogogerogoerorogroeorgefxcfgzdgawofqpwzxcvbnmsdfkfpweoriqgtogooggsdgogoog", "output": "ergegergo***ger***erorogroeorgefxcfgzdgawofqpwzxcvbnmsdfkfpweoriqgt***oggsdg***og" }, { "input": "2\nog", "output": "og" }, { "input": "4\nogog", "output": "***g" }, { "input": "4\nogoo", "output": "***o" }, { "input": "29\naaaogogogogogogogogogogogobbb", "output": "aaa***bbb" }, { "input": "11\nogogogogogo", "output": "***" }, { "input": "9\nogogogogo", "output": "***" }, { "input": "3\nogo", "output": "***" }, { "input": "15\nogogogogogogogo", "output": "***" }, { "input": "25\nogogogogogogogogogogogogo", "output": "***" } ]

1,479,633,123

423

Python 3

WRONG_ANSWER

PRETESTS

3

77

0

n = int(input()) s = input() ans_s = '' i = 0 while i < n-2: if (s[i]+s[i+1]+s[i+2] =='ogo'): ans_s+='***' i+=3 while i < n-1 and s[i]+s[i+1] == 'go': i+=2 else: ans_s += s[i] i+=1 if i < n: ans_s+=s[i] print(ans_s)

Title: Interview with Oleg Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarp has interviewed Oleg and has written the interview down without punctuation marks and spaces to save time. Thus, the interview is now a string *s* consisting of *n* lowercase English letters. There is a filler word ogo in Oleg's speech. All words that can be obtained from ogo by adding go several times to the end of it are also considered to be fillers. For example, the words ogo, ogogo, ogogogo are fillers, but the words go, og, ogog, ogogog and oggo are not fillers. The fillers have maximal size, for example, for ogogoo speech we can't consider ogo a filler and goo as a normal phrase. We should consider ogogo as a filler here. To print the interview, Polycarp has to replace each of the fillers with three asterisks. Note that a filler word is replaced with exactly three asterisks regardless of its length. Polycarp has dealt with this problem in no time. Can you do the same? The clock is ticking! Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the length of the interview. The second line contains the string *s* of length *n*, consisting of lowercase English letters. Output Specification: Print the interview text after the replacement of each of the fillers with "***". It is allowed for the substring "***" to have several consecutive occurences. Demo Input: ['7\naogogob\n', '13\nogogmgogogogo\n', '9\nogoogoogo\n'] Demo Output: ['a***b\n', '***gmg***\n', '*********\n'] Note: The first sample contains one filler word ogogo, so the interview for printing is "a***b". The second sample contains two fillers ogo and ogogogo. Thus, the interview is transformed to "***gmg***".

```python n = int(input()) s = input() ans_s = '' i = 0 while i < n-2: if (s[i]+s[i+1]+s[i+2] =='ogo'): ans_s+='***' i+=3 while i < n-1 and s[i]+s[i+1] == 'go': i+=2 else: ans_s += s[i] i+=1 if i < n: ans_s+=s[i] print(ans_s) ```

0

440

B

Balancer

PROGRAMMING

1,600

[ "greedy", "implementation" ]

null

Petya has *k* matches, placed in *n* matchboxes lying in a line from left to right. We know that *k* is divisible by *n*. Petya wants all boxes to have the same number of matches inside. For that, he can move a match from its box to the adjacent one in one move. How many such moves does he need to achieve the desired configuration?

The first line contains integer *n* (1<=≤<=*n*<=≤<=50000). The second line contains *n* non-negative numbers that do not exceed 109, the *i*-th written number is the number of matches in the *i*-th matchbox. It is guaranteed that the total number of matches is divisible by *n*.

Print the total minimum number of moves.

[ "6\n1 6 2 5 3 7\n" ]

[ "12\n" ]

none

1,000

[ { "input": "6\n1 6 2 5 3 7", "output": "12" }, { "input": "6\n6 6 6 0 0 0", "output": "27" }, { "input": "6\n0 0 0 6 6 6", "output": "27" }, { "input": "6\n6 6 0 0 6 6", "output": "12" }, { "input": "5\n0 0 0 0 0", "output": "0" }, { "input": "10\n0 100 0 100 0 100 0 100 0 100", "output": "250" }, { "input": "1\n0", "output": "0" }, { "input": "2\n0 0", "output": "0" }, { "input": "3\n0 0 0", "output": "0" }, { "input": "4\n0 0 0 0", "output": "0" }, { "input": "2\n921 29111", "output": "14095" }, { "input": "2\n0 1000000000", "output": "500000000" }, { "input": "2\n291911 1", "output": "145955" }, { "input": "2\n20180000 0", "output": "10090000" }, { "input": "10\n10 9 7 13 7 5 13 15 10 11", "output": "27" }, { "input": "100\n6 3 4 5 3 4 2 4 1 2 4 1 8 5 2 2 4 4 6 8 4 10 4 4 6 8 6 5 5 4 8 4 3 3 6 5 7 2 9 7 6 5 6 3 2 6 8 10 3 6 8 7 2 3 5 4 8 6 5 6 6 8 4 1 5 6 1 8 12 5 3 3 8 2 4 2 4 5 6 6 9 5 1 2 8 8 3 7 5 3 4 5 7 6 3 9 4 6 3 6", "output": "867" }, { "input": "10\n1 1 1 1 1 999999999 999999999 999999999 999999999 999999999", "output": "12499999975" }, { "input": "10\n1 1 1 1 1 1 1 1 2 1000000000", "output": "4499999999" }, { "input": "14\n0 0 0 0 0 0 0 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000", "output": "24500000000" }, { "input": "20\n1 1 1 1 1 1 1 1 1 1 999999999 999999999 999999999 999999999 999999999 999999999 999999999 999999999 999999999 999999999", "output": "49999999900" }, { "input": "20\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 2 2 2 2 2 2 2 2 2 2", "output": "49999999900" } ]

1,609,412,877

2,147,483,647

PyPy 3

OK

TESTS

53

187

7,577,600

n = int(input()) a = [int(x) for x in input().split()] s = sum(a) // n lft = 0 ans = 0 for i in range(n): ans += abs(lft) lft += a[i] - s print(ans)

Title: Balancer Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya has *k* matches, placed in *n* matchboxes lying in a line from left to right. We know that *k* is divisible by *n*. Petya wants all boxes to have the same number of matches inside. For that, he can move a match from its box to the adjacent one in one move. How many such moves does he need to achieve the desired configuration? Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=50000). The second line contains *n* non-negative numbers that do not exceed 109, the *i*-th written number is the number of matches in the *i*-th matchbox. It is guaranteed that the total number of matches is divisible by *n*. Output Specification: Print the total minimum number of moves. Demo Input: ['6\n1 6 2 5 3 7\n'] Demo Output: ['12\n'] Note: none

```python n = int(input()) a = [int(x) for x in input().split()] s = sum(a) // n lft = 0 ans = 0 for i in range(n): ans += abs(lft) lft += a[i] - s print(ans) ```

3

950

B

Intercepted Message

PROGRAMMING

1,100

[ "greedy", "implementation" ]

null

Hacker Zhorik wants to decipher two secret messages he intercepted yesterday. Yeah message is a sequence of encrypted blocks, each of them consists of several bytes of information. Zhorik knows that each of the messages is an archive containing one or more files. Zhorik knows how each of these archives was transferred through the network: if an archive consists of *k* files of sizes *l*1,<=*l*2,<=...,<=*l**k* bytes, then the *i*-th file is split to one or more blocks *b**i*,<=1,<=*b**i*,<=2,<=...,<=*b**i*,<=*m**i* (here the total length of the blocks *b**i*,<=1<=+<=*b**i*,<=2<=+<=...<=+<=*b**i*,<=*m**i* is equal to the length of the file *l**i*), and after that all blocks are transferred through the network, maintaining the order of files in the archive. Zhorik thinks that the two messages contain the same archive, because their total lengths are equal. However, each file can be split in blocks in different ways in the two messages. You are given the lengths of blocks in each of the two messages. Help Zhorik to determine what is the maximum number of files could be in the archive, if the Zhorik's assumption is correct.

The first line contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=105) — the number of blocks in the first and in the second messages. The second line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=106) — the length of the blocks that form the first message. The third line contains *m* integers *y*1,<=*y*2,<=...,<=*y**m* (1<=≤<=*y**i*<=≤<=106) — the length of the blocks that form the second message. It is guaranteed that *x*1<=+<=...<=+<=*x**n*<==<=*y*1<=+<=...<=+<=*y**m*. Also, it is guaranteed that *x*1<=+<=...<=+<=*x**n*<=≤<=106.

Print the maximum number of files the intercepted array could consist of.

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

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

In the first example the maximum number of files in the archive is 3. For example, it is possible that in the archive are three files of sizes 2 + 5 = 7, 15 = 3 + 1 + 11 = 8 + 2 + 4 + 1 and 4 + 4 = 8. In the second example it is possible that the archive contains two files of sizes 1 and 110 = 10 + 100 = 100 + 10. Note that the order of files is kept while transferring archives through the network, so we can't say that there are three files of sizes 1, 10 and 100. In the third example the only possibility is that the archive contains a single file of size 4.

1,000

[ { "input": "7 6\n2 5 3 1 11 4 4\n7 8 2 4 1 8", "output": "3" }, { "input": "3 3\n1 10 100\n1 100 10", "output": "2" }, { "input": "1 4\n4\n1 1 1 1", "output": "1" }, { "input": "1 1\n1000000\n1000000", "output": "1" }, { "input": "3 5\n2 2 9\n2 1 4 2 4", "output": "2" }, { "input": "5 3\n1 1 4 1 2\n1 4 4", "output": "2" }, { "input": "30 50\n3 3 1 3 1 2 4 3 4 1 3 2 3 3 2 3 2 1 3 4 2 1 1 3 2 2 1 3 1 60\n4 4 1 2 2 2 3 1 3 2 1 2 4 4 2 1 2 3 1 3 4 4 3 3 4 4 4 1 2 1 3 3 1 1 3 3 4 3 2 3 2 4 1 4 2 3 2 2 3 1", "output": "12" }, { "input": "50 50\n5733 740 547 3647 5382 5109 6842 7102 5879 1502 3574 1628 7905 4357 8569 9564 8268 3542 2487 8532 425 7713 2585 925 6458 2697 2844 69 324 9030 495 4428 6724 3524 3304 4874 1303 2098 1136 1048 2464 7316 274 9586 534 2450 2368 8060 7795 70692\n1918 4122 6806 4914 6517 6278 9842 9480 6609 4221 9373 1728 9508 9778 8578 5589 2673 6618 6031 9016 4017 6671 6008 2268 5154 9614 6834 9512 9618 6424 1736 1464 6520 9812 1722 9197 2412 2699 73 968 2906 2715 6573 8675 548 7061 5455 88 5565 2544", "output": "1" }, { "input": "1 2\n2\n1 1", "output": "1" }, { "input": "1 2\n1000000\n999999 1", "output": "1" }, { "input": "2 2\n1 1\n1 1", "output": "2" }, { "input": "2 2\n500000 500000\n1 999999", "output": "1" }, { "input": "2 2\n2 3\n4 1", "output": "1" }, { "input": "2 2\n2 3\n3 2", "output": "1" }, { "input": "2 2\n2 3\n2 3", "output": "2" }, { "input": "2 3\n2 2\n1 1 2", "output": "2" }, { "input": "1 1\n1\n1", "output": "1" }, { "input": "2 3\n3 2\n2 1 2", "output": "2" }, { "input": "2 3\n2 3\n2 1 2", "output": "2" }, { "input": "50 30\n2 3 1 2 2 4 3 4 3 2 1 4 2 3 1 3 1 2 2 3 1 1 1 2 3 1 4 3 1 2 1 2 2 1 2 4 4 3 3 2 2 1 1 1 2 2 2 4 3 3\n3 3 3 4 1 4 1 4 4 1 3 4 3 1 2 4 2 1 4 2 3 1 1 2 2 1 2 4 1 41", "output": "12" }, { "input": "50 50\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\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", "output": "50" }, { "input": "31 31\n5745 258 5486 13779 20931 407 1478 49032 30787 4957 36603 1034 5011 22319 50560 34419 22036 18235 62551 89259 36093 126169 106027 1673 52983 50127 640 30714 54574 20129 45984\n5745 258 5486 13779 20931 407 1478 49032 30787 4957 36603 1034 5011 22319 50560 34419 22036 18235 62551 89259 36093 126169 106027 1673 52983 50127 640 30714 54574 20129 45984", "output": "31" }, { "input": "3 6\n8 4 1\n1 8 1 1 1 1", "output": "2" } ]

1,522,959,202

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

8

1,000

9,523,200

n,m = map(int,input().split()) a = list(map(int,input().split())) b = list(map(int,input().split())) x = a.pop(0) y = b.pop(0) ans = [] while(1): if(x>y): if(len(b)>0): y+=b.pop(0) if(y>x): if(len(a)>0): x+=a.pop(0) if(x==y): ans.append(x) if(len(a)>0): x = a.pop(0) if(len(b)>0): y = b.pop(0) if(len(a)==0 and len(b)==0): break print(len(ans))

Title: Intercepted Message Time Limit: None seconds Memory Limit: None megabytes Problem Description: Hacker Zhorik wants to decipher two secret messages he intercepted yesterday. Yeah message is a sequence of encrypted blocks, each of them consists of several bytes of information. Zhorik knows that each of the messages is an archive containing one or more files. Zhorik knows how each of these archives was transferred through the network: if an archive consists of *k* files of sizes *l*1,<=*l*2,<=...,<=*l**k* bytes, then the *i*-th file is split to one or more blocks *b**i*,<=1,<=*b**i*,<=2,<=...,<=*b**i*,<=*m**i* (here the total length of the blocks *b**i*,<=1<=+<=*b**i*,<=2<=+<=...<=+<=*b**i*,<=*m**i* is equal to the length of the file *l**i*), and after that all blocks are transferred through the network, maintaining the order of files in the archive. Zhorik thinks that the two messages contain the same archive, because their total lengths are equal. However, each file can be split in blocks in different ways in the two messages. You are given the lengths of blocks in each of the two messages. Help Zhorik to determine what is the maximum number of files could be in the archive, if the Zhorik's assumption is correct. Input Specification: The first line contains two integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=105) — the number of blocks in the first and in the second messages. The second line contains *n* integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=106) — the length of the blocks that form the first message. The third line contains *m* integers *y*1,<=*y*2,<=...,<=*y**m* (1<=≤<=*y**i*<=≤<=106) — the length of the blocks that form the second message. It is guaranteed that *x*1<=+<=...<=+<=*x**n*<==<=*y*1<=+<=...<=+<=*y**m*. Also, it is guaranteed that *x*1<=+<=...<=+<=*x**n*<=≤<=106. Output Specification: Print the maximum number of files the intercepted array could consist of. Demo Input: ['7 6\n2 5 3 1 11 4 4\n7 8 2 4 1 8\n', '3 3\n1 10 100\n1 100 10\n', '1 4\n4\n1 1 1 1\n'] Demo Output: ['3\n', '2\n', '1\n'] Note: In the first example the maximum number of files in the archive is 3. For example, it is possible that in the archive are three files of sizes 2 + 5 = 7, 15 = 3 + 1 + 11 = 8 + 2 + 4 + 1 and 4 + 4 = 8. In the second example it is possible that the archive contains two files of sizes 1 and 110 = 10 + 100 = 100 + 10. Note that the order of files is kept while transferring archives through the network, so we can't say that there are three files of sizes 1, 10 and 100. In the third example the only possibility is that the archive contains a single file of size 4.

```python n,m = map(int,input().split()) a = list(map(int,input().split())) b = list(map(int,input().split())) x = a.pop(0) y = b.pop(0) ans = [] while(1): if(x>y): if(len(b)>0): y+=b.pop(0) if(y>x): if(len(a)>0): x+=a.pop(0) if(x==y): ans.append(x) if(len(a)>0): x = a.pop(0) if(len(b)>0): y = b.pop(0) if(len(a)==0 and len(b)==0): break print(len(ans)) ```

0

122

A

Lucky Division

PROGRAMMING

1,000

[ "brute force", "number theory" ]

null

Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya calls a number almost lucky if it could be evenly divided by some lucky number. Help him find out if the given number *n* is almost lucky.

The single line contains an integer *n* (1<=≤<=*n*<=≤<=1000) — the number that needs to be checked.

In the only line print "YES" (without the quotes), if number *n* is almost lucky. Otherwise, print "NO" (without the quotes).

[ "47\n", "16\n", "78\n" ]

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

Note that all lucky numbers are almost lucky as any number is evenly divisible by itself. In the first sample 47 is a lucky number. In the second sample 16 is divisible by 4.

500

[ { "input": "47", "output": "YES" }, { "input": "16", "output": "YES" }, { "input": "78", "output": "NO" }, { "input": "48", "output": "YES" }, { "input": "100", "output": "YES" }, { "input": "107", "output": "NO" }, { "input": "77", "output": "YES" }, { "input": "477", "output": "YES" }, { "input": "480", "output": "YES" }, { "input": "1", "output": "NO" }, { "input": "3", "output": "NO" }, { "input": "4", "output": "YES" }, { "input": "49", "output": "YES" }, { "input": "56", "output": "YES" }, { "input": "124", "output": "YES" }, { "input": "1000", "output": "YES" }, { "input": "999", "output": "NO" }, { "input": "298", "output": "NO" }, { "input": "274", "output": "NO" }, { "input": "998", "output": "NO" }, { "input": "42", "output": "YES" }, { "input": "788", "output": "YES" }, { "input": "70", "output": "YES" }, { "input": "444", "output": "YES" }, { "input": "777", "output": "YES" }, { "input": "799", "output": "YES" }, { "input": "25", "output": "NO" }, { "input": "882", "output": "YES" }, { "input": "88", "output": "YES" }, { "input": "11", "output": "NO" }, { "input": "2", "output": "NO" }, { "input": "7", "output": "YES" }, { "input": "8", "output": "YES" }, { "input": "94", "output": "YES" }, { "input": "477", "output": "YES" }, { "input": "141", "output": "YES" } ]

1,688,460,516

2,147,483,647

Python 3

OK

TESTS

36

92

0

n=int(input()) s=str(n) l=['4','7'] k=[4,7,47,74,444,777,447,744,474,747,774,477] c=0 o=0 for i in s: if i in l: c+=1 for i in k: if n%int(i)==0: o=1 break if c==len(s) or (n%4==0) or n%7==0 or o==1: print("YES") else: print("NO")

Title: Lucky Division Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Petya calls a number almost lucky if it could be evenly divided by some lucky number. Help him find out if the given number *n* is almost lucky. Input Specification: The single line contains an integer *n* (1<=≤<=*n*<=≤<=1000) — the number that needs to be checked. Output Specification: In the only line print "YES" (without the quotes), if number *n* is almost lucky. Otherwise, print "NO" (without the quotes). Demo Input: ['47\n', '16\n', '78\n'] Demo Output: ['YES\n', 'YES\n', 'NO\n'] Note: Note that all lucky numbers are almost lucky as any number is evenly divisible by itself. In the first sample 47 is a lucky number. In the second sample 16 is divisible by 4.

```python n=int(input()) s=str(n) l=['4','7'] k=[4,7,47,74,444,777,447,744,474,747,774,477] c=0 o=0 for i in s: if i in l: c+=1 for i in k: if n%int(i)==0: o=1 break if c==len(s) or (n%4==0) or n%7==0 or o==1: print("YES") else: print("NO") ```

3

0

none

0

[ "none" ]

null

A flower shop has got *n* bouquets, and the *i*-th bouquet consists of *a**i* flowers. Vasya, the manager of the shop, decided to make large bouquets from these bouquets. Vasya thinks that a bouquet is large if it is made of two or more initial bouquets, and there is a constraint: the total number of flowers in a large bouquet should be odd. Each of the initial bouquets can be a part of at most one large bouquet. If an initial bouquet becomes a part of a large bouquet, all its flowers are included in the large bouquet. Determine the maximum possible number of large bouquets Vasya can make.

The first line contains a single positive integer *n* (1<=≤<=*n*<=≤<=105) — the number of initial bouquets. The second line contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=106) — the number of flowers in each of the initial bouquets.

Print the maximum number of large bouquets Vasya can make.

[ "5\n2 3 4 2 7\n", "6\n2 2 6 8 6 12\n", "3\n11 4 10\n" ]

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

In the first example Vasya can make 2 large bouquets. For example, the first bouquet can contain the first and the fifth initial bouquets (the total number of flowers is then equal to 9), and the second bouquet can consist of the second and the third initial bouquets (the total number of flowers is then equal to 7). The fourth initial bouquet is unused in this scheme. In the second example it is not possible to form a single bouquet with odd number of flowers. In the third example Vasya can make one large bouquet. For example, he can make it using all three initial bouquets. The size of the large bouquet is then equal to 11 + 4 + 10 = 25.

0

[ { "input": "5\n2 3 4 2 7", "output": "2" }, { "input": "6\n2 2 6 8 6 12", "output": "0" }, { "input": "3\n11 4 10", "output": "1" }, { "input": "1\n1", "output": "0" }, { "input": "1\n2", "output": "0" }, { "input": "1\n999999", "output": "0" }, { "input": "1\n1000000", "output": "0" }, { "input": "4\n943543 151729 379602 589828", "output": "2" }, { "input": "2\n468463 62253", "output": "0" }, { "input": "3\n352987 849349 967007", "output": "1" }, { "input": "20\n274039 899325 798709 157662 963297 276599 529230 80095 252956 980560 358150 82383 29856 901568 123794 275349 512273 508369 120076 170206", "output": "10" }, { "input": "25\n742168 377547 485672 437223 96307 902863 759104 747933 512899 410317 588598 666688 823202 257684 520631 910066 168864 71499 899972 565350 764848 754913 929040 864132 289976", "output": "10" } ]

1,521,301,974

1,074

Python 3

WRONG_ANSWER

TESTS

8

77

8,704,000

'''input 3 11 4 10 ''' n = int(input()) nums = list(map(int, input().split())) odd = 0 even = 0 for x in nums: if(x%2==0): even+=1 else: odd+=1 print(min(odd, even))

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: A flower shop has got *n* bouquets, and the *i*-th bouquet consists of *a**i* flowers. Vasya, the manager of the shop, decided to make large bouquets from these bouquets. Vasya thinks that a bouquet is large if it is made of two or more initial bouquets, and there is a constraint: the total number of flowers in a large bouquet should be odd. Each of the initial bouquets can be a part of at most one large bouquet. If an initial bouquet becomes a part of a large bouquet, all its flowers are included in the large bouquet. Determine the maximum possible number of large bouquets Vasya can make. Input Specification: The first line contains a single positive integer *n* (1<=≤<=*n*<=≤<=105) — the number of initial bouquets. The second line contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=106) — the number of flowers in each of the initial bouquets. Output Specification: Print the maximum number of large bouquets Vasya can make. Demo Input: ['5\n2 3 4 2 7\n', '6\n2 2 6 8 6 12\n', '3\n11 4 10\n'] Demo Output: ['2\n', '0\n', '1\n'] Note: In the first example Vasya can make 2 large bouquets. For example, the first bouquet can contain the first and the fifth initial bouquets (the total number of flowers is then equal to 9), and the second bouquet can consist of the second and the third initial bouquets (the total number of flowers is then equal to 7). The fourth initial bouquet is unused in this scheme. In the second example it is not possible to form a single bouquet with odd number of flowers. In the third example Vasya can make one large bouquet. For example, he can make it using all three initial bouquets. The size of the large bouquet is then equal to 11 + 4 + 10 = 25.

```python '''input 3 11 4 10 ''' n = int(input()) nums = list(map(int, input().split())) odd = 0 even = 0 for x in nums: if(x%2==0): even+=1 else: odd+=1 print(min(odd, even)) ```

0

776

E

The Holmes Children

PROGRAMMING

2,100

[ "math", "number theory" ]

null

The Holmes children are fighting over who amongst them is the cleverest. Mycroft asked Sherlock and Eurus to find value of *f*(*n*), where *f*(1)<==<=1 and for *n*<=≥<=2, *f*(*n*) is the number of distinct ordered positive integer pairs (*x*,<=*y*) that satisfy *x*<=+<=*y*<==<=*n* and *gcd*(*x*,<=*y*)<==<=1. The integer *gcd*(*a*,<=*b*) is the greatest common divisor of *a* and *b*. Sherlock said that solving this was child's play and asked Mycroft to instead get the value of . Summation is done over all positive integers *d* that divide *n*. Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft. She defined a *k*-composite function *F**k*(*n*) recursively as follows: She wants them to tell the value of *F**k*(*n*) modulo 1000000007.

A single line of input contains two space separated integers *n* (1<=≤<=*n*<=≤<=1012) and *k* (1<=≤<=*k*<=≤<=1012) indicating that Eurus asks Sherlock and Mycroft to find the value of *F**k*(*n*) modulo 1000000007.

Output a single integer — the value of *F**k*(*n*) modulo 1000000007.

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

[ "6", "4" ]

In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying *x* + *y* = 7 and *gcd*(*x*, *y*) = 1. Hence, *f*(7) = 6. So, *F*1(7) = *f*(*g*(7)) = *f*(*f*(7) + *f*(1)) = *f*(6 + 1) = *f*(7) = 6.

2,250

[ { "input": "7 1", "output": "6" }, { "input": "10 2", "output": "4" }, { "input": "640 15", "output": "2" }, { "input": "641 17", "output": "2" }, { "input": "641 2000", "output": "1" }, { "input": "961 2", "output": "930" }, { "input": "524288 1000000000000", "output": "1" }, { "input": "557056 12", "output": "8192" }, { "input": "999961 19", "output": "512" }, { "input": "891581 1", "output": "889692" }, { "input": "500009 1", "output": "500008" }, { "input": "549755813888 2", "output": "877905026" }, { "input": "893277279607 1", "output": "275380949" }, { "input": "500000000023 2", "output": "999996529" }, { "input": "999999999937 1", "output": "999992943" }, { "input": "549755813888 38", "output": "1048576" }, { "input": "549755813888 100000", "output": "1" }, { "input": "847288609443 47", "output": "6" }, { "input": "847288609443 200", "output": "1" }, { "input": "999999999937 10000000000", "output": "1" }, { "input": "1 100", "output": "1" }, { "input": "1000000000000 1000000000000", "output": "1" }, { "input": "926517392239 2", "output": "20284739" }, { "input": "177463864070 57", "output": "4" }, { "input": "261777837818 43", "output": "1024" }, { "input": "170111505856 14", "output": "75497472" }, { "input": "135043671066 29", "output": "32768" }, { "input": "334796349382 43", "output": "1024" }, { "input": "989864800574 57", "output": "16" }, { "input": "969640267457 33", "output": "131072" }, { "input": "23566875403 23", "output": "262144" }, { "input": "730748768952 11", "output": "251658240" }, { "input": "997200247414 6", "output": "159532369" }, { "input": "331725641503 32", "output": "262144" }, { "input": "218332248232 2", "output": "570962709" }, { "input": "275876196794 19", "output": "2097152" }, { "input": "500133829908 18", "output": "16777216" }, { "input": "483154390901 6", "output": "72921411" }, { "input": "397631788999 25", "output": "2097152" }, { "input": "937746931140 51", "output": "128" }, { "input": "483650008814 18", "output": "33554432" }, { "input": "927159567 20", "output": "65536" }, { "input": "225907315952 14", "output": "50331648" }, { "input": "203821114680 58", "output": "8" }, { "input": "975624549148 18", "output": "16777216" }, { "input": "234228562369 46", "output": "1024" }, { "input": "485841800462 31", "output": "65536" }, { "input": "12120927584 7", "output": "94371840" }, { "input": "693112248210 36", "output": "16384" }, { "input": "372014205011 18", "output": "67108864" }, { "input": "371634364529 19", "output": "33554432" }, { "input": "845593725265 49", "output": "256" }, { "input": "580294660613 59", "output": "8" }, { "input": "247972832713 57", "output": "8" }, { "input": "246144568124 21", "output": "4194304" }, { "input": "955067149029 42", "output": "4096" }, { "input": "107491536450 46", "output": "512" }, { "input": "696462733578 50", "output": "256" }, { "input": "788541271619 28", "output": "1048576" }, { "input": "167797376193 26", "output": "1048576" }, { "input": "381139218512 16", "output": "50331648" }, { "input": "489124396932 38", "output": "32768" }, { "input": "619297137390 54", "output": "32" }, { "input": "766438750762 59", "output": "128" }, { "input": "662340381277 6", "output": "22476436" }, { "input": "407943488152 42", "output": "2048" }, { "input": "25185014181 30", "output": "8192" }, { "input": "939298330812 58", "output": "32" }, { "input": "78412884457 59", "output": "4" }, { "input": "338042434098 18", "output": "33554432" }, { "input": "289393192315 4", "output": "239438877" }, { "input": "175466750569 53", "output": "32" }, { "input": "340506728610 27", "output": "524288" }, { "input": "294635102279 20", "output": "4194304" }, { "input": "341753622008 21", "output": "4194304" }, { "input": "926517392239 592291529821", "output": "1" }, { "input": "177463864070 46265116367", "output": "1" }, { "input": "261777837818 37277859111", "output": "1" }, { "input": "170111505856 67720156918", "output": "1" }, { "input": "135043671066 116186285375", "output": "1" }, { "input": "334796349382 59340039141", "output": "1" }, { "input": "989864800574 265691489675", "output": "1" }, { "input": "969640267457 377175394707", "output": "1" }, { "input": "23566875403 21584772251", "output": "1" }, { "input": "730748768952 136728169835", "output": "1" }, { "input": "997200247414 829838591426", "output": "1" }, { "input": "331725641503 251068357277", "output": "1" }, { "input": "218332248232 166864935018", "output": "1" }, { "input": "275876196794 55444205659", "output": "1" }, { "input": "500133829908 188040404706", "output": "1" }, { "input": "483154390901 170937413735", "output": "1" }, { "input": "397631788999 80374663977", "output": "1" }, { "input": "937746931140 714211328211", "output": "1" }, { "input": "483650008814 63656897108", "output": "1" }, { "input": "927159567 694653032", "output": "1" }, { "input": "1 1000000000000", "output": "1" }, { "input": "1000000007 1000000007", "output": "1" }, { "input": "123456789 123", "output": "1" }, { "input": "2 100000000000", "output": "1" }, { "input": "9903870440 9831689586", "output": "1" }, { "input": "29000000261 4", "output": "879140815" }, { "input": "1000000009 3", "output": "281397888" }, { "input": "96000000673 3", "output": "999999975" } ]

1,608,218,108

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

6

2,000

307,200

mod=1e9+7 def primeFactors(n): factores=[] if n%2==0: exp=0 while n%2 ==0: exp+=1 n//=2 factores.append((2,exp)) i=3 while(i*i<=n): if(n%i==0): exp=0 while n%i ==0: exp+=1 n//=i factores.append((i,exp)) i+=2 if n > 2: factores.append((n,1)) return factores def Phi(n): phi=1 for fact in primeFactors(n): phi*=(fact[0]**(fact[1]-1))*(fact[0]-1) return phi def f(n): return Phi(n) def g(n): return n n,k=map(int,input().split()) ans=n for i in range(1,k+1): if i ==1: ans=f(g(ans)) elif i%2==0: ans=g(ans) else: ans=f(ans) ans=int(ans%mod) print(ans)

Title: The Holmes Children Time Limit: None seconds Memory Limit: None megabytes Problem Description: The Holmes children are fighting over who amongst them is the cleverest. Mycroft asked Sherlock and Eurus to find value of *f*(*n*), where *f*(1)<==<=1 and for *n*<=≥<=2, *f*(*n*) is the number of distinct ordered positive integer pairs (*x*,<=*y*) that satisfy *x*<=+<=*y*<==<=*n* and *gcd*(*x*,<=*y*)<==<=1. The integer *gcd*(*a*,<=*b*) is the greatest common divisor of *a* and *b*. Sherlock said that solving this was child's play and asked Mycroft to instead get the value of . Summation is done over all positive integers *d* that divide *n*. Eurus was quietly observing all this and finally came up with her problem to astonish both Sherlock and Mycroft. She defined a *k*-composite function *F**k*(*n*) recursively as follows: She wants them to tell the value of *F**k*(*n*) modulo 1000000007. Input Specification: A single line of input contains two space separated integers *n* (1<=≤<=*n*<=≤<=1012) and *k* (1<=≤<=*k*<=≤<=1012) indicating that Eurus asks Sherlock and Mycroft to find the value of *F**k*(*n*) modulo 1000000007. Output Specification: Output a single integer — the value of *F**k*(*n*) modulo 1000000007. Demo Input: ['7 1\n', '10 2\n'] Demo Output: ['6', '4'] Note: In the first case, there are 6 distinct ordered pairs (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) and (6, 1) satisfying *x* + *y* = 7 and *gcd*(*x*, *y*) = 1. Hence, *f*(7) = 6. So, *F*1(7) = *f*(*g*(7)) = *f*(*f*(7) + *f*(1)) = *f*(6 + 1) = *f*(7) = 6.

```python mod=1e9+7 def primeFactors(n): factores=[] if n%2==0: exp=0 while n%2 ==0: exp+=1 n//=2 factores.append((2,exp)) i=3 while(i*i<=n): if(n%i==0): exp=0 while n%i ==0: exp+=1 n//=i factores.append((i,exp)) i+=2 if n > 2: factores.append((n,1)) return factores def Phi(n): phi=1 for fact in primeFactors(n): phi*=(fact[0]**(fact[1]-1))*(fact[0]-1) return phi def f(n): return Phi(n) def g(n): return n n,k=map(int,input().split()) ans=n for i in range(1,k+1): if i ==1: ans=f(g(ans)) elif i%2==0: ans=g(ans) else: ans=f(ans) ans=int(ans%mod) print(ans) ```

0

757

A

Gotta Catch Em' All!

PROGRAMMING

1,000

[ "implementation" ]

null

Bash wants to become a Pokemon master one day. Although he liked a lot of Pokemon, he has always been fascinated by Bulbasaur the most. Soon, things started getting serious and his fascination turned into an obsession. Since he is too young to go out and catch Bulbasaur, he came up with his own way of catching a Bulbasaur. Each day, he takes the front page of the newspaper. He cuts out the letters one at a time, from anywhere on the front page of the newspaper to form the word "Bulbasaur" (without quotes) and sticks it on his wall. Bash is very particular about case — the first letter of "Bulbasaur" must be upper case and the rest must be lower case. By doing this he thinks he has caught one Bulbasaur. He then repeats this step on the left over part of the newspaper. He keeps doing this until it is not possible to form the word "Bulbasaur" from the newspaper. Given the text on the front page of the newspaper, can you tell how many Bulbasaurs he will catch today? Note: uppercase and lowercase letters are considered different.

Input contains a single line containing a string *s* (1<=<=≤<=<=|*s*|<=<=≤<=<=105) — the text on the front page of the newspaper without spaces and punctuation marks. |*s*| is the length of the string *s*. The string *s* contains lowercase and uppercase English letters, i.e. .

Output a single integer, the answer to the problem.

[ "Bulbbasaur\n", "F\n", "aBddulbasaurrgndgbualdBdsagaurrgndbb\n" ]

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

In the first case, you could pick: Bulbbasaur. In the second case, there is no way to pick even a single Bulbasaur. In the third case, you can rearrange the string to BulbasaurBulbasauraddrgndgddgargndbb to get two words "Bulbasaur".

500

[ { "input": "Bulbbasaur", "output": "1" }, { "input": "F", "output": "0" }, { "input": "aBddulbasaurrgndgbualdBdsagaurrgndbb", "output": "2" }, { "input": "BBBBBBBBBBbbbbbbbbbbuuuuuuuuuullllllllllssssssssssaaaaaaaaaarrrrrrrrrr", "output": "5" }, { "input": "BBBBBBBBBBbbbbbbbbbbbbbbbbbbbbuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuussssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "0" }, { "input": "BBBBBBBBBBssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrr", "output": "0" }, { "input": "BBBBBBBBBBbbbbbbbbbbbbbbbbbbbbuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuullllllllllllllllllllssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrrrrrrrrr", "output": "10" }, { "input": "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBbbbbbbbbbbbbbbbbbbbbuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuullllllllllllllllllllssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrrrrrrrrrrrrrrrrrrr", "output": "20" }, { "input": "CeSlSwec", "output": "0" }, { "input": "PnMrWPBGzVcmRcO", "output": "0" }, { "input": "hHPWBQeEmCuhdCnzrqYtuFtwxokGhdGkFtsFICVqYfJeUrSBtSxEbzMCblOgqOvjXURhSKivPcseqgiNuUgIboEYMvVeRBbpzCGCfVydDvZNFGSFidwUtNbmPSfSYdMNmHgchIsiVswzFsGQewlMVEzicOagpWMdCWrCdPmexfnM", "output": "0" }, { "input": "BBBBBBBBBBbbbbbbbbbbbbuuuuuuuuuuuullllllllllllssssssssssssaaaaaaaaaaaarrrrrrrrrrrrZBphUC", "output": "6" }, { "input": "bulsar", "output": "0" }, { "input": "Bblsar", "output": "0" }, { "input": "Bbusar", "output": "0" }, { "input": "Bbular", "output": "0" }, { "input": "Bbulsr", "output": "0" }, { "input": "Bbulsa", "output": "0" }, { "input": "Bbulsar", "output": "0" }, { "input": "Bbulsar", "output": "0" }, { "input": "CaQprCjTiQACZjUJjSmMHVTDorSUugvTtksEjptVzNLhClWaVVWszIixBlqFkvjDmbRjarQoUWhXHoCgYNNjvEgRTgKpbdEMFsmqcTyvJzupKgYiYMtrZWXIAGVhmDURtddbBZIMgIgXqQUmXpssLSaVCDGZDHimNthwiAWabjtcraAQugMCpBPQZbBGZyqUZmzDVSvJZmDWfZEUHGJVtiJANAIbvjTxtvvTbjWRpNQZlxAqpLCLRVwYWqLaHOTvzgeNGdxiBwsAVKKsewXMTwZUUfxYwrwsiaRBwEdvDDoPsQUtinvajBoRzLBUuQekhjsfDAOQzIABSVPitRuhvvqeAahsSELTGbCPh", "output": "2" }, { "input": "Bulbasaur", "output": "1" }, { "input": "BulbasaurBulbasaur", "output": "2" }, { "input": "Bulbbasar", "output": "0" }, { "input": "Bulbasur", "output": "0" }, { "input": "Bulbsaur", "output": "0" }, { "input": "BulbsurBulbsurBulbsurBulbsur", "output": "0" }, { "input": "Blbbasar", "output": "0" }, { "input": "Bulbasar", "output": "0" }, { "input": "BBullllbbaassaauurr", "output": "1" }, { "input": "BulbasaurBulbasar", "output": "1" }, { "input": "BulbasaurBulbsaur", "output": "1" }, { "input": "Bubasaur", "output": "0" }, { "input": "ulbasaurulbasaur", "output": "0" }, { "input": "Bulbasr", "output": "0" }, { "input": "BBBuuulllbbbaaasssaaauuurrr", "output": "3" }, { "input": "BBuuuullbbaaaassrr", "output": "2" }, { "input": "BBBBBBBuuuuuuuullllllllllllbbbbaaaaaassssssssssssssssaaaaauuuuuuuuuuuuurrrrrrrrrrrrrrrr", "output": "4" }, { "input": "BBuullbbaassaarr", "output": "1" }, { "input": "Bulbasau", "output": "0" }, { "input": "BBuullbbaassaauurr", "output": "2" }, { "input": "BulbasauBulbasauBulbasauBulbasauBulbasauBulbasauBulbasauBulbasau", "output": "0" }, { "input": "Blbasaur", "output": "0" }, { "input": "BulbasaurBulbasaurd", "output": "2" }, { "input": "ulbasaur", "output": "0" }, { "input": "Bulbaaur", "output": "0" }, { "input": "BBuuuullbbbbbbbbbbbbbbbaassrr", "output": "1" }, { "input": "Bulbasua", "output": "0" }, { "input": "Bubbasaur", "output": "0" }, { "input": "BulbasauBulbasauBulbasauBulbasauBulbasauBulbasaurrr", "output": "3" }, { "input": "BulbasaurBubasaur", "output": "1" }, { "input": "Baab", "output": "0" }, { "input": "BulbasaurBulbasau", "output": "1" }, { "input": "Bulbasauu", "output": "0" }, { "input": "BulbasauBulbasau", "output": "0" }, { "input": "BBBBBBBBBBB", "output": "0" }, { "input": "Bulbbasau", "output": "0" }, { "input": "BulbbasaurBulbbasar", "output": "1" }, { "input": "Bulaaaasaur", "output": "0" }, { "input": "BulbasaurBulbasauBulbasauBulbasau", "output": "1" } ]

1,618,597,890

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

62

0

s=input() print(min(s.count('B'),s.count('u'),s.count('l'),s.count('b'),s.count('a'),s.count('s'),s.count('r')))

Title: Gotta Catch Em' All! Time Limit: None seconds Memory Limit: None megabytes Problem Description: Bash wants to become a Pokemon master one day. Although he liked a lot of Pokemon, he has always been fascinated by Bulbasaur the most. Soon, things started getting serious and his fascination turned into an obsession. Since he is too young to go out and catch Bulbasaur, he came up with his own way of catching a Bulbasaur. Each day, he takes the front page of the newspaper. He cuts out the letters one at a time, from anywhere on the front page of the newspaper to form the word "Bulbasaur" (without quotes) and sticks it on his wall. Bash is very particular about case — the first letter of "Bulbasaur" must be upper case and the rest must be lower case. By doing this he thinks he has caught one Bulbasaur. He then repeats this step on the left over part of the newspaper. He keeps doing this until it is not possible to form the word "Bulbasaur" from the newspaper. Given the text on the front page of the newspaper, can you tell how many Bulbasaurs he will catch today? Note: uppercase and lowercase letters are considered different. Input Specification: Input contains a single line containing a string *s* (1<=<=≤<=<=|*s*|<=<=≤<=<=105) — the text on the front page of the newspaper without spaces and punctuation marks. |*s*| is the length of the string *s*. The string *s* contains lowercase and uppercase English letters, i.e. . Output Specification: Output a single integer, the answer to the problem. Demo Input: ['Bulbbasaur\n', 'F\n', 'aBddulbasaurrgndgbualdBdsagaurrgndbb\n'] Demo Output: ['1\n', '0\n', '2\n'] Note: In the first case, you could pick: Bulbbasaur. In the second case, there is no way to pick even a single Bulbasaur. In the third case, you can rearrange the string to BulbasaurBulbasauraddrgndgddgargndbb to get two words "Bulbasaur".

```python s=input() print(min(s.count('B'),s.count('u'),s.count('l'),s.count('b'),s.count('a'),s.count('s'),s.count('r'))) ```

0

318

A

Even Odds

PROGRAMMING

900

[ "math" ]

null

Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*.

The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

Print the number that will stand at the position number *k* after Volodya's manipulations.

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

[ "5", "6" ]

In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

500

[ { "input": "10 3", "output": "5" }, { "input": "7 7", "output": "6" }, { "input": "7 1", "output": "1" }, { "input": "7 2", "output": "3" }, { "input": "8 5", "output": "2" }, { "input": "8 3", "output": "5" }, { "input": "8 4", "output": "7" }, { "input": "1000000000000 500000000001", "output": "2" }, { "input": "999999999997 499999999999", "output": "999999999997" }, { "input": "999999999999 999999999999", "output": "999999999998" }, { "input": "1000000000000 1", "output": "1" }, { "input": "999999999999 1", "output": "1" }, { "input": "1 1", "output": "1" }, { "input": "1000000000000 1000000000000", "output": "1000000000000" }, { "input": "1000000000000 500000000000", "output": "999999999999" }, { "input": "1000000000000 499999999999", "output": "999999999997" }, { "input": "999999999997 499999999998", "output": "999999999995" }, { "input": "619234238 556154835", "output": "493075432" }, { "input": "38151981 36650624", "output": "35149266" }, { "input": "680402465 442571217", "output": "204739968" }, { "input": "109135284 9408714", "output": "18817427" }, { "input": "603701841 56038951", "output": "112077901" }, { "input": "356764822 321510177", "output": "286255532" }, { "input": "284911189 142190783", "output": "284381565" }, { "input": "91028405 61435545", "output": "31842684" } ]

1,697,103,771

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

8

92

0

n,k = map(int, input().split()) if n == 1: print(1) elif k < n/2: print(k*2-1) else: x = (k+(-n//2))*2 print(x if x > 0 else n-1) """ 1 3 5 7 9 2 4 6 8 """ """ 1 3 5 7 2 4 6 8 """

Title: Even Odds Time Limit: None seconds Memory Limit: None megabytes Problem Description: Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*. Input Specification: The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Specification: Print the number that will stand at the position number *k* after Volodya's manipulations. Demo Input: ['10 3\n', '7 7\n'] Demo Output: ['5', '6'] Note: In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

```python n,k = map(int, input().split()) if n == 1: print(1) elif k < n/2: print(k*2-1) else: x = (k+(-n//2))*2 print(x if x > 0 else n-1) """ 1 3 5 7 9 2 4 6 8 """ """ 1 3 5 7 2 4 6 8 """ ```

0

376

A

Lever

PROGRAMMING

900

[ "implementation", "math" ]

null

You have a description of a lever as string *s*. We'll represent the string length as record |*s*|, then the lever looks as a horizontal bar with weights of length |*s*|<=-<=1 with exactly one pivot. We will assume that the bar is a segment on the *Ox* axis between points 0 and |*s*|<=-<=1. The decoding of the lever description is given below. - If the *i*-th character of the string equals "^", that means that at coordinate *i* there is the pivot under the bar. - If the *i*-th character of the string equals "=", that means that at coordinate *i* there is nothing lying on the bar. - If the *i*-th character of the string equals digit *c* (1-9), that means that at coordinate *i* there is a weight of mass *c* on the bar. Your task is, given the lever description, print if it will be in balance or not. Assume that the bar doesn't weight anything. Assume that the bar initially is in balance then all weights are simultaneously put on it. After that the bar either tilts to the left, or tilts to the right, or is in balance.

The first line contains the lever description as a non-empty string *s* (3<=≤<=|*s*|<=≤<=106), consisting of digits (1-9) and characters "^" and "=". It is guaranteed that the line contains exactly one character "^". It is guaranteed that the pivot of the lever isn't located in any end of the lever bar. To solve the problem you may need 64-bit integer numbers. Please, do not forget to use them in your programs.

Print "left" if the given lever tilts to the left, "right" if it tilts to the right and "balance", if it is in balance.

[ "=^==\n", "9===^==1\n", "2==^7==\n", "41^52==\n" ]

[ "balance\n", "left\n", "right\n", "balance\n" ]

As you solve the problem, you may find the following link useful to better understand how a lever functions: http://en.wikipedia.org/wiki/Lever. The pictures to the examples:

500

[ { "input": "=^==", "output": "balance" }, { "input": "9===^==1", "output": "left" }, { "input": "2==^7==", "output": "right" }, { "input": "41^52==", "output": "balance" }, { "input": "=^2=4=1===1=", "output": "right" }, { "input": "9=6===5==3=9=1=1^7=1==", "output": "left" }, { "input": "85=61=36=^93===4==44==35==94===39===15===", "output": "right" }, { "input": "==88=^95==83=45===8====73===7==7====1=29====29=8=85=", "output": "right" }, { "input": "==41^52==", "output": "balance" }, { "input": "2===================^2", "output": "left" }, { "input": "9^=============1", "output": "right" }, { "input": "4=========^=55", "output": "left" }, { "input": "123^321", "output": "balance" }, { "input": "7^1=2", "output": "balance" }, { "input": "589==^==958", "output": "right" } ]

1,626,538,740

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

61

6,758,400

s = input() m = s.index('^') f = lambda x: int(x) if x not in ['=','^'] else 0 k = sum(f(i)*(s.index(i)-m) for i in s) print([['left','right'][0<k],'balance'][k==0]) #l,r = input().split('^') #p,q = l.replace('=',''), r.replace('=','') #a = sum(int(p[::-1][i])*(l[::-1].index(p[::-1][i])+1) for i in range(len(p))) #b = sum(int(q[j])*(r.index(q[j])+1) for j in range(len(q))) #print([['left','right'][a<b],'balance'][a==b]) #a = sum(int(l[::-1][i])*(i+1) for i in range(len(l)) if l[::-1][i] != '=') #b = sum(int(r[j])*(j+1) for j in range(len(r)) if r[j] != '=') #print([['left','right'][a<b],'balance'][a==b])

Title: Lever Time Limit: None seconds Memory Limit: None megabytes Problem Description: You have a description of a lever as string *s*. We'll represent the string length as record |*s*|, then the lever looks as a horizontal bar with weights of length |*s*|<=-<=1 with exactly one pivot. We will assume that the bar is a segment on the *Ox* axis between points 0 and |*s*|<=-<=1. The decoding of the lever description is given below. - If the *i*-th character of the string equals "^", that means that at coordinate *i* there is the pivot under the bar. - If the *i*-th character of the string equals "=", that means that at coordinate *i* there is nothing lying on the bar. - If the *i*-th character of the string equals digit *c* (1-9), that means that at coordinate *i* there is a weight of mass *c* on the bar. Your task is, given the lever description, print if it will be in balance or not. Assume that the bar doesn't weight anything. Assume that the bar initially is in balance then all weights are simultaneously put on it. After that the bar either tilts to the left, or tilts to the right, or is in balance. Input Specification: The first line contains the lever description as a non-empty string *s* (3<=≤<=|*s*|<=≤<=106), consisting of digits (1-9) and characters "^" and "=". It is guaranteed that the line contains exactly one character "^". It is guaranteed that the pivot of the lever isn't located in any end of the lever bar. To solve the problem you may need 64-bit integer numbers. Please, do not forget to use them in your programs. Output Specification: Print "left" if the given lever tilts to the left, "right" if it tilts to the right and "balance", if it is in balance. Demo Input: ['=^==\n', '9===^==1\n', '2==^7==\n', '41^52==\n'] Demo Output: ['balance\n', 'left\n', 'right\n', 'balance\n'] Note: As you solve the problem, you may find the following link useful to better understand how a lever functions: http://en.wikipedia.org/wiki/Lever. The pictures to the examples:

```python s = input() m = s.index('^') f = lambda x: int(x) if x not in ['=','^'] else 0 k = sum(f(i)*(s.index(i)-m) for i in s) print([['left','right'][0<k],'balance'][k==0]) #l,r = input().split('^') #p,q = l.replace('=',''), r.replace('=','') #a = sum(int(p[::-1][i])*(l[::-1].index(p[::-1][i])+1) for i in range(len(p))) #b = sum(int(q[j])*(r.index(q[j])+1) for j in range(len(q))) #print([['left','right'][a<b],'balance'][a==b]) #a = sum(int(l[::-1][i])*(i+1) for i in range(len(l)) if l[::-1][i] != '=') #b = sum(int(r[j])*(j+1) for j in range(len(r)) if r[j] != '=') #print([['left','right'][a<b],'balance'][a==b]) ```

0

660

B

Seating On Bus

PROGRAMMING

1,000

[ "implementation" ]

null

Consider 2*n* rows of the seats in a bus. *n* rows of the seats on the left and *n* rows of the seats on the right. Each row can be filled by two people. So the total capacity of the bus is 4*n*. Consider that *m* (*m*<=≤<=4*n*) people occupy the seats in the bus. The passengers entering the bus are numbered from 1 to *m* (in the order of their entering the bus). The pattern of the seat occupation is as below: 1-st row left window seat, 1-st row right window seat, 2-nd row left window seat, 2-nd row right window seat, ... , *n*-th row left window seat, *n*-th row right window seat. After occupying all the window seats (for *m*<=><=2*n*) the non-window seats are occupied: 1-st row left non-window seat, 1-st row right non-window seat, ... , *n*-th row left non-window seat, *n*-th row right non-window seat. All the passengers go to a single final destination. In the final destination, the passengers get off in the given order. 1-st row left non-window seat, 1-st row left window seat, 1-st row right non-window seat, 1-st row right window seat, ... , *n*-th row left non-window seat, *n*-th row left window seat, *n*-th row right non-window seat, *n*-th row right window seat. You are given the values *n* and *m*. Output *m* numbers from 1 to *m*, the order in which the passengers will get off the bus.

The only line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*m*<=≤<=4*n*) — the number of pairs of rows and the number of passengers.

Print *m* distinct integers from 1 to *m* — the order in which the passengers will get off the bus.

[ "2 7\n", "9 36\n" ]

[ "5 1 6 2 7 3 4\n", "19 1 20 2 21 3 22 4 23 5 24 6 25 7 26 8 27 9 28 10 29 11 30 12 31 13 32 14 33 15 34 16 35 17 36 18\n" ]

none

0

[ { "input": "2 7", "output": "5 1 6 2 7 3 4" }, { "input": "9 36", "output": "19 1 20 2 21 3 22 4 23 5 24 6 25 7 26 8 27 9 28 10 29 11 30 12 31 13 32 14 33 15 34 16 35 17 36 18" }, { "input": "1 1", "output": "1" }, { "input": "1 4", "output": "3 1 4 2" }, { "input": "10 1", "output": "1" }, { "input": "10 10", "output": "1 2 3 4 5 6 7 8 9 10" }, { "input": "10 40", "output": "21 1 22 2 23 3 24 4 25 5 26 6 27 7 28 8 29 9 30 10 31 11 32 12 33 13 34 14 35 15 36 16 37 17 38 18 39 19 40 20" }, { "input": "10 39", "output": "21 1 22 2 23 3 24 4 25 5 26 6 27 7 28 8 29 9 30 10 31 11 32 12 33 13 34 14 35 15 36 16 37 17 38 18 39 19 20" }, { "input": "77 1", "output": "1" }, { "input": "77 13", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13" }, { "input": "77 53", "output": "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" }, { "input": "77 280", "output": "155 1 156 2 157 3 158 4 159 5 160 6 161 7 162 8 163 9 164 10 165 11 166 12 167 13 168 14 169 15 170 16 171 17 172 18 173 19 174 20 175 21 176 22 177 23 178 24 179 25 180 26 181 27 182 28 183 29 184 30 185 31 186 32 187 33 188 34 189 35 190 36 191 37 192 38 193 39 194 40 195 41 196 42 197 43 198 44 199 45 200 46 201 47 202 48 203 49 204 50 205 51 206 52 207 53 208 54 209 55 210 56 211 57 212 58 213 59 214 60 215 61 216 62 217 63 218 64 219 65 220 66 221 67 222 68 223 69 224 70 225 71 226 72 227 73 228 74 22..." }, { "input": "100 1", "output": "1" }, { "input": "100 13", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13" }, { "input": "100 77", "output": "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" }, { "input": "100 103", "output": "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 101 102 103" }, { "input": "100 200", "output": "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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "100 199", "output": "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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "100 201", "output": "201 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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154..." }, { "input": "100 300", "output": "201 1 202 2 203 3 204 4 205 5 206 6 207 7 208 8 209 9 210 10 211 11 212 12 213 13 214 14 215 15 216 16 217 17 218 18 219 19 220 20 221 21 222 22 223 23 224 24 225 25 226 26 227 27 228 28 229 29 230 30 231 31 232 32 233 33 234 34 235 35 236 36 237 37 238 38 239 39 240 40 241 41 242 42 243 43 244 44 245 45 246 46 247 47 248 48 249 49 250 50 251 51 252 52 253 53 254 54 255 55 256 56 257 57 258 58 259 59 260 60 261 61 262 62 263 63 264 64 265 65 266 66 267 67 268 68 269 69 270 70 271 71 272 72 273 73 274 74 27..." }, { "input": "100 399", "output": "201 1 202 2 203 3 204 4 205 5 206 6 207 7 208 8 209 9 210 10 211 11 212 12 213 13 214 14 215 15 216 16 217 17 218 18 219 19 220 20 221 21 222 22 223 23 224 24 225 25 226 26 227 27 228 28 229 29 230 30 231 31 232 32 233 33 234 34 235 35 236 36 237 37 238 38 239 39 240 40 241 41 242 42 243 43 244 44 245 45 246 46 247 47 248 48 249 49 250 50 251 51 252 52 253 53 254 54 255 55 256 56 257 57 258 58 259 59 260 60 261 61 262 62 263 63 264 64 265 65 266 66 267 67 268 68 269 69 270 70 271 71 272 72 273 73 274 74 27..." }, { "input": "100 400", "output": "201 1 202 2 203 3 204 4 205 5 206 6 207 7 208 8 209 9 210 10 211 11 212 12 213 13 214 14 215 15 216 16 217 17 218 18 219 19 220 20 221 21 222 22 223 23 224 24 225 25 226 26 227 27 228 28 229 29 230 30 231 31 232 32 233 33 234 34 235 35 236 36 237 37 238 38 239 39 240 40 241 41 242 42 243 43 244 44 245 45 246 46 247 47 248 48 249 49 250 50 251 51 252 52 253 53 254 54 255 55 256 56 257 57 258 58 259 59 260 60 261 61 262 62 263 63 264 64 265 65 266 66 267 67 268 68 269 69 270 70 271 71 272 72 273 73 274 74 27..." }, { "input": "3 9", "output": "7 1 8 2 9 3 4 5 6" } ]

1,647,698,524

2,147,483,647

Python 3

OK

TESTS

23

46

0

def solve(n,m): n = n*2 # Numero de pares k =1 while(k <= n): if(n+k <=m): print(n+k,end=" ") if(k <= m): print(k,end=" ") k = k+1 n,m = map(int,input("").split()) solve(n,m)

Title: Seating On Bus Time Limit: None seconds Memory Limit: None megabytes Problem Description: Consider 2*n* rows of the seats in a bus. *n* rows of the seats on the left and *n* rows of the seats on the right. Each row can be filled by two people. So the total capacity of the bus is 4*n*. Consider that *m* (*m*<=≤<=4*n*) people occupy the seats in the bus. The passengers entering the bus are numbered from 1 to *m* (in the order of their entering the bus). The pattern of the seat occupation is as below: 1-st row left window seat, 1-st row right window seat, 2-nd row left window seat, 2-nd row right window seat, ... , *n*-th row left window seat, *n*-th row right window seat. After occupying all the window seats (for *m*<=><=2*n*) the non-window seats are occupied: 1-st row left non-window seat, 1-st row right non-window seat, ... , *n*-th row left non-window seat, *n*-th row right non-window seat. All the passengers go to a single final destination. In the final destination, the passengers get off in the given order. 1-st row left non-window seat, 1-st row left window seat, 1-st row right non-window seat, 1-st row right window seat, ... , *n*-th row left non-window seat, *n*-th row left window seat, *n*-th row right non-window seat, *n*-th row right window seat. You are given the values *n* and *m*. Output *m* numbers from 1 to *m*, the order in which the passengers will get off the bus. Input Specification: The only line contains two integers, *n* and *m* (1<=≤<=*n*<=≤<=100,<=1<=≤<=*m*<=≤<=4*n*) — the number of pairs of rows and the number of passengers. Output Specification: Print *m* distinct integers from 1 to *m* — the order in which the passengers will get off the bus. Demo Input: ['2 7\n', '9 36\n'] Demo Output: ['5 1 6 2 7 3 4\n', '19 1 20 2 21 3 22 4 23 5 24 6 25 7 26 8 27 9 28 10 29 11 30 12 31 13 32 14 33 15 34 16 35 17 36 18\n'] Note: none

```python def solve(n,m): n = n*2 # Numero de pares k =1 while(k <= n): if(n+k <=m): print(n+k,end=" ") if(k <= m): print(k,end=" ") k = k+1 n,m = map(int,input("").split()) solve(n,m) ```

3

276

A

Lunch Rush

PROGRAMMING

900

[ "implementation" ]

null

Having written another programming contest, three Rabbits decided to grab some lunch. The coach gave the team exactly *k* time units for the lunch break. The Rabbits have a list of *n* restaurants to lunch in: the *i*-th restaurant is characterized by two integers *f**i* and *t**i*. Value *t**i* shows the time the Rabbits need to lunch in the *i*-th restaurant. If time *t**i* exceeds the time *k* that the coach has given for the lunch break, then the Rabbits' joy from lunching in this restaurant will equal *f**i*<=-<=(*t**i*<=-<=*k*). Otherwise, the Rabbits get exactly *f**i* units of joy. Your task is to find the value of the maximum joy the Rabbits can get from the lunch, depending on the restaurant. The Rabbits must choose exactly one restaurant to lunch in. Note that the joy value isn't necessarily a positive value.

The first line contains two space-separated integers — *n* (1<=≤<=*n*<=≤<=104) and *k* (1<=≤<=*k*<=≤<=109) — the number of restaurants in the Rabbits' list and the time the coach has given them to lunch, correspondingly. Each of the next *n* lines contains two space-separated integers — *f**i* (1<=≤<=*f**i*<=≤<=109) and *t**i* (1<=≤<=*t**i*<=≤<=109) — the characteristics of the *i*-th restaurant.

In a single line print a single integer — the maximum joy value that the Rabbits will get from the lunch.

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

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

none

500

[ { "input": "2 5\n3 3\n4 5", "output": "4" }, { "input": "4 6\n5 8\n3 6\n2 3\n2 2", "output": "3" }, { "input": "1 5\n1 7", "output": "-1" }, { "input": "4 9\n10 13\n4 18\n13 3\n10 6", "output": "13" }, { "input": "1 1\n1 1000000000", "output": "-999999998" }, { "input": "1 1\n1000000000 1000000000", "output": "1" }, { "input": "1 1\n1000000000 1", "output": "1000000000" }, { "input": "2 3\n1000000000 1\n2 2", "output": "1000000000" }, { "input": "2 5\n1 7\n1 1000000000", "output": "-1" } ]

1,657,221,605

2,147,483,647

Python 3

OK

TESTS

35

92

0

numRestaurants, timeGiven = list(map(int, input().split(' '))) maxJoy = float('-inf') for i in range(numRestaurants): currentRestaurantAttributes = list(map(int, input().split(' '))) restaurantJoy = currentRestaurantAttributes[0] restaurantTime = currentRestaurantAttributes[1] currentJoy = 0 if restaurantTime > timeGiven: currentJoy = restaurantJoy - (restaurantTime - timeGiven) else: currentJoy = restaurantJoy if currentJoy > maxJoy: maxJoy = currentJoy print(maxJoy)

Title: Lunch Rush Time Limit: None seconds Memory Limit: None megabytes Problem Description: Having written another programming contest, three Rabbits decided to grab some lunch. The coach gave the team exactly *k* time units for the lunch break. The Rabbits have a list of *n* restaurants to lunch in: the *i*-th restaurant is characterized by two integers *f**i* and *t**i*. Value *t**i* shows the time the Rabbits need to lunch in the *i*-th restaurant. If time *t**i* exceeds the time *k* that the coach has given for the lunch break, then the Rabbits' joy from lunching in this restaurant will equal *f**i*<=-<=(*t**i*<=-<=*k*). Otherwise, the Rabbits get exactly *f**i* units of joy. Your task is to find the value of the maximum joy the Rabbits can get from the lunch, depending on the restaurant. The Rabbits must choose exactly one restaurant to lunch in. Note that the joy value isn't necessarily a positive value. Input Specification: The first line contains two space-separated integers — *n* (1<=≤<=*n*<=≤<=104) and *k* (1<=≤<=*k*<=≤<=109) — the number of restaurants in the Rabbits' list and the time the coach has given them to lunch, correspondingly. Each of the next *n* lines contains two space-separated integers — *f**i* (1<=≤<=*f**i*<=≤<=109) and *t**i* (1<=≤<=*t**i*<=≤<=109) — the characteristics of the *i*-th restaurant. Output Specification: In a single line print a single integer — the maximum joy value that the Rabbits will get from the lunch. Demo Input: ['2 5\n3 3\n4 5\n', '4 6\n5 8\n3 6\n2 3\n2 2\n', '1 5\n1 7\n'] Demo Output: ['4\n', '3\n', '-1\n'] Note: none

```python numRestaurants, timeGiven = list(map(int, input().split(' '))) maxJoy = float('-inf') for i in range(numRestaurants): currentRestaurantAttributes = list(map(int, input().split(' '))) restaurantJoy = currentRestaurantAttributes[0] restaurantTime = currentRestaurantAttributes[1] currentJoy = 0 if restaurantTime > timeGiven: currentJoy = restaurantJoy - (restaurantTime - timeGiven) else: currentJoy = restaurantJoy if currentJoy > maxJoy: maxJoy = currentJoy print(maxJoy) ```

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,630,593,499

2,147,483,647

PyPy 3

OK

TESTS

30

248

25,292,800

n = int(input()) ls = list(map(int, input().split())) x = sum(ls) if x % n == 0: print(n) else: print(n-1)

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()) ls = list(map(int, input().split())) x = sum(ls) if x % n == 0: print(n) else: print(n-1) ```

3

584

A

Olesya and Rodion

PROGRAMMING

1,000

[ "math" ]

null

Olesya loves numbers consisting of *n* digits, and Rodion only likes numbers that are divisible by *t*. Find some number that satisfies both of them. Your task is: given the *n* and *t* print an integer strictly larger than zero consisting of *n* digits that is divisible by *t*. If such number doesn't exist, print <=-<=1.

The single line contains two numbers, *n* and *t* (1<=≤<=*n*<=≤<=100, 2<=≤<=*t*<=≤<=10) — the length of the number and the number it should be divisible by.

Print one such positive number without leading zeroes, — the answer to the problem, or <=-<=1, if such number doesn't exist. If there are multiple possible answers, you are allowed to print any of them.

[ "3 2\n" ]

[ "712" ]

none

500

[ { "input": "3 2", "output": "222" }, { "input": "2 2", "output": "22" }, { "input": "4 3", "output": "3333" }, { "input": "5 3", "output": "33333" }, { "input": "10 7", "output": "7777777777" }, { "input": "2 9", "output": "99" }, { "input": "18 8", "output": "888888888888888888" }, { "input": "1 5", "output": "5" }, { "input": "1 10", "output": "-1" }, { "input": "100 5", "output": "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" }, { "input": "10 2", "output": "2222222222" }, { "input": "18 10", "output": "111111111111111110" }, { "input": "1 9", "output": "9" }, { "input": "7 6", "output": "6666666" }, { "input": "4 4", "output": "4444" }, { "input": "14 7", "output": "77777777777777" }, { "input": "3 8", "output": "888" }, { "input": "1 3", "output": "3" }, { "input": "2 8", "output": "88" }, { "input": "3 8", "output": "888" }, { "input": "4 3", "output": "3333" }, { "input": "5 9", "output": "99999" }, { "input": "4 8", "output": "8888" }, { "input": "3 4", "output": "444" }, { "input": "9 4", "output": "444444444" }, { "input": "8 10", "output": "11111110" }, { "input": "1 6", "output": "6" }, { "input": "20 3", "output": "33333333333333333333" }, { "input": "15 10", "output": "111111111111110" }, { "input": "31 4", "output": "4444444444444444444444444444444" }, { "input": "18 9", "output": "999999999999999999" }, { "input": "72 4", "output": "444444444444444444444444444444444444444444444444444444444444444444444444" }, { "input": "76 8", "output": "8888888888888888888888888888888888888888888888888888888888888888888888888888" }, { "input": "12 5", "output": "555555555555" }, { "input": "54 5", "output": "555555555555555555555555555555555555555555555555555555" }, { "input": "96 10", "output": "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110" }, { "input": "15 9", "output": "999999999999999" }, { "input": "100 2", "output": "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222" }, { "input": "99 3", "output": "333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333" }, { "input": "98 4", "output": "44444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444" }, { "input": "97 5", "output": "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" }, { "input": "100 6", "output": "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666" }, { "input": "99 7", "output": "777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777" }, { "input": "98 8", "output": "88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888" }, { "input": "97 9", "output": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" }, { "input": "100 10", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110" }, { "input": "3 10", "output": "110" }, { "input": "2 4", "output": "44" }, { "input": "2 10", "output": "10" }, { "input": "10 10", "output": "1111111110" }, { "input": "4 10", "output": "1110" }, { "input": "25 10", "output": "1111111111111111111111110" }, { "input": "50 10", "output": "11111111111111111111111111111111111111111111111110" }, { "input": "5 10", "output": "11110" }, { "input": "99 10", "output": "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110" }, { "input": "100 10", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110" }, { "input": "1 2", "output": "2" }, { "input": "20 10", "output": "11111111111111111110" }, { "input": "99 7", "output": "777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777" }, { "input": "89 5", "output": "55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" }, { "input": "6 10", "output": "111110" }, { "input": "3 8", "output": "888" }, { "input": "1 9", "output": "9" }, { "input": "1 4", "output": "4" }, { "input": "100 7", "output": "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777" } ]

1,688,685,709

2,147,483,647

PyPy 3-64

OK

TESTS

65

62

0

n, t = map(int, input().split()) if len(str(10 ** (n - 1))) < len(str(t)): print(-1) else: ans = 10 ** (n - 1) for i in range(12): if ans % t != 0: ans += 1 else: print(ans) break

Title: Olesya and Rodion Time Limit: None seconds Memory Limit: None megabytes Problem Description: Olesya loves numbers consisting of *n* digits, and Rodion only likes numbers that are divisible by *t*. Find some number that satisfies both of them. Your task is: given the *n* and *t* print an integer strictly larger than zero consisting of *n* digits that is divisible by *t*. If such number doesn't exist, print <=-<=1. Input Specification: The single line contains two numbers, *n* and *t* (1<=≤<=*n*<=≤<=100, 2<=≤<=*t*<=≤<=10) — the length of the number and the number it should be divisible by. Output Specification: Print one such positive number without leading zeroes, — the answer to the problem, or <=-<=1, if such number doesn't exist. If there are multiple possible answers, you are allowed to print any of them. Demo Input: ['3 2\n'] Demo Output: ['712'] Note: none

```python n, t = map(int, input().split()) if len(str(10 ** (n - 1))) < len(str(t)): print(-1) else: ans = 10 ** (n - 1) for i in range(12): if ans % t != 0: ans += 1 else: print(ans) break ```

3

370

A

Rook, Bishop and King

PROGRAMMING

1,100

[ "graphs", "math", "shortest paths" ]

null

Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8<=×<=8 table. A field is represented by a pair of integers (*r*,<=*c*) — the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules: - A rook moves any number of fields horizontally or vertically. - A bishop moves any number of fields diagonally. - A king moves one field in any direction — horizontally, vertically or diagonally. Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (*r*1,<=*c*1) to field (*r*2,<=*c*2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.

The input contains four integers *r*1,<=*c*1,<=*r*2,<=*c*2 (1<=≤<=*r*1,<=*c*1,<=*r*2,<=*c*2<=≤<=8) — the coordinates of the starting and the final field. The starting field doesn't coincide with the final one. You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.

Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (*r*1,<=*c*1) to field (*r*2,<=*c*2). If a piece cannot make such a move, print a 0 instead of the corresponding number.

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

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

none

500

[ { "input": "4 3 1 6", "output": "2 1 3" }, { "input": "5 5 5 6", "output": "1 0 1" }, { "input": "1 1 8 8", "output": "2 1 7" }, { "input": "1 1 8 1", "output": "1 0 7" }, { "input": "1 1 1 8", "output": "1 0 7" }, { "input": "8 1 1 1", "output": "1 0 7" }, { "input": "8 1 1 8", "output": "2 1 7" }, { "input": "7 7 6 6", "output": "2 1 1" }, { "input": "8 1 8 8", "output": "1 0 7" }, { "input": "1 8 1 1", "output": "1 0 7" }, { "input": "1 8 8 1", "output": "2 1 7" }, { "input": "1 8 8 8", "output": "1 0 7" }, { "input": "8 8 1 1", "output": "2 1 7" }, { "input": "8 8 1 8", "output": "1 0 7" }, { "input": "8 8 8 1", "output": "1 0 7" }, { "input": "1 3 1 6", "output": "1 0 3" }, { "input": "1 3 1 4", "output": "1 0 1" }, { "input": "1 3 1 5", "output": "1 2 2" }, { "input": "3 3 2 4", "output": "2 1 1" }, { "input": "3 3 1 5", "output": "2 1 2" }, { "input": "1 6 2 1", "output": "2 2 5" }, { "input": "1 5 6 4", "output": "2 2 5" }, { "input": "1 3 3 7", "output": "2 2 4" }, { "input": "1 1 8 1", "output": "1 0 7" }, { "input": "1 7 5 4", "output": "2 0 4" }, { "input": "1 5 2 7", "output": "2 0 2" }, { "input": "1 4 6 2", "output": "2 0 5" }, { "input": "1 2 3 5", "output": "2 0 3" }, { "input": "1 8 8 7", "output": "2 2 7" }, { "input": "6 5 6 2", "output": "1 0 3" }, { "input": "6 3 3 5", "output": "2 0 3" }, { "input": "6 1 7 8", "output": "2 2 7" }, { "input": "1 2 3 2", "output": "1 2 2" }, { "input": "3 8 7 2", "output": "2 2 6" }, { "input": "4 2 6 4", "output": "2 1 2" }, { "input": "1 1 1 3", "output": "1 2 2" }, { "input": "6 8 8 6", "output": "2 1 2" }, { "input": "6 7 4 1", "output": "2 2 6" }, { "input": "6 5 1 4", "output": "2 2 5" }, { "input": "3 2 7 6", "output": "2 1 4" }, { "input": "3 8 4 1", "output": "2 2 7" }, { "input": "3 6 1 4", "output": "2 1 2" } ]

1,621,602,012

2,147,483,647

Python 3

OK

TESTS

42

62

0

x1, y1, x2, y2 = list(map(int, input().split())) dx = abs(x2 - x1) dy = abs(y2 - y1) # for the rook if dx > 0 and dy > 0: print(2, end=" ") elif dx > 0 or dy > 0: print(1, end=" ") def func(a, b, c, d): y = (b+d+c-a)/2 x = (d+c-b+a)/2 return x in range(1,9) and y in range(1,9) # for the bishop if dx == dy: print(1, end=" ") else: if func(x1, y1, x2, y2): print(2, end=" ") elif func(x2, y2, x1, y1): print(2, end=" ") else: print(0, end=" ") # for the king if dx == dy: print(dx) elif dx > dy: print(dx) else: print(dy)

Title: Rook, Bishop and King Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8<=×<=8 table. A field is represented by a pair of integers (*r*,<=*c*) — the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules: - A rook moves any number of fields horizontally or vertically. - A bishop moves any number of fields diagonally. - A king moves one field in any direction — horizontally, vertically or diagonally. Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (*r*1,<=*c*1) to field (*r*2,<=*c*2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem. Input Specification: The input contains four integers *r*1,<=*c*1,<=*r*2,<=*c*2 (1<=≤<=*r*1,<=*c*1,<=*r*2,<=*c*2<=≤<=8) — the coordinates of the starting and the final field. The starting field doesn't coincide with the final one. You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8. Output Specification: Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (*r*1,<=*c*1) to field (*r*2,<=*c*2). If a piece cannot make such a move, print a 0 instead of the corresponding number. Demo Input: ['4 3 1 6\n', '5 5 5 6\n'] Demo Output: ['2 1 3\n', '1 0 1\n'] Note: none

```python x1, y1, x2, y2 = list(map(int, input().split())) dx = abs(x2 - x1) dy = abs(y2 - y1) # for the rook if dx > 0 and dy > 0: print(2, end=" ") elif dx > 0 or dy > 0: print(1, end=" ") def func(a, b, c, d): y = (b+d+c-a)/2 x = (d+c-b+a)/2 return x in range(1,9) and y in range(1,9) # for the bishop if dx == dy: print(1, end=" ") else: if func(x1, y1, x2, y2): print(2, end=" ") elif func(x2, y2, x1, y1): print(2, end=" ") else: print(0, end=" ") # for the king if dx == dy: print(dx) elif dx > dy: print(dx) else: print(dy) ```

3

920

B

Tea Queue

PROGRAMMING

1,200

[ "implementation" ]

null

Recently *n* students from city S moved to city P to attend a programming camp. They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea. *i*-th student comes to the end of the queue at the beginning of *l**i*-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of *r**i*-th second student *i* still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea. For each student determine the second he will use the teapot and get his tea (if he actually gets it).

The first line contains one integer *t* — the number of test cases to solve (1<=≤<=*t*<=≤<=1000). Then *t* test cases follow. The first line of each test case contains one integer *n* (1<=≤<=*n*<=≤<=1000) — the number of students. Then *n* lines follow. Each line contains two integer *l**i*, *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=5000) — the second *i*-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea. It is guaranteed that for every condition *l**i*<=-<=1<=≤<=*l**i* holds. The sum of *n* over all test cases doesn't exceed 1000. Note that in hacks you have to set *t*<==<=1.

For each test case print *n* integers. *i*-th of them must be equal to the second when *i*-th student gets his tea, or 0 if he leaves without tea.

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

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

The example contains 2 tests: 1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second. 1. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.

0

[ { "input": "2\n2\n1 3\n1 4\n3\n1 5\n1 1\n2 3", "output": "1 2 \n1 0 2 " }, { "input": "19\n1\n1 1\n1\n1 2\n1\n1 1000\n1\n1 2000\n1\n2 2\n1\n2 3\n1\n2 1000\n1\n2 2000\n1\n1999 1999\n1\n1999 2000\n1\n2000 2000\n2\n1 1\n1 1\n2\n1 1\n1 2\n2\n1 2\n1 1\n2\n1 2000\n1 1\n2\n1 1\n1 2000\n2\n1 2000\n2 2\n2\n2 2000\n2 2\n2\n2 2\n2 2000", "output": "1 \n1 \n1 \n1 \n2 \n2 \n2 \n2 \n1999 \n1999 \n2000 \n1 0 \n1 2 \n1 0 \n1 0 \n1 2 \n1 2 \n2 0 \n2 3 " }, { "input": "1\n11\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "1 0 0 0 0 0 0 0 0 0 0 " }, { "input": "1\n5\n1 1\n1 2\n1 5\n1 1\n1 1", "output": "1 2 3 0 0 " } ]

1,535,312,243

2,147,483,647

Python 3

OK

TESTS

8

124

0

t=int(input()) for i in range(t): n=int(input()) a=[None]*n sec=a[0]=int(input().split()[0]) for j in range(1,n): l,r=map(int,input().split()) if sec<r: a[j]=sec=max(sec+1,l) else: a[j]=0 print(' '.join(list(map(str,a)))) # Made By Mostafa_Khaled

Title: Tea Queue Time Limit: None seconds Memory Limit: None megabytes Problem Description: Recently *n* students from city S moved to city P to attend a programming camp. They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea. *i*-th student comes to the end of the queue at the beginning of *l**i*-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of *r**i*-th second student *i* still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea. For each student determine the second he will use the teapot and get his tea (if he actually gets it). Input Specification: The first line contains one integer *t* — the number of test cases to solve (1<=≤<=*t*<=≤<=1000). Then *t* test cases follow. The first line of each test case contains one integer *n* (1<=≤<=*n*<=≤<=1000) — the number of students. Then *n* lines follow. Each line contains two integer *l**i*, *r**i* (1<=≤<=*l**i*<=≤<=*r**i*<=≤<=5000) — the second *i*-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea. It is guaranteed that for every condition *l**i*<=-<=1<=≤<=*l**i* holds. The sum of *n* over all test cases doesn't exceed 1000. Note that in hacks you have to set *t*<==<=1. Output Specification: For each test case print *n* integers. *i*-th of them must be equal to the second when *i*-th student gets his tea, or 0 if he leaves without tea. Demo Input: ['2\n2\n1 3\n1 4\n3\n1 5\n1 1\n2 3\n'] Demo Output: ['1 2 \n1 0 2 \n'] Note: The example contains 2 tests: 1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second. 1. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.

```python t=int(input()) for i in range(t): n=int(input()) a=[None]*n sec=a[0]=int(input().split()[0]) for j in range(1,n): l,r=map(int,input().split()) if sec<r: a[j]=sec=max(sec+1,l) else: a[j]=0 print(' '.join(list(map(str,a)))) # Made By Mostafa_Khaled ```

3

742

A

Arpa’s hard exam and Mehrdad’s naive cheat

PROGRAMMING

1,000

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

null

There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do. Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one question, given *n*, print the last digit of 1378*n*. Mehrdad has become quite confused and wants you to help him. Please help, although it's a naive cheat.

The single line of input contains one integer *n* (0<=<=≤<=<=*n*<=<=≤<=<=109).

Print single integer — the last digit of 1378*n*.

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

[ "8", "4" ]

In the first example, last digit of 13781 = 1378 is 8. In the second example, last digit of 13782 = 1378·1378 = 1898884 is 4.

500

[ { "input": "1", "output": "8" }, { "input": "2", "output": "4" }, { "input": "1000", "output": "6" }, { "input": "3", "output": "2" }, { "input": "4", "output": "6" }, { "input": "1000000000", "output": "6" }, { "input": "5", "output": "8" }, { "input": "6", "output": "4" }, { "input": "999999999", "output": "2" }, { "input": "1378", "output": "4" }, { "input": "13781378", "output": "4" }, { "input": "51202278", "output": "4" }, { "input": "999999998", "output": "4" }, { "input": "999999997", "output": "8" }, { "input": "12193721", "output": "8" }, { "input": "0", "output": "1" }, { "input": "989898989", "output": "8" }, { "input": "7", "output": "2" }, { "input": "8", "output": "6" }, { "input": "9", "output": "8" }, { "input": "10", "output": "4" }, { "input": "11", "output": "2" }, { "input": "12", "output": "6" }, { "input": "13", "output": "8" }, { "input": "14", "output": "4" }, { "input": "15", "output": "2" }, { "input": "16", "output": "6" }, { "input": "999999996", "output": "6" }, { "input": "999999995", "output": "2" }, { "input": "999999994", "output": "4" } ]

1,659,008,187

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

31

0

n = int(input()) pw = 0 if 5 > n > 0: print(str(1378 ** pw)[-1]) elif n > 4: if n % 4 == 0: pw = 4 print(str(1378 ** pw)[-1]) else: pw = n % 4 print(str(1378 ** pw)[-1])

Title: Arpa’s hard exam and Mehrdad’s naive cheat Time Limit: None seconds Memory Limit: None megabytes Problem Description: There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do. Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one question, given *n*, print the last digit of 1378*n*. Mehrdad has become quite confused and wants you to help him. Please help, although it's a naive cheat. Input Specification: The single line of input contains one integer *n* (0<=<=≤<=<=*n*<=<=≤<=<=109). Output Specification: Print single integer — the last digit of 1378*n*. Demo Input: ['1\n', '2\n'] Demo Output: ['8', '4'] Note: In the first example, last digit of 13781 = 1378 is 8. In the second example, last digit of 13782 = 1378·1378 = 1898884 is 4.

```python n = int(input()) pw = 0 if 5 > n > 0: print(str(1378 ** pw)[-1]) elif n > 4: if n % 4 == 0: pw = 4 print(str(1378 ** pw)[-1]) else: pw = n % 4 print(str(1378 ** pw)[-1]) ```

0

59

A

Word

PROGRAMMING

800

[ "implementation", "strings" ]

A. Word

2

256

Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word.

The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100.

Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one.

[ "HoUse\n", "ViP\n", "maTRIx\n" ]

[ "house\n", "VIP\n", "matrix\n" ]

none

500

[ { "input": "HoUse", "output": "house" }, { "input": "ViP", "output": "VIP" }, { "input": "maTRIx", "output": "matrix" }, { "input": "BNHWpnpawg", "output": "bnhwpnpawg" }, { "input": "VTYGP", "output": "VTYGP" }, { "input": "CHNenu", "output": "chnenu" }, { "input": "ERPZGrodyu", "output": "erpzgrodyu" }, { "input": "KSXBXWpebh", "output": "KSXBXWPEBH" }, { "input": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv", "output": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv" }, { "input": "Amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd", "output": "amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd" }, { "input": "ISAGFJFARYFBLOPQDSHWGMCNKMFTLVFUGNJEWGWNBLXUIATXEkqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv", "output": "isagfjfaryfblopqdshwgmcnkmftlvfugnjewgwnblxuiatxekqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv" }, { "input": "XHRPXZEGHSOCJPICUIXSKFUZUPYTSGJSDIYBCMNMNBPNDBXLXBzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg", "output": "xhrpxzeghsocjpicuixskfuzupytsgjsdiybcmnmnbpndbxlxbzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg" }, { "input": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGAdkcetqjljtmttlonpekcovdzebzdkzggwfsxhapmjkdbuceak", "output": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGADKCETQJLJTMTTLONPEKCOVDZEBZDKZGGWFSXHAPMJKDBUCEAK" }, { "input": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFw", "output": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFW" }, { "input": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB", "output": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB" }, { "input": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge", "output": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge" }, { "input": "Ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw", "output": "ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw" }, { "input": "YQOMLKYAORUQQUCQZCDYMIVDHGWZFFRMUVTAWCHERFPMNRYRIkgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks", "output": "yqomlkyaoruqqucqzcdymivdhgwzffrmuvtawcherfpmnryrikgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks" }, { "input": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJcuusigdqfkumewjtdyitveeiaybwrhomrwmpdipjwiuxfnwuz", "output": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJCUUSIGDQFKUMEWJTDYITVEEIAYBWRHOMRWMPDIPJWIUXFNWUZ" }, { "input": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWuckzcpxosodcjaaakvlxpbiigsiauviilylnnqlyucziihqg", "output": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWUCKZCPXOSODCJAAAKVLXPBIIGSIAUVIILYLNNQLYUCZIIHQG" }, { "input": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO", "output": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO" }, { "input": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDd", "output": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDD" }, { "input": "EBWOVSNLYTWWXrnovgugogtjahnmatomubebyxakas", "output": "ebwovsnlytwwxrnovgugogtjahnmatomubebyxakas" }, { "input": "AORNNDKTRLRVGDPXJKXFTPFpopuzrlqumrxssskvbm", "output": "AORNNDKTRLRVGDPXJKXFTPFPOPUZRLQUMRXSSSKVBM" }, { "input": "DBBZJCWQEVGYHEEUHJAWRHBDPsnplijbwtdibqrrheebfxqcvn", "output": "dbbzjcwqevgyheeuhjawrhbdpsnplijbwtdibqrrheebfxqcvn" }, { "input": "t", "output": "t" }, { "input": "N", "output": "N" }, { "input": "kv", "output": "kv" }, { "input": "Ur", "output": "ur" }, { "input": "CN", "output": "CN" } ]

1,695,325,475

2,147,483,647

Python 3

OK

TESTS

30

122

0

n=input() l=0 u=0 for i in n: if "a"<=i and i<="z" : l+=1 else : u+=1 if l<u : print(n.upper()) else : print(n.lower())

Title: Word Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word. Input Specification: The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100. Output Specification: Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one. Demo Input: ['HoUse\n', 'ViP\n', 'maTRIx\n'] Demo Output: ['house\n', 'VIP\n', 'matrix\n'] Note: none

```python n=input() l=0 u=0 for i in n: if "a"<=i and i<="z" : l+=1 else : u+=1 if l<u : print(n.upper()) else : print(n.lower()) ```

3.9695

17

A

Noldbach problem

PROGRAMMING

1,000

[ "brute force", "math", "number theory" ]

A. Noldbach problem

2

64

Nick is interested in prime numbers. Once he read about Goldbach problem. It states that every even integer greater than 2 can be expressed as the sum of two primes. That got Nick's attention and he decided to invent a problem of his own and call it Noldbach problem. Since Nick is interested only in prime numbers, Noldbach problem states that at least *k* prime numbers from 2 to *n* inclusively can be expressed as the sum of three integer numbers: two neighboring prime numbers and 1. For example, 19 = 7 + 11 + 1, or 13 = 5 + 7 + 1. Two prime numbers are called neighboring if there are no other prime numbers between them. You are to help Nick, and find out if he is right or wrong.

The first line of the input contains two integers *n* (2<=≤<=*n*<=≤<=1000) and *k* (0<=≤<=*k*<=≤<=1000).

Output YES if at least *k* prime numbers from 2 to *n* inclusively can be expressed as it was described above. Otherwise output NO.

[ "27 2\n", "45 7\n" ]

[ "YES", "NO" ]

In the first sample the answer is YES since at least two numbers can be expressed as it was described (for example, 13 and 19). In the second sample the answer is NO since it is impossible to express 7 prime numbers from 2 to 45 in the desired form.

0

[ { "input": "27 2", "output": "YES" }, { "input": "45 7", "output": "NO" }, { "input": "2 0", "output": "YES" }, { "input": "15 1", "output": "YES" }, { "input": "17 1", "output": "YES" }, { "input": "34 5", "output": "NO" }, { "input": "37 4", "output": "YES" }, { "input": "43 5", "output": "YES" }, { "input": "47 7", "output": "NO" }, { "input": "50 5", "output": "YES" }, { "input": "57 6", "output": "YES" }, { "input": "60 8", "output": "NO" }, { "input": "62 7", "output": "YES" }, { "input": "76 9", "output": "NO" }, { "input": "69 7", "output": "YES" }, { "input": "113 10", "output": "YES" }, { "input": "141 11", "output": "YES" }, { "input": "207 16", "output": "NO" }, { "input": "231 18", "output": "NO" }, { "input": "296 19", "output": "YES" }, { "input": "332 20", "output": "YES" }, { "input": "378 24", "output": "NO" }, { "input": "428 23", "output": "YES" }, { "input": "497 27", "output": "NO" }, { "input": "640 32", "output": "YES" }, { "input": "798 35", "output": "YES" }, { "input": "802 35", "output": "YES" }, { "input": "864 40", "output": "NO" }, { "input": "953 44", "output": "NO" }, { "input": "995 44", "output": "YES" }, { "input": "1000 44", "output": "YES" }, { "input": "1000 0", "output": "YES" }, { "input": "1000 1000", "output": "NO" }, { "input": "2 1000", "output": "NO" }, { "input": "2 0", "output": "YES" } ]

1,689,409,419

2,147,483,647

Python 3

OK

TESTS

35

62

0

n, k = map(int, input().split()) prime = [3, 5] curr = 2 res = 0 for number in range(7, n+1, 2): i = 0 while i < curr and number % prime[i] != 0: i += 1 if i == curr: for j in range(1, curr): if prime[j] + prime[j-1] + 1 == number: k -= 1 break prime.append(number) curr += 1 if k == 0: break print('YES' if k == 0 else 'NO')

Title: Noldbach problem Time Limit: 2 seconds Memory Limit: 64 megabytes Problem Description: Nick is interested in prime numbers. Once he read about Goldbach problem. It states that every even integer greater than 2 can be expressed as the sum of two primes. That got Nick's attention and he decided to invent a problem of his own and call it Noldbach problem. Since Nick is interested only in prime numbers, Noldbach problem states that at least *k* prime numbers from 2 to *n* inclusively can be expressed as the sum of three integer numbers: two neighboring prime numbers and 1. For example, 19 = 7 + 11 + 1, or 13 = 5 + 7 + 1. Two prime numbers are called neighboring if there are no other prime numbers between them. You are to help Nick, and find out if he is right or wrong. Input Specification: The first line of the input contains two integers *n* (2<=≤<=*n*<=≤<=1000) and *k* (0<=≤<=*k*<=≤<=1000). Output Specification: Output YES if at least *k* prime numbers from 2 to *n* inclusively can be expressed as it was described above. Otherwise output NO. Demo Input: ['27 2\n', '45 7\n'] Demo Output: ['YES', 'NO'] Note: In the first sample the answer is YES since at least two numbers can be expressed as it was described (for example, 13 and 19). In the second sample the answer is NO since it is impossible to express 7 prime numbers from 2 to 45 in the desired form.

```python n, k = map(int, input().split()) prime = [3, 5] curr = 2 res = 0 for number in range(7, n+1, 2): i = 0 while i < curr and number % prime[i] != 0: i += 1 if i == curr: for j in range(1, curr): if prime[j] + prime[j-1] + 1 == number: k -= 1 break prime.append(number) curr += 1 if k == 0: break print('YES' if k == 0 else 'NO') ```

3.9845

466

A

Cheap Travel

PROGRAMMING

1,200

[ "implementation" ]

null

Ann has recently started commuting by subway. We know that a one ride subway ticket costs *a* rubles. Besides, Ann found out that she can buy a special ticket for *m* rides (she can buy it several times). It costs *b* rubles. Ann did the math; she will need to use subway *n* times. Help Ann, tell her what is the minimum sum of money she will have to spend to make *n* rides?

The single line contains four space-separated integers *n*, *m*, *a*, *b* (1<=≤<=*n*,<=*m*,<=*a*,<=*b*<=≤<=1000) — the number of rides Ann has planned, the number of rides covered by the *m* ride ticket, the price of a one ride ticket and the price of an *m* ride ticket.

Print a single integer — the minimum sum in rubles that Ann will need to spend.

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

[ "6\n", "8\n" ]

In the first sample one of the optimal solutions is: each time buy a one ride ticket. There are other optimal solutions. For example, buy three *m* ride tickets.

500

[ { "input": "6 2 1 2", "output": "6" }, { "input": "5 2 2 3", "output": "8" }, { "input": "10 3 5 1", "output": "4" }, { "input": "1000 1 1000 1000", "output": "1000000" }, { "input": "1000 3 1000 1000", "output": "334000" }, { "input": "1 1 1 1", "output": "1" }, { "input": "10 2 1 1", "output": "5" }, { "input": "1 1000 1 2", "output": "1" }, { "input": "1 1000 3 2", "output": "2" }, { "input": "10 3 1 2", "output": "7" }, { "input": "995 1 2 1", "output": "995" }, { "input": "556 2 16 15", "output": "4170" }, { "input": "477 2 16 14", "output": "3346" }, { "input": "101 110 1 100", "output": "100" }, { "input": "9 3 3 10", "output": "27" }, { "input": "100 8 10 1", "output": "13" }, { "input": "6 4 1 3", "output": "5" }, { "input": "8 5 2 8", "output": "14" }, { "input": "1000 2 1 1000", "output": "1000" } ]

1,686,591,785

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

31

0

a=list(map(int,input().split())) print([(a[0]//a[1])*a[3]+a[2],(a[0]//a[1])*a[3]][a[0]%a[1]==0])

Title: Cheap Travel Time Limit: None seconds Memory Limit: None megabytes Problem Description: Ann has recently started commuting by subway. We know that a one ride subway ticket costs *a* rubles. Besides, Ann found out that she can buy a special ticket for *m* rides (she can buy it several times). It costs *b* rubles. Ann did the math; she will need to use subway *n* times. Help Ann, tell her what is the minimum sum of money she will have to spend to make *n* rides? Input Specification: The single line contains four space-separated integers *n*, *m*, *a*, *b* (1<=≤<=*n*,<=*m*,<=*a*,<=*b*<=≤<=1000) — the number of rides Ann has planned, the number of rides covered by the *m* ride ticket, the price of a one ride ticket and the price of an *m* ride ticket. Output Specification: Print a single integer — the minimum sum in rubles that Ann will need to spend. Demo Input: ['6 2 1 2\n', '5 2 2 3\n'] Demo Output: ['6\n', '8\n'] Note: In the first sample one of the optimal solutions is: each time buy a one ride ticket. There are other optimal solutions. For example, buy three *m* ride tickets.

```python a=list(map(int,input().split())) print([(a[0]//a[1])*a[3]+a[2],(a[0]//a[1])*a[3]][a[0]%a[1]==0]) ```

0

501

A

Contest

PROGRAMMING

900

[ "implementation" ]

null

Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs *a* points and Vasya solved the problem that costs *b* points. Besides, Misha submitted the problem *c* minutes after the contest started and Vasya submitted the problem *d* minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs *p* points *t* minutes after the contest started, you get points. Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.

The first line contains four integers *a*, *b*, *c*, *d* (250<=≤<=*a*,<=*b*<=≤<=3500, 0<=≤<=*c*,<=*d*<=≤<=180). It is guaranteed that numbers *a* and *b* are divisible by 250 (just like on any real Codeforces round).

Output on a single line: "Misha" (without the quotes), if Misha got more points than Vasya. "Vasya" (without the quotes), if Vasya got more points than Misha. "Tie" (without the quotes), if both of them got the same number of points.

[ "500 1000 20 30\n", "1000 1000 1 1\n", "1500 1000 176 177\n" ]

[ "Vasya\n", "Tie\n", "Misha\n" ]

none

500

[ { "input": "500 1000 20 30", "output": "Vasya" }, { "input": "1000 1000 1 1", "output": "Tie" }, { "input": "1500 1000 176 177", "output": "Misha" }, { "input": "1500 1000 74 177", "output": "Misha" }, { "input": "750 2500 175 178", "output": "Vasya" }, { "input": "750 1000 54 103", "output": "Tie" }, { "input": "2000 1250 176 130", "output": "Tie" }, { "input": "1250 1750 145 179", "output": "Tie" }, { "input": "2000 2000 176 179", "output": "Tie" }, { "input": "1500 1500 148 148", "output": "Tie" }, { "input": "2750 1750 134 147", "output": "Misha" }, { "input": "3250 250 175 173", "output": "Misha" }, { "input": "500 500 170 176", "output": "Misha" }, { "input": "250 1000 179 178", "output": "Vasya" }, { "input": "3250 1000 160 138", "output": "Misha" }, { "input": "3000 2000 162 118", "output": "Tie" }, { "input": "1500 1250 180 160", "output": "Tie" }, { "input": "1250 2500 100 176", "output": "Tie" }, { "input": "3500 3500 177 178", "output": "Tie" }, { "input": "3000 3250 16 34", "output": "Tie" }, { "input": "1750 3000 137 49", "output": "Vasya" }, { "input": "500 1500 179 71", "output": "Vasya" }, { "input": "1250 2000 101 180", "output": "Misha" }, { "input": "250 750 180 176", "output": "Vasya" }, { "input": "2250 2250 163 145", "output": "Vasya" }, { "input": "3000 3000 176 78", "output": "Vasya" }, { "input": "250 3500 8 178", "output": "Vasya" }, { "input": "1750 1250 179 180", "output": "Misha" }, { "input": "2750 1750 13 164", "output": "Misha" }, { "input": "1750 2250 178 53", "output": "Vasya" }, { "input": "2500 2750 73 179", "output": "Misha" }, { "input": "1000 3500 178 175", "output": "Vasya" }, { "input": "1000 500 7 162", "output": "Misha" }, { "input": "1000 250 175 48", "output": "Misha" }, { "input": "1750 500 166 177", "output": "Misha" }, { "input": "250 250 0 0", "output": "Tie" }, { "input": "250 3500 0 0", "output": "Vasya" }, { "input": "250 3500 0 180", "output": "Vasya" }, { "input": "3500 3500 180 180", "output": "Tie" }, { "input": "3500 250 0 180", "output": "Misha" } ]

1,505,386,666

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

46

0

ss = lambda: input() si = lambda: int(input()) a, b, c, d = map(int, input().split()) score = lambda p, t: max(3 * p / 10, p - p / 250 * t) misha, vasya = score(a, c), score(b, d) if (misha > vasya): print("Misha") elif (misha < vasya): print("Vashya") else: print("Tie")

Title: Contest Time Limit: None seconds Memory Limit: None megabytes Problem Description: Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs *a* points and Vasya solved the problem that costs *b* points. Besides, Misha submitted the problem *c* minutes after the contest started and Vasya submitted the problem *d* minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs *p* points *t* minutes after the contest started, you get points. Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth. Input Specification: The first line contains four integers *a*, *b*, *c*, *d* (250<=≤<=*a*,<=*b*<=≤<=3500, 0<=≤<=*c*,<=*d*<=≤<=180). It is guaranteed that numbers *a* and *b* are divisible by 250 (just like on any real Codeforces round). Output Specification: Output on a single line: "Misha" (without the quotes), if Misha got more points than Vasya. "Vasya" (without the quotes), if Vasya got more points than Misha. "Tie" (without the quotes), if both of them got the same number of points. Demo Input: ['500 1000 20 30\n', '1000 1000 1 1\n', '1500 1000 176 177\n'] Demo Output: ['Vasya\n', 'Tie\n', 'Misha\n'] Note: none

```python ss = lambda: input() si = lambda: int(input()) a, b, c, d = map(int, input().split()) score = lambda p, t: max(3 * p / 10, p - p / 250 * t) misha, vasya = score(a, c), score(b, d) if (misha > vasya): print("Misha") elif (misha < vasya): print("Vashya") else: print("Tie") ```

0

792

C

Divide by Three

PROGRAMMING

2,000

[ "dp", "greedy", "math", "number theory" ]

null

A positive integer number *n* is written on a blackboard. It consists of not more than 105 digits. You have to transform it into a beautiful number by erasing some of the digits, and you want to erase as few digits as possible. The number is called beautiful if it consists of at least one digit, doesn't have leading zeroes and is a multiple of 3. For example, 0, 99, 10110 are beautiful numbers, and 00, 03, 122 are not. Write a program which for the given *n* will find a beautiful number such that *n* can be transformed into this number by erasing as few digits as possible. You can erase an arbitraty set of digits. For example, they don't have to go one after another in the number *n*. If it's impossible to obtain a beautiful number, print -1. If there are multiple answers, print any of them.

The first line of input contains *n* — a positive integer number without leading zeroes (1<=≤<=*n*<=<<=10100000).

Print one number — any beautiful number obtained by erasing as few as possible digits. If there is no answer, print <=-<=1.

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

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

In the first example it is enough to erase only the first digit to obtain a multiple of 3. But if we erase the first digit, then we obtain a number with a leading zero. So the minimum number of digits to be erased is two.

0

[ { "input": "1033", "output": "33" }, { "input": "10", "output": "0" }, { "input": "11", "output": "-1" }, { "input": "3", "output": "3" }, { "input": "1", "output": "-1" }, { "input": "117", "output": "117" }, { "input": "518", "output": "18" }, { "input": "327", "output": "327" }, { "input": "270461", "output": "70461" }, { "input": "609209", "output": "60909" }, { "input": "110930", "output": "930" }, { "input": "37616145150713688775", "output": "3616145150713688775" }, { "input": "98509135612114839419", "output": "9509135612114839419" }, { "input": "41674994051436988162", "output": "1674994051436988162" }, { "input": "82547062721736129804", "output": "82547062721736129804" }, { "input": "4902501252475186372406731932548506197390793597574544727433297197476846519276598727359617092494798814", "output": "490501252475186372406731932548506197390793597574544727433297197476846519276598727359617092494798814" }, { "input": "1291007209605301446874998623691572528836214969878676835460982410817526074579818247646933326771899122", "output": "1291007209605301446874998623691572528836214969878676835460982410817526074579818247646933326771899122" }, { "input": "5388306043547446322173224045662327678394712363272776811399689704247387317165308057863239568137902157", "output": "538830603547446322173224045662327678394712363272776811399689704247387317165308057863239568137902157" }, { "input": "20000111", "output": "200001" }, { "input": "100222", "output": "1002" }, { "input": "202", "output": "0" }, { "input": "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033", "output": "33" }, { "input": "101", "output": "0" }, { "input": "1000000222", "output": "10000002" }, { "input": "1001", "output": "0" }, { "input": "205", "output": "0" }, { "input": "102211", "output": "10221" }, { "input": "100000002022", "output": "1000000002" }, { "input": "20203", "output": "3" }, { "input": "1002001", "output": "100200" }, { "input": "10002223", "output": "100023" }, { "input": "1002223", "output": "10023" }, { "input": "100000231", "output": "10000023" }, { "input": "220", "output": "0" }, { "input": "322", "output": "3" }, { "input": "100000222", "output": "1000002" }, { "input": "10033", "output": "33" }, { "input": "2003302", "output": "330" }, { "input": "10011001", "output": "1001001" }, { "input": "20000000011001111", "output": "200000000001111" }, { "input": "100000000", "output": "0" }, { "input": "1000", "output": "0" }, { "input": "200000000000000000000000000008", "output": "0" }, { "input": "1000000000000222", "output": "10000000000002" }, { "input": "100000000000000000222", "output": "1000000000000000002" }, { "input": "29512", "output": "2952" }, { "input": "88888888888888", "output": "888888888888" }, { "input": "100000000000222", "output": "1000000000002" }, { "input": "11000000", "output": "0" }, { "input": "2200", "output": "0" }, { "input": "10000555", "output": "100005" }, { "input": "1000222", "output": "10002" }, { "input": "10021", "output": "1002" }, { "input": "223", "output": "3" }, { "input": "1013", "output": "3" }, { "input": "100020001", "output": "10002000" }, { "input": "20000000000000000000932", "output": "93" }, { "input": "1010", "output": "0" }, { "input": "2000000002222", "output": "20000000022" }, { "input": "10213", "output": "1023" }, { "input": "109111", "output": "10911" }, { "input": "1010101010", "output": "10001010" }, { "input": "300055", "output": "3000" }, { "input": "200200", "output": "0" }, { "input": "202222", "output": "2022" }, { "input": "4000888", "output": "40008" }, { "input": "200000111", "output": "2000001" }, { "input": "2000000111", "output": "20000001" }, { "input": "1000000", "output": "0" }, { "input": "1003301", "output": "330" }, { "input": "100001", "output": "0" }, { "input": "40000000000000000000888", "output": "400000000000000000008" }, { "input": "100000", "output": "0" }, { "input": "4000000888", "output": "40000008" }, { "input": "334733", "output": "3333" }, { "input": "1000002220", "output": "10000020" }, { "input": "100321", "output": "10032" }, { "input": "101111", "output": "1011" }, { "input": "100000000222", "output": "1000000002" }, { "input": "10001", "output": "0" }, { "input": "7", "output": "-1" }, { "input": "2000000000111", "output": "20000000001" }, { "input": "100000001", "output": "0" }, { "input": "10000000000222", "output": "100000000002" }, { "input": "200000000000000111", "output": "2000000000000001" }, { "input": "404044", "output": "40044" }, { "input": "30202", "output": "300" }, { "input": "20000000000000000111", "output": "200000000000000001" }, { "input": "707", "output": "0" }, { "input": "20000300000000003000050000003", "output": "30000000000300000000003" }, { "input": "400000888", "output": "4000008" }, { "input": "2888", "output": "888" }, { "input": "200111", "output": "2001" }, { "input": "10000000888", "output": "100000008" }, { "input": "40000888", "output": "400008" }, { "input": "40404044", "output": "400044" }, { "input": "5500000000", "output": "0" }, { "input": "100012", "output": "10002" }, { "input": "1000007", "output": "0" }, { "input": "200093", "output": "93" }, { "input": "10000000222", "output": "100000002" }, { "input": "20000000002", "output": "0" }, { "input": "74333", "output": "333" }, { "input": "200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008", "output": "0" }, { "input": "10000000111", "output": "1000000011" }, { "input": "100007", "output": "0" }, { "input": "20000006711", "output": "200000061" }, { "input": "8059", "output": "9" }, { "input": "8008", "output": "0" }, { "input": "88", "output": "-1" }, { "input": "2002", "output": "0" }, { "input": "2000111", "output": "20001" }, { "input": "100000000100000002", "output": "10000000000000002" }, { "input": "1000000000000000000000000000000000", "output": "0" }, { "input": "10000000000000000222", "output": "100000000000000002" }, { "input": "1000001", "output": "0" }, { "input": "200000000000111", "output": "2000000000001" }, { "input": "2000000002", "output": "0" }, { "input": "2010000100001", "output": "10000100001" }, { "input": "200330", "output": "330" }, { "input": "10000222", "output": "100002" }, { "input": "2005", "output": "0" }, { "input": "100000000000822", "output": "1000000000002" }, { "input": "10000000000000000000000", "output": "0" }, { "input": "7046", "output": "6" }, { "input": "4000117", "output": "400017" }, { "input": "971", "output": "9" }, { "input": "404", "output": "0" }, { "input": "5", "output": "-1" }, { "input": "164", "output": "6" }, { "input": "140", "output": "0" }, { "input": "74", "output": "-1" }, { "input": "2058232", "output": "20232" }, { "input": "4", "output": "-1" }, { "input": "20206", "output": "6" }, { "input": "103310", "output": "330" }, { "input": "100", "output": "0" }, { "input": "417179", "output": "7179" }, { "input": "70558", "output": "558" }, { "input": "298", "output": "9" }, { "input": "7003", "output": "3" }, { "input": "2212", "output": "222" }, { "input": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "output": "0" }, { "input": "2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002", "output": "0" }, { "input": "1002200", "output": "100200" }, { "input": "1222", "output": "222" }, { "input": "101200100", "output": "10100100" }, { "input": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003", "output": "3" }, { "input": "20020201", "output": "2002020" }, { "input": "12122", "output": "1122" }, { "input": "20200", "output": "0" }, { "input": "2", "output": "-1" }, { "input": "1000000000000258", "output": "10000000000008" } ]

1,683,459,275

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

6

62

0

import sys import math import heapq input = sys.stdin.readline def fgh(): return [int(xx) for xx in input().split()] def fg(): return int(input()) def qw(a): return sorted(a) def rt(): return input()[:-1] def tt(a): d = {} for i in range(len(a)): if a[i] not in d: d[a[i]] = 0 d[a[i]] += 1 s = list(input()[:-1]) n = len(s) for i in range(n): s[i] = int(s[i]) if sum(s) % 3 == 0: print(*s, sep = '') quit() u = sum(s) ans = [] d = {} for i in range(n): d[s[i]] = 1 for i in range(10): for j in range(10): if (u - i - j) % 3 == 0 and i in d and j in d: r = '' fl1 = 0 fl2 = 0 for k in range(n - 1, -1, -1): if s[k] == i and not fl1: fl1 = 1 elif s[k] == j and fl1 and not fl2: fl2 = 1 else: r += str(s[k]) if len(r): r = int(r[::-1]) ans.append((len(str(r)), r)) if len(ans): print(max(ans)[1]) else: print(-1)

Title: Divide by Three Time Limit: None seconds Memory Limit: None megabytes Problem Description: A positive integer number *n* is written on a blackboard. It consists of not more than 105 digits. You have to transform it into a beautiful number by erasing some of the digits, and you want to erase as few digits as possible. The number is called beautiful if it consists of at least one digit, doesn't have leading zeroes and is a multiple of 3. For example, 0, 99, 10110 are beautiful numbers, and 00, 03, 122 are not. Write a program which for the given *n* will find a beautiful number such that *n* can be transformed into this number by erasing as few digits as possible. You can erase an arbitraty set of digits. For example, they don't have to go one after another in the number *n*. If it's impossible to obtain a beautiful number, print -1. If there are multiple answers, print any of them. Input Specification: The first line of input contains *n* — a positive integer number without leading zeroes (1<=≤<=*n*<=<<=10100000). Output Specification: Print one number — any beautiful number obtained by erasing as few as possible digits. If there is no answer, print <=-<=1. Demo Input: ['1033\n', '10\n', '11\n'] Demo Output: ['33\n', '0\n', '-1\n'] Note: In the first example it is enough to erase only the first digit to obtain a multiple of 3. But if we erase the first digit, then we obtain a number with a leading zero. So the minimum number of digits to be erased is two.

```python import sys import math import heapq input = sys.stdin.readline def fgh(): return [int(xx) for xx in input().split()] def fg(): return int(input()) def qw(a): return sorted(a) def rt(): return input()[:-1] def tt(a): d = {} for i in range(len(a)): if a[i] not in d: d[a[i]] = 0 d[a[i]] += 1 s = list(input()[:-1]) n = len(s) for i in range(n): s[i] = int(s[i]) if sum(s) % 3 == 0: print(*s, sep = '') quit() u = sum(s) ans = [] d = {} for i in range(n): d[s[i]] = 1 for i in range(10): for j in range(10): if (u - i - j) % 3 == 0 and i in d and j in d: r = '' fl1 = 0 fl2 = 0 for k in range(n - 1, -1, -1): if s[k] == i and not fl1: fl1 = 1 elif s[k] == j and fl1 and not fl2: fl2 = 1 else: r += str(s[k]) if len(r): r = int(r[::-1]) ans.append((len(str(r)), r)) if len(ans): print(max(ans)[1]) else: print(-1) ```

0

287

B

Pipeline

PROGRAMMING

1,700

[ "binary search", "math" ]

null

Vova, the Ultimate Thule new shaman, wants to build a pipeline. As there are exactly *n* houses in Ultimate Thule, Vova wants the city to have exactly *n* pipes, each such pipe should be connected to the water supply. A pipe can be connected to the water supply if there's water flowing out of it. Initially Vova has only one pipe with flowing water. Besides, Vova has several splitters. A splitter is a construction that consists of one input (it can be connected to a water pipe) and *x* output pipes. When a splitter is connected to a water pipe, water flows from each output pipe. You can assume that the output pipes are ordinary pipes. For example, you can connect water supply to such pipe if there's water flowing out from it. At most one splitter can be connected to any water pipe. Vova has one splitter of each kind: with 2, 3, 4, ..., *k* outputs. Help Vova use the minimum number of splitters to build the required pipeline or otherwise state that it's impossible. Vova needs the pipeline to have exactly *n* pipes with flowing out water. Note that some of those pipes can be the output pipes of the splitters.

The first line contains two space-separated integers *n* and *k* (1<=≤<=*n*<=≤<=1018, 2<=≤<=*k*<=≤<=109). Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Print a single integer — the minimum number of splitters needed to build the pipeline. If it is impossible to build a pipeline with the given splitters, print -1.

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

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

none

1,500

[ { "input": "4 3", "output": "2" }, { "input": "5 5", "output": "1" }, { "input": "8 4", "output": "-1" }, { "input": "1000000000000000000 1000000000", "output": "-1" }, { "input": "499999998500000001 1000000000", "output": "999955279" }, { "input": "499999998500000000 1000000000", "output": "999955279" }, { "input": "499999999500000000 1000000000", "output": "999999998" }, { "input": "499999999500000001 1000000000", "output": "999999999" }, { "input": "525 34", "output": "25" }, { "input": "223265034477 726990", "output": "440662" }, { "input": "15597035789572051 185473109", "output": "128849771" }, { "input": "499999999500000002 1000000000", "output": "-1" }, { "input": "1 1000000000", "output": "0" }, { "input": "1000000000 2", "output": "-1" }, { "input": "462498979 204468265", "output": "3" }, { "input": "2107921 542531", "output": "4" }, { "input": "131 49", "output": "3" }, { "input": "20171878992939541 200857557", "output": "200853401" }, { "input": "399812655947 894219", "output": "893030" }, { "input": "93 17", "output": "8" }, { "input": "1000000000 999999999", "output": "2" }, { "input": "100000000000000000 1000000000", "output": "105572810" } ]

1,655,537,831

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

3

400

198,860,800

n, k = [int(item) for item in input().split()] x = [i for i in range(k, 1, -1)] m = 0 temp = 0 for i in range(k): if n > sum(x) - (len(x) - 1): print(-1) exit(0) else: if x[0] >= n - m: temp += 1 break else: m += x[0] temp += 1 print(temp)

Title: Pipeline Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vova, the Ultimate Thule new shaman, wants to build a pipeline. As there are exactly *n* houses in Ultimate Thule, Vova wants the city to have exactly *n* pipes, each such pipe should be connected to the water supply. A pipe can be connected to the water supply if there's water flowing out of it. Initially Vova has only one pipe with flowing water. Besides, Vova has several splitters. A splitter is a construction that consists of one input (it can be connected to a water pipe) and *x* output pipes. When a splitter is connected to a water pipe, water flows from each output pipe. You can assume that the output pipes are ordinary pipes. For example, you can connect water supply to such pipe if there's water flowing out from it. At most one splitter can be connected to any water pipe. Vova has one splitter of each kind: with 2, 3, 4, ..., *k* outputs. Help Vova use the minimum number of splitters to build the required pipeline or otherwise state that it's impossible. Vova needs the pipeline to have exactly *n* pipes with flowing out water. Note that some of those pipes can be the output pipes of the splitters. Input Specification: The first line contains two space-separated integers *n* and *k* (1<=≤<=*n*<=≤<=1018, 2<=≤<=*k*<=≤<=109). Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Specification: Print a single integer — the minimum number of splitters needed to build the pipeline. If it is impossible to build a pipeline with the given splitters, print -1. Demo Input: ['4 3\n', '5 5\n', '8 4\n'] Demo Output: ['2\n', '1\n', '-1\n'] Note: none

```python n, k = [int(item) for item in input().split()] x = [i for i in range(k, 1, -1)] m = 0 temp = 0 for i in range(k): if n > sum(x) - (len(x) - 1): print(-1) exit(0) else: if x[0] >= n - m: temp += 1 break else: m += x[0] temp += 1 print(temp) ```

0

58

A

Chat room

PROGRAMMING

1,000

[ "greedy", "strings" ]

A. Chat room

1

256

Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*.

The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters.

If Vasya managed to say hello, print "YES", otherwise print "NO".

[ "ahhellllloou\n", "hlelo\n" ]

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

none

500

[ { "input": "ahhellllloou", "output": "YES" }, { "input": "hlelo", "output": "NO" }, { "input": "helhcludoo", "output": "YES" }, { "input": "hehwelloho", "output": "YES" }, { "input": "pnnepelqomhhheollvlo", "output": "YES" }, { "input": "tymbzjyqhymedasloqbq", "output": "NO" }, { "input": "yehluhlkwo", "output": "NO" }, { "input": "hatlevhhalrohairnolsvocafgueelrqmlqlleello", "output": "YES" }, { "input": "hhhtehdbllnhwmbyhvelqqyoulretpbfokflhlhreeflxeftelziclrwllrpflflbdtotvlqgoaoqldlroovbfsq", "output": "YES" }, { "input": "rzlvihhghnelqtwlexmvdjjrliqllolhyewgozkuovaiezgcilelqapuoeglnwmnlftxxiigzczlouooi", "output": "YES" }, { "input": "pfhhwctyqdlkrwhebfqfelhyebwllhemtrmeblgrynmvyhioesqklclocxmlffuormljszllpoo", "output": "YES" }, { "input": "lqllcolohwflhfhlnaow", "output": "NO" }, { "input": "heheeellollvoo", "output": "YES" }, { "input": "hellooo", "output": "YES" }, { "input": "o", "output": "NO" }, { "input": "hhqhzeclohlehljlhtesllylrolmomvuhcxsobtsckogdv", "output": "YES" }, { "input": "yoegfuzhqsihygnhpnukluutocvvwuldiighpogsifealtgkfzqbwtmgghmythcxflebrkctlldlkzlagovwlstsghbouk", "output": "YES" }, { "input": "uatqtgbvrnywfacwursctpagasnhydvmlinrcnqrry", "output": "NO" }, { "input": "tndtbldbllnrwmbyhvqaqqyoudrstpbfokfoclnraefuxtftmgzicorwisrpfnfpbdtatvwqgyalqtdtrjqvbfsq", "output": "NO" }, { "input": "rzlvirhgemelnzdawzpaoqtxmqucnahvqnwldklrmjiiyageraijfivigvozgwngiulttxxgzczptusoi", "output": "YES" }, { "input": "kgyelmchocojsnaqdsyeqgnllytbqietpdlgknwwumqkxrexgdcnwoldicwzwofpmuesjuxzrasscvyuqwspm", "output": "YES" }, { "input": "pnyvrcotjvgynbeldnxieghfltmexttuxzyac", "output": "NO" }, { "input": "dtwhbqoumejligbenxvzhjlhosqojetcqsynlzyhfaevbdpekgbtjrbhlltbceobcok", "output": "YES" }, { "input": "crrfpfftjwhhikwzeedrlwzblckkteseofjuxjrktcjfsylmlsvogvrcxbxtffujqshslemnixoeezivksouefeqlhhokwbqjz", "output": "YES" }, { "input": "jhfbndhyzdvhbvhmhmefqllujdflwdpjbehedlsqfdsqlyelwjtyloxwsvasrbqosblzbowlqjmyeilcvotdlaouxhdpoeloaovb", "output": "YES" }, { "input": "hwlghueoemiqtjhhpashjsouyegdlvoyzeunlroypoprnhlyiwiuxrghekaylndhrhllllwhbebezoglydcvykllotrlaqtvmlla", "output": "YES" }, { "input": "wshiaunnqnqxodholbipwhhjmyeblhgpeleblklpzwhdunmpqkbuzloetmwwxmeltkrcomulxauzlwmlklldjodozxryghsnwgcz", "output": "YES" }, { "input": "shvksednttggehroewuiptvvxtrzgidravtnjwuqrlnnkxbplctzkckinpkgjopjfoxdbojtcvsuvablcbkrzajrlhgobkcxeqti", "output": "YES" }, { "input": "hyyhddqhxhekehkwfhlnlsihzefwchzerevcjtokefplholrbvxlltdlafjxrfhleglrvlolojoqaolagtbeyogxlbgfolllslli", "output": "YES" }, { "input": "iaagrdhhelxpdegueiulflquvlzidoprzkehthkldaytrjwhyhprwjxlltinxvuilxohqgjqcvkkdcuoliekcnlilwgqlnlzouoo", "output": "YES" }, { "input": "wfluaeseldgxyvxpwuhkptdmlflnlhktwxiabsvkolsquymrmhzczzoybvlilhmvsuunggvgxzgyyffk", "output": "NO" }, { "input": "loee", "output": "NO" }, { "input": "izdipwylefqmjbuoznfglgcfvedeouflkeehxbasaqmiooppfsqlhprospqgxvzrcpwlfdddngoqvpwvggsnvvxhmjoslwjudjlo", "output": "NO" }, { "input": "pplynflbjlseflaegzqpdxswgunhnlglqhycrbcwdfhclmcrwekkzsoosmfblljeenwfjyifcvxihhhbyhmhlkvtskeglaovjnsi", "output": "YES" }, { "input": "xqjqmenkodmlhzyzmmvofdngktygbbxbzpluzcohohmalkoeuwfikblltaaigv", "output": "NO" }, { "input": "hello", "output": "YES" }, { "input": "oohell", "output": "NO" }, { "input": "hell", "output": "NO" }, { "input": "eloellohoelo", "output": "NO" }, { "input": "helllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllo", "output": "YES" } ]

1,546,018,411

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

93

0

s=input() l=['h','e','l','l','o'] l.sort() m=list(s) m.sort() a=b=c=d=0 if 'h' in m: a=a+1 if 'e' in m: b=b+1 if 'l' in m: c=c+1 if 'o' in m: d=d+1 if l==m: print("NO") elif l!=m: if a!=1 or b!=1 or c!=2 or d!=1: print('NO') else: print("YES")

Title: Chat room Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*. Input Specification: The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters. Output Specification: If Vasya managed to say hello, print "YES", otherwise print "NO". Demo Input: ['ahhellllloou\n', 'hlelo\n'] Demo Output: ['YES\n', 'NO\n'] Note: none

```python s=input() l=['h','e','l','l','o'] l.sort() m=list(s) m.sort() a=b=c=d=0 if 'h' in m: a=a+1 if 'e' in m: b=b+1 if 'l' in m: c=c+1 if 'o' in m: d=d+1 if l==m: print("NO") elif l!=m: if a!=1 or b!=1 or c!=2 or d!=1: print('NO') else: print("YES") ```

0

794

A

Bank Robbery

PROGRAMMING

800

[ "brute force", "implementation" ]

null

A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes. Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the *i*-th safe from the left is called safe *i*. There are *n* banknotes left in all the safes in total. The *i*-th banknote is in safe *x**i*. Oleg is now at safe *a*. There are two security guards, one of which guards the safe *b* such that *b*<=<<=*a*, i.e. the first guard is to the left of Oleg. The other guard guards the safe *c* so that *c*<=><=*a*, i.e. he is to the right of Oleg. The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather.

The first line of input contains three space-separated integers, *a*, *b* and *c* (1<=≤<=*b*<=<<=*a*<=<<=*c*<=≤<=109), denoting the positions of Oleg, the first security guard and the second security guard, respectively. The next line of input contains a single integer *n* (1<=≤<=*n*<=≤<=105), denoting the number of banknotes. The next line of input contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=109), denoting that the *i*-th banknote is located in the *x**i*-th safe. Note that *x**i* are not guaranteed to be distinct.

Output a single integer: the maximum number of banknotes Oleg can take.

[ "5 3 7\n8\n4 7 5 5 3 6 2 8\n", "6 5 7\n5\n1 5 7 92 3\n" ]

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

In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes. For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.

500

[ { "input": "5 3 7\n8\n4 7 5 5 3 6 2 8", "output": "4" }, { "input": "6 5 7\n5\n1 5 7 92 3", "output": "0" }, { "input": "3 2 4\n1\n3", "output": "1" }, { "input": "5 3 8\n12\n8 3 4 5 7 6 8 3 5 4 7 6", "output": "8" }, { "input": "7 3 10\n5\n3 3 3 3 3", "output": "0" }, { "input": "3 2 5\n4\n1 3 4 5", "output": "2" }, { "input": "3 2 4\n1\n1", "output": "0" }, { "input": "6 4 8\n1\n4", "output": "0" }, { "input": "2 1 3\n1\n3", "output": "0" } ]

1,494,668,679

579

Python 3

OK

TESTS

46

171

7,372,800

s=input() s=s.split() a=int(s[0]) b=int(s[1]) c=int(s[2]) n=int(input()) s=input() s=s.split() count=0 for i in range(n): if(int(s[i])>b and int(s[i])<c): count+=1 print(count)

Title: Bank Robbery Time Limit: None seconds Memory Limit: None megabytes Problem Description: A robber has attempted to rob a bank but failed to complete his task. However, he had managed to open all the safes. Oleg the bank client loves money (who doesn't), and decides to take advantage of this failed robbery and steal some money from the safes. There are many safes arranged in a line, where the *i*-th safe from the left is called safe *i*. There are *n* banknotes left in all the safes in total. The *i*-th banknote is in safe *x**i*. Oleg is now at safe *a*. There are two security guards, one of which guards the safe *b* such that *b*<=<<=*a*, i.e. the first guard is to the left of Oleg. The other guard guards the safe *c* so that *c*<=><=*a*, i.e. he is to the right of Oleg. The two guards are very lazy, so they do not move. In every second, Oleg can either take all the banknotes from the current safe or move to any of the neighboring safes. However, he cannot visit any safe that is guarded by security guards at any time, becaues he might be charged for stealing. Determine the maximum amount of banknotes Oleg can gather. Input Specification: The first line of input contains three space-separated integers, *a*, *b* and *c* (1<=≤<=*b*<=<<=*a*<=<<=*c*<=≤<=109), denoting the positions of Oleg, the first security guard and the second security guard, respectively. The next line of input contains a single integer *n* (1<=≤<=*n*<=≤<=105), denoting the number of banknotes. The next line of input contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (1<=≤<=*x**i*<=≤<=109), denoting that the *i*-th banknote is located in the *x**i*-th safe. Note that *x**i* are not guaranteed to be distinct. Output Specification: Output a single integer: the maximum number of banknotes Oleg can take. Demo Input: ['5 3 7\n8\n4 7 5 5 3 6 2 8\n', '6 5 7\n5\n1 5 7 92 3\n'] Demo Output: ['4\n', '0\n'] Note: In the first example Oleg can take the banknotes in positions 4, 5, 6 (note that there are 2 banknotes at position 5). Oleg can't take the banknotes in safes 7 and 8 because he can't run into the second security guard. Similarly, Oleg cannot take the banknotes at positions 3 and 2 because he can't run into the first security guard. Thus, he can take a maximum of 4 banknotes. For the second sample, Oleg can't take any banknotes without bumping into any of the security guards.

```python s=input() s=s.split() a=int(s[0]) b=int(s[1]) c=int(s[2]) n=int(input()) s=input() s=s.split() count=0 for i in range(n): if(int(s[i])>b and int(s[i])<c): count+=1 print(count) ```

3

916

A

Jamie and Alarm Snooze

PROGRAMMING

900

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

null

Jamie loves sleeping. One day, he decides that he needs to wake up at exactly *hh*:<=*mm*. However, he hates waking up, so he wants to make waking up less painful by setting the alarm at a lucky time. He will then press the snooze button every *x* minutes until *hh*:<=*mm* is reached, and only then he will wake up. He wants to know what is the smallest number of times he needs to press the snooze button. A time is considered lucky if it contains a digit '7'. For example, 13:<=07 and 17:<=27 are lucky, while 00:<=48 and 21:<=34 are not lucky. Note that it is not necessary that the time set for the alarm and the wake-up time are on the same day. It is guaranteed that there is a lucky time Jamie can set so that he can wake at *hh*:<=*mm*. Formally, find the smallest possible non-negative integer *y* such that the time representation of the time *x*·*y* minutes before *hh*:<=*mm* contains the digit '7'. Jamie uses 24-hours clock, so after 23:<=59 comes 00:<=00.

The first line contains a single integer *x* (1<=≤<=*x*<=≤<=60). The second line contains two two-digit integers, *hh* and *mm* (00<=≤<=*hh*<=≤<=23,<=00<=≤<=*mm*<=≤<=59).

Print the minimum number of times he needs to press the button.

[ "3\n11 23\n", "5\n01 07\n" ]

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

In the first sample, Jamie needs to wake up at 11:23. So, he can set his alarm at 11:17. He would press the snooze button when the alarm rings at 11:17 and at 11:20. In the second sample, Jamie can set his alarm at exactly at 01:07 which is lucky.

500

[ { "input": "3\n11 23", "output": "2" }, { "input": "5\n01 07", "output": "0" }, { "input": "34\n09 24", "output": "3" }, { "input": "2\n14 37", "output": "0" }, { "input": "14\n19 54", "output": "9" }, { "input": "42\n15 44", "output": "12" }, { "input": "46\n02 43", "output": "1" }, { "input": "14\n06 41", "output": "1" }, { "input": "26\n04 58", "output": "26" }, { "input": "54\n16 47", "output": "0" }, { "input": "38\n20 01", "output": "3" }, { "input": "11\n02 05", "output": "8" }, { "input": "55\n22 10", "output": "5" }, { "input": "23\n10 08", "output": "6" }, { "input": "23\n23 14", "output": "9" }, { "input": "51\n03 27", "output": "0" }, { "input": "35\n15 25", "output": "13" }, { "input": "3\n12 15", "output": "6" }, { "input": "47\n00 28", "output": "3" }, { "input": "31\n13 34", "output": "7" }, { "input": "59\n17 32", "output": "0" }, { "input": "25\n11 03", "output": "8" }, { "input": "9\n16 53", "output": "4" }, { "input": "53\n04 06", "output": "3" }, { "input": "37\n00 12", "output": "5" }, { "input": "5\n13 10", "output": "63" }, { "input": "50\n01 59", "output": "10" }, { "input": "34\n06 13", "output": "4" }, { "input": "2\n18 19", "output": "1" }, { "input": "46\n06 16", "output": "17" }, { "input": "14\n03 30", "output": "41" }, { "input": "40\n13 37", "output": "0" }, { "input": "24\n17 51", "output": "0" }, { "input": "8\n14 57", "output": "0" }, { "input": "52\n18 54", "output": "2" }, { "input": "20\n15 52", "output": "24" }, { "input": "20\n03 58", "output": "30" }, { "input": "48\n07 11", "output": "0" }, { "input": "32\n04 01", "output": "2" }, { "input": "60\n08 15", "output": "1" }, { "input": "44\n20 20", "output": "4" }, { "input": "55\n15 35", "output": "9" }, { "input": "55\n03 49", "output": "11" }, { "input": "23\n16 39", "output": "4" }, { "input": "7\n20 36", "output": "7" }, { "input": "35\n16 42", "output": "1" }, { "input": "35\n05 56", "output": "21" }, { "input": "3\n17 45", "output": "0" }, { "input": "47\n05 59", "output": "6" }, { "input": "15\n10 13", "output": "9" }, { "input": "59\n06 18", "output": "9" }, { "input": "34\n17 18", "output": "0" }, { "input": "18\n05 23", "output": "2" }, { "input": "46\n17 21", "output": "0" }, { "input": "30\n06 27", "output": "0" }, { "input": "14\n18 40", "output": "3" }, { "input": "58\n22 54", "output": "6" }, { "input": "26\n19 44", "output": "5" }, { "input": "10\n15 57", "output": "0" }, { "input": "54\n20 47", "output": "0" }, { "input": "22\n08 45", "output": "3" }, { "input": "48\n18 08", "output": "1" }, { "input": "32\n07 06", "output": "0" }, { "input": "60\n19 19", "output": "2" }, { "input": "45\n07 25", "output": "0" }, { "input": "29\n12 39", "output": "8" }, { "input": "13\n08 28", "output": "3" }, { "input": "41\n21 42", "output": "5" }, { "input": "41\n09 32", "output": "3" }, { "input": "9\n21 45", "output": "2" }, { "input": "37\n10 43", "output": "5" }, { "input": "3\n20 50", "output": "1" }, { "input": "47\n00 04", "output": "1" }, { "input": "15\n13 10", "output": "21" }, { "input": "15\n17 23", "output": "0" }, { "input": "43\n22 13", "output": "2" }, { "input": "27\n10 26", "output": "6" }, { "input": "55\n22 24", "output": "5" }, { "input": "55\n03 30", "output": "11" }, { "input": "24\n23 27", "output": "0" }, { "input": "52\n11 33", "output": "3" }, { "input": "18\n22 48", "output": "17" }, { "input": "1\n12 55", "output": "8" }, { "input": "1\n04 27", "output": "0" }, { "input": "1\n12 52", "output": "5" }, { "input": "1\n20 16", "output": "9" }, { "input": "1\n04 41", "output": "4" }, { "input": "1\n20 21", "output": "4" }, { "input": "1\n04 45", "output": "8" }, { "input": "1\n12 18", "output": "1" }, { "input": "1\n04 42", "output": "5" }, { "input": "1\n02 59", "output": "2" }, { "input": "1\n18 24", "output": "7" }, { "input": "1\n02 04", "output": "7" }, { "input": "1\n18 28", "output": "1" }, { "input": "1\n18 01", "output": "2" }, { "input": "1\n10 25", "output": "8" }, { "input": "1\n02 49", "output": "2" }, { "input": "1\n02 30", "output": "3" }, { "input": "1\n18 54", "output": "7" }, { "input": "1\n02 19", "output": "2" }, { "input": "1\n05 25", "output": "8" }, { "input": "60\n23 55", "output": "6" }, { "input": "60\n08 19", "output": "1" }, { "input": "60\n00 00", "output": "7" }, { "input": "60\n08 24", "output": "1" }, { "input": "60\n16 13", "output": "9" }, { "input": "60\n08 21", "output": "1" }, { "input": "60\n16 45", "output": "9" }, { "input": "60\n08 26", "output": "1" }, { "input": "60\n08 50", "output": "1" }, { "input": "60\n05 21", "output": "12" }, { "input": "60\n13 29", "output": "6" }, { "input": "60\n05 18", "output": "12" }, { "input": "60\n13 42", "output": "6" }, { "input": "60\n05 07", "output": "0" }, { "input": "60\n05 47", "output": "0" }, { "input": "60\n21 55", "output": "4" }, { "input": "60\n05 36", "output": "12" }, { "input": "60\n21 08", "output": "4" }, { "input": "60\n21 32", "output": "4" }, { "input": "60\n16 31", "output": "9" }, { "input": "5\n00 00", "output": "73" }, { "input": "2\n06 58", "output": "390" }, { "input": "60\n00 00", "output": "7" }, { "input": "2\n00 00", "output": "181" }, { "input": "10\n00 00", "output": "37" }, { "input": "60\n01 00", "output": "8" }, { "input": "12\n00 06", "output": "31" }, { "input": "1\n00 01", "output": "4" }, { "input": "5\n00 05", "output": "74" }, { "input": "60\n01 01", "output": "8" }, { "input": "11\n18 11", "output": "2" }, { "input": "60\n01 15", "output": "8" }, { "input": "10\n00 16", "output": "38" }, { "input": "60\n00 59", "output": "7" }, { "input": "30\n00 00", "output": "13" }, { "input": "60\n01 05", "output": "8" }, { "input": "4\n00 03", "output": "4" }, { "input": "4\n00 00", "output": "91" }, { "input": "60\n00 01", "output": "7" }, { "input": "6\n00 03", "output": "1" }, { "input": "13\n00 00", "output": "1" }, { "input": "1\n18 01", "output": "2" }, { "input": "5\n06 00", "output": "145" }, { "input": "60\n04 08", "output": "11" }, { "input": "5\n01 55", "output": "96" }, { "input": "8\n00 08", "output": "47" }, { "input": "23\n18 23", "output": "2" }, { "input": "6\n00 06", "output": "62" }, { "input": "59\n18 59", "output": "2" }, { "input": "11\n00 10", "output": "3" }, { "input": "10\n00 01", "output": "37" }, { "input": "59\n00 00", "output": "7" }, { "input": "10\n18 10", "output": "2" }, { "input": "5\n00 01", "output": "73" }, { "input": "1\n00 00", "output": "3" }, { "input": "8\n00 14", "output": "47" }, { "input": "60\n03 00", "output": "10" }, { "input": "60\n00 10", "output": "7" }, { "input": "5\n01 13", "output": "87" }, { "input": "30\n02 43", "output": "18" }, { "input": "17\n00 08", "output": "3" }, { "input": "3\n00 00", "output": "1" }, { "input": "60\n00 05", "output": "7" }, { "input": "5\n18 05", "output": "2" }, { "input": "30\n00 30", "output": "14" }, { "input": "1\n00 06", "output": "9" }, { "input": "55\n00 00", "output": "7" }, { "input": "8\n02 08", "output": "62" }, { "input": "7\n00 00", "output": "9" }, { "input": "6\n08 06", "output": "2" }, { "input": "48\n06 24", "output": "16" }, { "input": "8\n06 58", "output": "98" }, { "input": "3\n12 00", "output": "1" }, { "input": "5\n01 06", "output": "86" }, { "input": "2\n00 08", "output": "185" }, { "input": "3\n18 03", "output": "2" }, { "input": "1\n17 00", "output": "0" }, { "input": "59\n00 48", "output": "7" }, { "input": "5\n12 01", "output": "49" }, { "input": "55\n01 25", "output": "9" }, { "input": "2\n07 23", "output": "0" }, { "input": "10\n01 10", "output": "44" }, { "input": "2\n00 01", "output": "2" }, { "input": "59\n00 01", "output": "6" }, { "input": "5\n00 02", "output": "1" }, { "input": "4\n01 02", "output": "106" }, { "input": "5\n00 06", "output": "74" }, { "input": "42\n00 08", "output": "9" }, { "input": "60\n01 20", "output": "8" }, { "input": "3\n06 00", "output": "1" }, { "input": "4\n00 01", "output": "1" }, { "input": "2\n00 06", "output": "184" }, { "input": "1\n00 57", "output": "0" }, { "input": "6\n00 00", "output": "61" }, { "input": "5\n08 40", "output": "9" }, { "input": "58\n00 55", "output": "1" }, { "input": "2\n00 02", "output": "182" }, { "input": "1\n08 01", "output": "2" }, { "input": "10\n10 10", "output": "14" }, { "input": "60\n01 11", "output": "8" }, { "input": "2\n07 00", "output": "0" }, { "input": "15\n00 03", "output": "25" }, { "input": "6\n04 34", "output": "106" }, { "input": "16\n00 16", "output": "24" }, { "input": "2\n00 59", "output": "1" }, { "input": "59\n00 08", "output": "7" }, { "input": "10\n03 10", "output": "56" }, { "input": "3\n08 03", "output": "2" }, { "input": "20\n06 11", "output": "37" }, { "input": "4\n01 00", "output": "106" }, { "input": "38\n01 08", "output": "12" }, { "input": "60\n00 06", "output": "7" }, { "input": "5\n12 00", "output": "49" }, { "input": "6\n01 42", "output": "78" }, { "input": "4\n00 04", "output": "92" }, { "input": "60\n04 05", "output": "11" }, { "input": "1\n00 53", "output": "6" }, { "input": "5\n08 05", "output": "2" }, { "input": "60\n18 45", "output": "1" }, { "input": "60\n06 23", "output": "13" }, { "input": "6\n00 15", "output": "3" }, { "input": "58\n00 06", "output": "7" }, { "input": "2\n06 44", "output": "383" }, { "input": "1\n08 00", "output": "1" }, { "input": "10\n06 58", "output": "78" }, { "input": "59\n00 58", "output": "8" }, { "input": "1\n18 00", "output": "1" }, { "input": "50\n00 42", "output": "9" }, { "input": "30\n18 30", "output": "2" }, { "input": "60\n21 59", "output": "4" }, { "input": "2\n10 52", "output": "87" }, { "input": "56\n00 00", "output": "7" }, { "input": "16\n18 16", "output": "2" }, { "input": "5\n01 05", "output": "86" }, { "input": "5\n05 00", "output": "133" }, { "input": "5\n23 59", "output": "72" }, { "input": "7\n17 13", "output": "0" }, { "input": "58\n00 00", "output": "7" }, { "input": "15\n00 07", "output": "0" }, { "input": "59\n08 00", "output": "1" }, { "input": "46\n00 00", "output": "8" }, { "input": "59\n01 05", "output": "2" }, { "input": "2\n01 00", "output": "211" }, { "input": "60\n00 24", "output": "7" }, { "input": "10\n00 08", "output": "37" }, { "input": "10\n00 06", "output": "37" }, { "input": "60\n01 24", "output": "8" }, { "input": "50\n00 10", "output": "8" }, { "input": "2\n03 00", "output": "271" }, { "input": "4\n19 04", "output": "17" }, { "input": "25\n00 23", "output": "16" }, { "input": "10\n01 01", "output": "43" } ]

1,516,779,746

2,147,483,647

Python 3

OK

TESTS

254

92

6,144,000

# -*- coding:utf-8 -*- """ created by shuangquan.huang at 1/24/18 """ import math import collections import bisect import heapq import time import random import itertools import sys MOD = 24 * 60 X = int(input()) % MOD H, M = map(int, input().split()) ans = 0 while ''.join(map(str, [H, M])).find('7') < 0: t = (H*60 + M - X + MOD) % MOD H = t // 60 M = t % 60 ans += 1 print(ans)

Title: Jamie and Alarm Snooze Time Limit: None seconds Memory Limit: None megabytes Problem Description: Jamie loves sleeping. One day, he decides that he needs to wake up at exactly *hh*:<=*mm*. However, he hates waking up, so he wants to make waking up less painful by setting the alarm at a lucky time. He will then press the snooze button every *x* minutes until *hh*:<=*mm* is reached, and only then he will wake up. He wants to know what is the smallest number of times he needs to press the snooze button. A time is considered lucky if it contains a digit '7'. For example, 13:<=07 and 17:<=27 are lucky, while 00:<=48 and 21:<=34 are not lucky. Note that it is not necessary that the time set for the alarm and the wake-up time are on the same day. It is guaranteed that there is a lucky time Jamie can set so that he can wake at *hh*:<=*mm*. Formally, find the smallest possible non-negative integer *y* such that the time representation of the time *x*·*y* minutes before *hh*:<=*mm* contains the digit '7'. Jamie uses 24-hours clock, so after 23:<=59 comes 00:<=00. Input Specification: The first line contains a single integer *x* (1<=≤<=*x*<=≤<=60). The second line contains two two-digit integers, *hh* and *mm* (00<=≤<=*hh*<=≤<=23,<=00<=≤<=*mm*<=≤<=59). Output Specification: Print the minimum number of times he needs to press the button. Demo Input: ['3\n11 23\n', '5\n01 07\n'] Demo Output: ['2\n', '0\n'] Note: In the first sample, Jamie needs to wake up at 11:23. So, he can set his alarm at 11:17. He would press the snooze button when the alarm rings at 11:17 and at 11:20. In the second sample, Jamie can set his alarm at exactly at 01:07 which is lucky.

```python # -*- coding:utf-8 -*- """ created by shuangquan.huang at 1/24/18 """ import math import collections import bisect import heapq import time import random import itertools import sys MOD = 24 * 60 X = int(input()) % MOD H, M = map(int, input().split()) ans = 0 while ''.join(map(str, [H, M])).find('7') < 0: t = (H*60 + M - X + MOD) % MOD H = t // 60 M = t % 60 ans += 1 print(ans) ```

3

990

B

Micro-World

PROGRAMMING

1,200

[ "greedy", "sortings" ]

null

You have a Petri dish with bacteria and you are preparing to dive into the harsh micro-world. But, unfortunately, you don't have any microscope nearby, so you can't watch them. You know that you have $n$ bacteria in the Petri dish and size of the $i$-th bacteria is $a_i$. Also you know intergalactic positive integer constant $K$. The $i$-th bacteria can swallow the $j$-th bacteria if and only if $a_i > a_j$ and $a_i \le a_j + K$. The $j$-th bacteria disappear, but the $i$-th bacteria doesn't change its size. The bacteria can perform multiple swallows. On each swallow operation any bacteria $i$ can swallow any bacteria $j$ if $a_i > a_j$ and $a_i \le a_j + K$. The swallow operations go one after another. For example, the sequence of bacteria sizes $a=[101, 53, 42, 102, 101, 55, 54]$ and $K=1$. The one of possible sequences of swallows is: $[101, 53, 42, 102, \underline{101}, 55, 54]$ $\to$ $[101, \underline{53}, 42, 102, 55, 54]$ $\to$ $[\underline{101}, 42, 102, 55, 54]$ $\to$ $[42, 102, 55, \underline{54}]$ $\to$ $[42, 102, 55]$. In total there are $3$ bacteria remained in the Petri dish. Since you don't have a microscope, you can only guess, what the minimal possible number of bacteria can remain in your Petri dish when you finally will find any microscope.

The first line contains two space separated positive integers $n$ and $K$ ($1 \le n \le 2 \cdot 10^5$, $1 \le K \le 10^6$) — number of bacteria and intergalactic constant $K$. The second line contains $n$ space separated integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^6$) — sizes of bacteria you have.

Print the only integer — minimal possible number of bacteria can remain.

[ "7 1\n101 53 42 102 101 55 54\n", "6 5\n20 15 10 15 20 25\n", "7 1000000\n1 1 1 1 1 1 1\n" ]

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

The first example is clarified in the problem statement. In the second example an optimal possible sequence of swallows is: $[20, 15, 10, 15, \underline{20}, 25]$ $\to$ $[20, 15, 10, \underline{15}, 25]$ $\to$ $[20, 15, \underline{10}, 25]$ $\to$ $[20, \underline{15}, 25]$ $\to$ $[\underline{20}, 25]$ $\to$ $[25]$. In the third example no bacteria can swallow any other bacteria.

0

[ { "input": "7 1\n101 53 42 102 101 55 54", "output": "3" }, { "input": "6 5\n20 15 10 15 20 25", "output": "1" }, { "input": "7 1000000\n1 1 1 1 1 1 1", "output": "7" }, { "input": "1 1\n1", "output": "1" }, { "input": "1 4\n8", "output": "1" }, { "input": "10 1\n1 2 3 5 6 8 10 11 9 4", "output": "2" }, { "input": "9 2\n1 6 1 5 5 8 6 8 7", "output": "4" }, { "input": "15 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "15" }, { "input": "2 1000000\n1 1000000", "output": "1" }, { "input": "7 2\n1 5 5 8 9 8 8", "output": "4" }, { "input": "10 1\n2 6 3 4 2 4 4 3 2 1", "output": "4" }, { "input": "4 1\n2 2 1 1", "output": "2" }, { "input": "10 1\n6 3 1 3 6 4 1 3 6 4", "output": "7" }, { "input": "2 1\n1 1", "output": "2" }, { "input": "2 1\n1 2", "output": "1" }, { "input": "8 2\n3 13 9 8 3 13 9 14", "output": "5" }, { "input": "8 1000000\n1 1 5 1000000 1000000 2 2 2", "output": "2" }, { "input": "2 1\n999152 999153", "output": "1" } ]

1,531,586,124

2,147,483,647

Python 3

OK

TESTS

36

499

14,336,000

x=list(map(int,input().split())) y=list(map(int,input().split())) y.sort() z=[] c=-1 r=x[0] k=x[0] for i in range (r-1): if y[i]+x[1]>=y[i+1] and y[i+1]>y[i]: j=i-1 while j>=0 and y[j]==y[i]: j-=1 k-=1 k-=1 print(k)

Title: Micro-World Time Limit: None seconds Memory Limit: None megabytes Problem Description: You have a Petri dish with bacteria and you are preparing to dive into the harsh micro-world. But, unfortunately, you don't have any microscope nearby, so you can't watch them. You know that you have $n$ bacteria in the Petri dish and size of the $i$-th bacteria is $a_i$. Also you know intergalactic positive integer constant $K$. The $i$-th bacteria can swallow the $j$-th bacteria if and only if $a_i > a_j$ and $a_i \le a_j + K$. The $j$-th bacteria disappear, but the $i$-th bacteria doesn't change its size. The bacteria can perform multiple swallows. On each swallow operation any bacteria $i$ can swallow any bacteria $j$ if $a_i > a_j$ and $a_i \le a_j + K$. The swallow operations go one after another. For example, the sequence of bacteria sizes $a=[101, 53, 42, 102, 101, 55, 54]$ and $K=1$. The one of possible sequences of swallows is: $[101, 53, 42, 102, \underline{101}, 55, 54]$ $\to$ $[101, \underline{53}, 42, 102, 55, 54]$ $\to$ $[\underline{101}, 42, 102, 55, 54]$ $\to$ $[42, 102, 55, \underline{54}]$ $\to$ $[42, 102, 55]$. In total there are $3$ bacteria remained in the Petri dish. Since you don't have a microscope, you can only guess, what the minimal possible number of bacteria can remain in your Petri dish when you finally will find any microscope. Input Specification: The first line contains two space separated positive integers $n$ and $K$ ($1 \le n \le 2 \cdot 10^5$, $1 \le K \le 10^6$) — number of bacteria and intergalactic constant $K$. The second line contains $n$ space separated integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^6$) — sizes of bacteria you have. Output Specification: Print the only integer — minimal possible number of bacteria can remain. Demo Input: ['7 1\n101 53 42 102 101 55 54\n', '6 5\n20 15 10 15 20 25\n', '7 1000000\n1 1 1 1 1 1 1\n'] Demo Output: ['3\n', '1\n', '7\n'] Note: The first example is clarified in the problem statement. In the second example an optimal possible sequence of swallows is: $[20, 15, 10, 15, \underline{20}, 25]$ $\to$ $[20, 15, 10, \underline{15}, 25]$ $\to$ $[20, 15, \underline{10}, 25]$ $\to$ $[20, \underline{15}, 25]$ $\to$ $[\underline{20}, 25]$ $\to$ $[25]$. In the third example no bacteria can swallow any other bacteria.

```python x=list(map(int,input().split())) y=list(map(int,input().split())) y.sort() z=[] c=-1 r=x[0] k=x[0] for i in range (r-1): if y[i]+x[1]>=y[i+1] and y[i+1]>y[i]: j=i-1 while j>=0 and y[j]==y[i]: j-=1 k-=1 k-=1 print(k) ```

3

155

A

I_love_\%username\%

PROGRAMMING

800

[ "brute force" ]

null

Vasya adores sport programming. He can't write programs but he loves to watch the contests' progress. Vasya even has a favorite coder and Vasya pays special attention to him. One day Vasya decided to collect the results of all contests where his favorite coder participated and track the progress of his coolness. For each contest where this coder participated, he wrote out a single non-negative number — the number of points his favorite coder earned in the contest. Vasya wrote out the points for the contest in the order, in which the contests run (naturally, no two contests ran simultaneously). Vasya considers a coder's performance in a contest amazing in two situations: he can break either his best or his worst performance record. First, it is amazing if during the contest the coder earns strictly more points that he earned on each past contest. Second, it is amazing if during the contest the coder earns strictly less points that he earned on each past contest. A coder's first contest isn't considered amazing. Now he wants to count the number of amazing performances the coder had throughout his whole history of participating in contests. But the list of earned points turned out long and Vasya can't code... That's why he asks you to help him.

The first line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of contests where the coder participated. The next line contains *n* space-separated non-negative integer numbers — they are the points which the coder has earned. The points are given in the chronological order. All points do not exceed 10000.

Print the single number — the number of amazing performances the coder has had during his whole history of participating in the contests.

[ "5\n100 50 200 150 200\n", "10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242\n" ]

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

In the first sample the performances number 2 and 3 are amazing. In the second sample the performances number 2, 4, 9 and 10 are amazing.

500

[ { "input": "5\n100 50 200 150 200", "output": "2" }, { "input": "10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242", "output": "4" }, { "input": "1\n6", "output": "0" }, { "input": "2\n2 1", "output": "1" }, { "input": "5\n100 36 53 7 81", "output": "2" }, { "input": "5\n7 36 53 81 100", "output": "4" }, { "input": "5\n100 81 53 36 7", "output": "4" }, { "input": "10\n8 6 3 4 9 10 7 7 1 3", "output": "5" }, { "input": "10\n1627 1675 1488 1390 1812 1137 1746 1324 1952 1862", "output": "6" }, { "input": "10\n1 3 3 4 6 7 7 8 9 10", "output": "7" }, { "input": "10\n1952 1862 1812 1746 1675 1627 1488 1390 1324 1137", "output": "9" }, { "input": "25\n1448 4549 2310 2725 2091 3509 1565 2475 2232 3989 4231 779 2967 2702 608 3739 721 1552 2767 530 3114 665 1940 48 4198", "output": "5" }, { "input": "33\n1097 1132 1091 1104 1049 1038 1023 1080 1104 1029 1035 1061 1049 1060 1088 1106 1105 1087 1063 1076 1054 1103 1047 1041 1028 1120 1126 1063 1117 1110 1044 1093 1101", "output": "5" }, { "input": "34\n821 5536 2491 6074 7216 9885 764 1603 778 8736 8987 771 617 1587 8943 7922 439 7367 4115 8886 7878 6899 8811 5752 3184 3401 9760 9400 8995 4681 1323 6637 6554 6498", "output": "7" }, { "input": "68\n6764 6877 6950 6768 6839 6755 6726 6778 6699 6805 6777 6985 6821 6801 6791 6805 6940 6761 6677 6999 6911 6699 6959 6933 6903 6843 6972 6717 6997 6756 6789 6668 6735 6852 6735 6880 6723 6834 6810 6694 6780 6679 6698 6857 6826 6896 6979 6968 6957 6988 6960 6700 6919 6892 6984 6685 6813 6678 6715 6857 6976 6902 6780 6686 6777 6686 6842 6679", "output": "9" }, { "input": "60\n9000 9014 9034 9081 9131 9162 9174 9199 9202 9220 9221 9223 9229 9235 9251 9260 9268 9269 9270 9298 9307 9309 9313 9323 9386 9399 9407 9495 9497 9529 9531 9544 9614 9615 9627 9627 9643 9654 9656 9657 9685 9699 9701 9736 9745 9758 9799 9827 9843 9845 9854 9854 9885 9891 9896 9913 9942 9963 9986 9992", "output": "57" }, { "input": "100\n7 61 12 52 41 16 34 99 30 44 48 89 31 54 21 1 48 52 61 15 35 87 21 76 64 92 44 81 16 93 84 92 32 15 68 76 53 39 26 4 11 26 7 4 99 99 61 65 55 85 65 67 47 39 2 74 63 49 98 87 5 94 22 30 25 42 31 84 49 23 89 60 16 26 92 27 9 57 75 61 94 35 83 47 99 100 63 24 91 88 79 10 15 45 22 64 3 11 89 83", "output": "4" }, { "input": "100\n9999 9999 9999 9998 9998 9998 9997 9996 9996 9995 9993 9993 9991 9990 9989 9986 9984 9984 9983 9981 9981 9980 9980 9980 9979 9977 9977 9977 9977 9977 9976 9976 9975 9975 9973 9972 9972 9972 9972 9971 9969 9969 9969 9968 9967 9965 9962 9962 9962 9962 9960 9958 9958 9955 9954 9954 9954 9954 9950 9949 9949 9947 9943 9943 9940 9940 9939 9937 9937 9937 9936 9935 9932 9932 9931 9929 9927 9927 9926 9923 9919 9919 9918 9918 9918 9917 9917 9916 9916 9915 9914 9911 9910 9907 9907 9906 9905 9905 9904 9901", "output": "57" }, { "input": "100\n158 159 157 156 155 154 160 153 161 152 162 163 151 164 150 165 149 148 147 166 146 167 145 144 143 142 168 141 169 170 140 139 138 137 171 136 135 134 172 173 174 133 175 132 177 178 131 179 180 130 129 181 128 127 182 126 183 125 124 184 123 122 121 120 119 118 117 185 186 187 188 189 116 190 115 191 192 193 114 113 112 111 110 109 108 194 195 107 106 105 196 197 104 198 199 103 102 200 101 100", "output": "99" }, { "input": "2\n0 10000", "output": "1" }, { "input": "2\n5 5", "output": "0" }, { "input": "2\n1 1", "output": "0" }, { "input": "2\n10 10", "output": "0" }, { "input": "1\n0", "output": "0" } ]

1,696,649,304

2,147,483,647

PyPy 3-64

OK

TESTS

37

124

0

n = int(input()) score = list(map(int, input().split())) men = mex = score[0] cnt = 0 for i in range(n): if score[i] > mex: mex = score[i] cnt += 1 elif score[i] < men: men = score[i] cnt += 1 print(cnt)

Title: I_love_\%username\% Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya adores sport programming. He can't write programs but he loves to watch the contests' progress. Vasya even has a favorite coder and Vasya pays special attention to him. One day Vasya decided to collect the results of all contests where his favorite coder participated and track the progress of his coolness. For each contest where this coder participated, he wrote out a single non-negative number — the number of points his favorite coder earned in the contest. Vasya wrote out the points for the contest in the order, in which the contests run (naturally, no two contests ran simultaneously). Vasya considers a coder's performance in a contest amazing in two situations: he can break either his best or his worst performance record. First, it is amazing if during the contest the coder earns strictly more points that he earned on each past contest. Second, it is amazing if during the contest the coder earns strictly less points that he earned on each past contest. A coder's first contest isn't considered amazing. Now he wants to count the number of amazing performances the coder had throughout his whole history of participating in contests. But the list of earned points turned out long and Vasya can't code... That's why he asks you to help him. Input Specification: The first line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of contests where the coder participated. The next line contains *n* space-separated non-negative integer numbers — they are the points which the coder has earned. The points are given in the chronological order. All points do not exceed 10000. Output Specification: Print the single number — the number of amazing performances the coder has had during his whole history of participating in the contests. Demo Input: ['5\n100 50 200 150 200\n', '10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242\n'] Demo Output: ['2\n', '4\n'] Note: In the first sample the performances number 2 and 3 are amazing. In the second sample the performances number 2, 4, 9 and 10 are amazing.

```python n = int(input()) score = list(map(int, input().split())) men = mex = score[0] cnt = 0 for i in range(n): if score[i] > mex: mex = score[i] cnt += 1 elif score[i] < men: men = score[i] cnt += 1 print(cnt) ```

3

996

A

Hit the Lottery

PROGRAMMING

800

[ "dp", "greedy" ]

null

Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$. What is the minimum number of bills Allen could receive after withdrawing his entire balance?

The first and only line of input contains a single integer $n$ ($1 \le n \le 10^9$).

Output the minimum number of bills that Allen could receive.

[ "125\n", "43\n", "1000000000\n" ]

[ "3\n", "5\n", "10000000\n" ]

In the first sample case, Allen can withdraw this with a $100$ dollar bill, a $20$ dollar bill, and a $5$ dollar bill. There is no way for Allen to receive $125$ dollars in one or two bills. In the second sample case, Allen can withdraw two $20$ dollar bills and three $1$ dollar bills. In the third sample case, Allen can withdraw $100000000$ (ten million!) $100$ dollar bills.

500

[ { "input": "125", "output": "3" }, { "input": "43", "output": "5" }, { "input": "1000000000", "output": "10000000" }, { "input": "4", "output": "4" }, { "input": "5", "output": "1" }, { "input": "1", "output": "1" }, { "input": "74", "output": "8" }, { "input": "31", "output": "3" }, { "input": "59", "output": "8" }, { "input": "79", "output": "9" }, { "input": "7", "output": "3" }, { "input": "55", "output": "4" }, { "input": "40", "output": "2" }, { "input": "719", "output": "13" }, { "input": "847", "output": "13" }, { "input": "225", "output": "4" }, { "input": "4704", "output": "51" }, { "input": "1132", "output": "15" }, { "input": "7811", "output": "80" }, { "input": "7981", "output": "84" }, { "input": "82655", "output": "830" }, { "input": "6364", "output": "70" }, { "input": "74611", "output": "748" }, { "input": "45391", "output": "459" }, { "input": "620448", "output": "6210" }, { "input": "265145", "output": "2654" }, { "input": "671704", "output": "6721" }, { "input": "365173", "output": "3658" }, { "input": "7130872", "output": "71314" }, { "input": "9628747", "output": "96292" }, { "input": "8898399", "output": "88993" }, { "input": "9497953", "output": "94985" }, { "input": "19070947", "output": "190714" }, { "input": "20185520", "output": "201856" }, { "input": "91402248", "output": "914028" }, { "input": "27035533", "output": "270360" }, { "input": "22717528", "output": "227180" }, { "input": "24403439", "output": "244041" }, { "input": "163565555", "output": "1635659" }, { "input": "152541908", "output": "1525423" }, { "input": "668439837", "output": "6684403" }, { "input": "20", "output": "1" }, { "input": "999999999", "output": "10000009" }, { "input": "10", "output": "1" }, { "input": "7", "output": "3" }, { "input": "6", "output": "2" }, { "input": "99999999", "output": "1000009" }, { "input": "1000001", "output": "10001" }, { "input": "2521", "output": "27" } ]

1,686,892,735

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

6

31

0

n=int(input()) c=0 while n>0: if n>=100: c+=(n//100) n=n%100 elif n<100 and n>=50: c+=(n//50) n=n%50 elif n<50 and n>=20: c+=(n//20) n=n%20 elif n<20 and n>=10: c+=(n//10) n=n%10 elif n<10 and n>=5: c+=(n//5) n=n%5 else: c+=n n=n%1 print(c)

Title: Hit the Lottery Time Limit: None seconds Memory Limit: None megabytes Problem Description: Allen has a LOT of money. He has $n$ dollars in the bank. For security reasons, he wants to withdraw it in cash (we will not disclose the reasons here). The denominations for dollar bills are $1$, $5$, $10$, $20$, $100$. What is the minimum number of bills Allen could receive after withdrawing his entire balance? Input Specification: The first and only line of input contains a single integer $n$ ($1 \le n \le 10^9$). Output Specification: Output the minimum number of bills that Allen could receive. Demo Input: ['125\n', '43\n', '1000000000\n'] Demo Output: ['3\n', '5\n', '10000000\n'] Note: In the first sample case, Allen can withdraw this with a $100$ dollar bill, a $20$ dollar bill, and a $5$ dollar bill. There is no way for Allen to receive $125$ dollars in one or two bills. In the second sample case, Allen can withdraw two $20$ dollar bills and three $1$ dollar bills. In the third sample case, Allen can withdraw $100000000$ (ten million!) $100$ dollar bills.

```python n=int(input()) c=0 while n>0: if n>=100: c+=(n//100) n=n%100 elif n<100 and n>=50: c+=(n//50) n=n%50 elif n<50 and n>=20: c+=(n//20) n=n%20 elif n<20 and n>=10: c+=(n//10) n=n%10 elif n<10 and n>=5: c+=(n//5) n=n%5 else: c+=n n=n%1 print(c) ```

0

131

A

cAPS lOCK

PROGRAMMING

1,000

[ "implementation", "strings" ]

null

wHAT DO WE NEED cAPS LOCK FOR? Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage. Let's consider that a word has been typed with the Caps lock key accidentally switched on, if: - either it only contains uppercase letters; - or all letters except for the first one are uppercase. In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed. Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.

The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.

Print the result of the given word's processing.

[ "cAPS\n", "Lock\n" ]

[ "Caps", "Lock\n" ]

none

500

[ { "input": "cAPS", "output": "Caps" }, { "input": "Lock", "output": "Lock" }, { "input": "cAPSlOCK", "output": "cAPSlOCK" }, { "input": "CAPs", "output": "CAPs" }, { "input": "LoCK", "output": "LoCK" }, { "input": "OOPS", "output": "oops" }, { "input": "oops", "output": "oops" }, { "input": "a", "output": "A" }, { "input": "A", "output": "a" }, { "input": "aA", "output": "Aa" }, { "input": "Zz", "output": "Zz" }, { "input": "Az", "output": "Az" }, { "input": "zA", "output": "Za" }, { "input": "AAA", "output": "aaa" }, { "input": "AAa", "output": "AAa" }, { "input": "AaR", "output": "AaR" }, { "input": "Tdr", "output": "Tdr" }, { "input": "aTF", "output": "Atf" }, { "input": "fYd", "output": "fYd" }, { "input": "dsA", "output": "dsA" }, { "input": "fru", "output": "fru" }, { "input": "hYBKF", "output": "Hybkf" }, { "input": "XweAR", "output": "XweAR" }, { "input": "mogqx", "output": "mogqx" }, { "input": "eOhEi", "output": "eOhEi" }, { "input": "nkdku", "output": "nkdku" }, { "input": "zcnko", "output": "zcnko" }, { "input": "lcccd", "output": "lcccd" }, { "input": "vwmvg", "output": "vwmvg" }, { "input": "lvchf", "output": "lvchf" }, { "input": "IUNVZCCHEWENCHQQXQYPUJCRDZLUXCLJHXPHBXEUUGNXOOOPBMOBRIBHHMIRILYJGYYGFMTMFSVURGYHUWDRLQVIBRLPEVAMJQYO", "output": "iunvzcchewenchqqxqypujcrdzluxcljhxphbxeuugnxooopbmobribhhmirilyjgyygfmtmfsvurgyhuwdrlqvibrlpevamjqyo" }, { "input": "OBHSZCAMDXEJWOZLKXQKIVXUUQJKJLMMFNBPXAEFXGVNSKQLJGXHUXHGCOTESIVKSFMVVXFVMTEKACRIWALAGGMCGFEXQKNYMRTG", "output": "obhszcamdxejwozlkxqkivxuuqjkjlmmfnbpxaefxgvnskqljgxhuxhgcotesivksfmvvxfvmtekacriwalaggmcgfexqknymrtg" }, { "input": "IKJYZIKROIYUUCTHSVSKZTETNNOCMAUBLFJCEVANCADASMZRCNLBZPQRXESHEEMOMEPCHROSRTNBIDXYMEPJSIXSZQEBTEKKUHFS", "output": "ikjyzikroiyuucthsvskztetnnocmaublfjcevancadasmzrcnlbzpqrxesheemomepchrosrtnbidxymepjsixszqebtekkuhfs" }, { "input": "cTKDZNWVYRTFPQLDAUUNSPKTDJTUPPFPRXRSINTVFVNNQNKXWUZUDHZBUSOKTABUEDQKUIVRTTVUREEOBJTSDKJKVEGFXVHXEYPE", "output": "Ctkdznwvyrtfpqldauunspktdjtuppfprxrsintvfvnnqnkxwuzudhzbusoktabuedqkuivrttvureeobjtsdkjkvegfxvhxeype" }, { "input": "uCKJZRGZJCPPLEEYJTUNKOQSWGBMTBQEVPYFPIPEKRVYQNTDPANOIXKMPINNFUSZWCURGBDPYTEKBEKCPMVZPMWAOSHJYMGKOMBQ", "output": "Uckjzrgzjcppleeyjtunkoqswgbmtbqevpyfpipekrvyqntdpanoixkmpinnfuszwcurgbdpytekbekcpmvzpmwaoshjymgkombq" }, { "input": "KETAXTSWAAOBKUOKUQREHIOMVMMRSAEWKGXZKRASwTVNSSFSNIWYNPSTMRADOADEEBURRHPOOBIEUIBGYDJCEKPNLEUCANZYJKMR", "output": "KETAXTSWAAOBKUOKUQREHIOMVMMRSAEWKGXZKRASwTVNSSFSNIWYNPSTMRADOADEEBURRHPOOBIEUIBGYDJCEKPNLEUCANZYJKMR" }, { "input": "ZEKGDMWJPVUWFlNXRLUmWKLMMYSLRQQIBRWDPKWITUIMZYYKOEYGREKHHZRZZUFPVTNIHKGTCCTLOKSZITXXZDMPITHNZUIGDZLE", "output": "ZEKGDMWJPVUWFlNXRLUmWKLMMYSLRQQIBRWDPKWITUIMZYYKOEYGREKHHZRZZUFPVTNIHKGTCCTLOKSZITXXZDMPITHNZUIGDZLE" }, { "input": "TcMbVPCFvnNkCEUUCIFLgBJeCOKuJhIGwXFrhAZjuAhBraMSchBfWwIuHAEbgJOFzGtxDLDXzDSaPCFujGGxgxdlHUIQYRrMFCgJ", "output": "TcMbVPCFvnNkCEUUCIFLgBJeCOKuJhIGwXFrhAZjuAhBraMSchBfWwIuHAEbgJOFzGtxDLDXzDSaPCFujGGxgxdlHUIQYRrMFCgJ" }, { "input": "xFGqoLILNvxARKuIntPfeukFtMbvzDezKpPRAKkIoIvwqNXnehRVwkkXYvuRCeoieBaBfTjwsYhDeCLvBwktntyluoxCYVioXGdm", "output": "xFGqoLILNvxARKuIntPfeukFtMbvzDezKpPRAKkIoIvwqNXnehRVwkkXYvuRCeoieBaBfTjwsYhDeCLvBwktntyluoxCYVioXGdm" }, { "input": "udvqolbxdwbkijwvhlyaelhynmnfgszbhgshlcwdkaibceqomzujndixuzivlsjyjqxzxodzbukxxhwwultvekdfntwpzlhhrIjm", "output": "udvqolbxdwbkijwvhlyaelhynmnfgszbhgshlcwdkaibceqomzujndixuzivlsjyjqxzxodzbukxxhwwultvekdfntwpzlhhrIjm" }, { "input": "jgpwhetqqoncighgzbbaLwwwxkxivuwtokehrgprfgewzcwxkavwoflcgsgbhoeamzbefzoonwsyzisetoydrpufktzgbaycgaeg", "output": "jgpwhetqqoncighgzbbaLwwwxkxivuwtokehrgprfgewzcwxkavwoflcgsgbhoeamzbefzoonwsyzisetoydrpufktzgbaycgaeg" }, { "input": "vyujsazdstbnkxeunedfbolicojzjpufgfemhtmdrswvmuhoivjvonacefqenbqudelmdegxqtbwezsbydmanzutvdgkgrjxzlnc", "output": "vyujsazdstbnkxeunedfbolicojzjpufgfemhtmdrswvmuhoivjvonacefqenbqudelmdegxqtbwezsbydmanzutvdgkgrjxzlnc" }, { "input": "pivqnuqkaofcduvbttztjbuavrqwiqrwkfncmvatoxruelyoecnkpqraiahumiaiqeyjapbqyrsxcdgjbihivtqezvasfmzntdfv", "output": "pivqnuqkaofcduvbttztjbuavrqwiqrwkfncmvatoxruelyoecnkpqraiahumiaiqeyjapbqyrsxcdgjbihivtqezvasfmzntdfv" }, { "input": "upvtbsxswbohxshdrbjxcungzquhuomgxwlryvshshsfvqbrxvcikbglietlpqkiwbhiqpmdwuqosbtdvyxekkaqiwrbsibpoect", "output": "upvtbsxswbohxshdrbjxcungzquhuomgxwlryvshshsfvqbrxvcikbglietlpqkiwbhiqpmdwuqosbtdvyxekkaqiwrbsibpoect" }, { "input": "cTKDZNWVYRTFPQLDAUUNSPKTDJTUPPFPRXRSINTVFVNNQNKXWUZUDHZBUSOKTABUEDQKUIVRTTVUREEOBJTSDKJKVEGFXVHXEYPE", "output": "Ctkdznwvyrtfpqldauunspktdjtuppfprxrsintvfvnnqnkxwuzudhzbusoktabuedqkuivrttvureeobjtsdkjkvegfxvhxeype" }, { "input": "JEGDOFJOFGJHFROGHOFGMHOFGHORGFHMOu", "output": "JEGDOFJOFGJHFROGHOFGMHOFGHORGFHMOu" }, { "input": "aBACABa", "output": "aBACABa" }, { "input": "AAAAAAAAAAAAAAAAAAAAAAAAaa", "output": "AAAAAAAAAAAAAAAAAAAAAAAAaa" }, { "input": "aaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "output": "aaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" }, { "input": "dDDDDDDDDDDDDD", "output": "Dddddddddddddd" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "z", "output": "Z" }, { "input": "AZ", "output": "az" }, { "input": "Z", "output": "z" }, { "input": "aAAAA", "output": "Aaaaa" }, { "input": "F", "output": "f" } ]

1,696,089,877

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

31

0

string = input() string = string.capitalize() print(string)

Title: cAPS lOCK Time Limit: None seconds Memory Limit: None megabytes Problem Description: wHAT DO WE NEED cAPS LOCK FOR? Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage. Let's consider that a word has been typed with the Caps lock key accidentally switched on, if: - either it only contains uppercase letters; - or all letters except for the first one are uppercase. In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed. Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged. Input Specification: The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive. Output Specification: Print the result of the given word's processing. Demo Input: ['cAPS\n', 'Lock\n'] Demo Output: ['Caps', 'Lock\n'] Note: none

```python string = input() string = string.capitalize() print(string) ```

0

376

B

I.O.U.

PROGRAMMING

1,300

[ "implementation" ]

null

Imagine that there is a group of three friends: A, B and С. A owes B 20 rubles and B owes C 20 rubles. The total sum of the debts is 40 rubles. You can see that the debts are not organized in a very optimal manner. Let's rearrange them like that: assume that A owes C 20 rubles and B doesn't owe anything to anybody. The debts still mean the same but the total sum of the debts now equals 20 rubles. This task is a generalisation of a described example. Imagine that your group of friends has *n* people and you know the debts between the people. Optimize the given debts without changing their meaning. In other words, finally for each friend the difference between the total money he should give and the total money he should take must be the same. Print the minimum sum of all debts in the optimal rearrangement of the debts. See the notes to the test samples to better understand the problem.

The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=100; 0<=≤<=*m*<=≤<=104). The next *m* lines contain the debts. The *i*-th line contains three integers *a**i*,<=*b**i*,<=*c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*; *a**i*<=≠<=*b**i*; 1<=≤<=*c**i*<=≤<=100), which mean that person *a**i* owes person *b**i* *c**i* rubles. Assume that the people are numbered by integers from 1 to *n*. It is guaranteed that the same pair of people occurs at most once in the input. The input doesn't simultaneously contain pair of people (*x*,<=*y*) and pair of people (*y*,<=*x*).

Print a single integer — the minimum sum of debts in the optimal rearrangement.

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

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

In the first sample, you can assume that person number 1 owes 8 rubles to person number 2, 1 ruble to person number 3 and 1 ruble to person number 4. He doesn't owe anybody else anything. In the end, the total debt equals 10. In the second sample, there are no debts. In the third sample, you can annul all the debts.

1,000

[ { "input": "5 3\n1 2 10\n2 3 1\n2 4 1", "output": "10" }, { "input": "3 0", "output": "0" }, { "input": "4 3\n1 2 1\n2 3 1\n3 1 1", "output": "0" }, { "input": "20 28\n1 5 6\n1 12 7\n1 13 4\n1 15 7\n1 20 3\n2 4 1\n2 15 6\n3 5 3\n3 8 10\n3 13 8\n3 20 6\n4 6 10\n4 12 8\n4 19 5\n5 17 8\n6 9 9\n6 16 2\n6 19 9\n7 14 6\n8 9 3\n8 16 10\n9 11 7\n9 17 8\n11 13 8\n11 17 17\n11 19 1\n15 20 2\n17 20 1", "output": "124" }, { "input": "20 36\n1 2 13\n1 3 1\n1 6 4\n1 12 8\n1 13 9\n1 15 3\n1 18 4\n2 10 2\n2 15 2\n2 18 6\n3 7 8\n3 16 19\n4 7 1\n4 18 4\n5 9 2\n5 15 9\n5 17 4\n5 18 5\n6 11 7\n6 13 1\n6 14 9\n7 10 4\n7 12 10\n7 15 9\n7 17 8\n8 14 4\n10 13 8\n10 19 9\n11 12 5\n12 17 6\n13 15 8\n13 19 4\n14 15 9\n14 16 8\n17 19 8\n17 20 7", "output": "147" }, { "input": "20 40\n1 13 4\n2 3 3\n2 4 5\n2 7 7\n2 17 10\n3 5 3\n3 6 9\n3 10 4\n3 12 2\n3 13 2\n3 14 3\n4 5 4\n4 8 7\n4 13 9\n5 6 14\n5 14 5\n7 11 5\n7 12 13\n7 15 7\n8 14 5\n8 16 7\n8 18 17\n9 11 8\n9 19 19\n10 12 4\n10 16 3\n10 18 10\n10 20 9\n11 13 9\n11 20 2\n12 13 8\n12 18 2\n12 20 3\n13 17 1\n13 20 4\n14 16 8\n16 19 3\n18 19 3\n18 20 7\n19 20 10", "output": "165" }, { "input": "50 10\n1 5 1\n2 34 2\n3 8 10\n5 28 4\n7 28 6\n13 49 9\n15 42 7\n16 26 7\n18 47 5\n20 41 10", "output": "60" }, { "input": "50 46\n1 6 10\n1 18 1\n1 24 10\n1 33 2\n1 40 8\n3 16 7\n4 26 8\n4 32 2\n4 34 6\n5 29 8\n6 44 3\n8 20 5\n8 42 13\n10 13 5\n10 25 7\n10 27 9\n10 29 10\n11 23 4\n12 28 7\n12 30 10\n12 40 10\n13 18 2\n13 33 2\n14 15 7\n14 43 10\n14 47 3\n16 27 10\n17 21 6\n17 30 9\n19 40 4\n22 24 8\n22 25 7\n22 38 18\n25 38 1\n27 31 7\n27 40 8\n30 36 8\n31 34 1\n32 49 6\n33 35 4\n33 50 7\n38 47 1\n42 47 2\n42 50 5\n43 44 9\n47 50 5", "output": "228" }, { "input": "100 48\n1 56 6\n2 42 3\n3 52 1\n9 50 8\n10 96 8\n11 39 2\n12 51 6\n12 68 7\n13 40 5\n14 18 10\n14 70 6\n15 37 4\n15 38 8\n15 82 6\n15 85 5\n16 48 4\n16 50 9\n16 71 9\n17 18 3\n17 100 10\n20 73 3\n22 32 9\n22 89 9\n23 53 3\n24 53 1\n27 78 10\n30 50 5\n33 94 8\n34 87 9\n35 73 3\n36 51 8\n37 88 10\n37 97 2\n40 47 8\n40 90 6\n44 53 3\n44 65 3\n47 48 8\n48 72 10\n49 98 2\n53 68 10\n53 71 9\n57 62 2\n63 76 10\n66 90 9\n71 76 8\n72 80 5\n75 77 7", "output": "253" }, { "input": "4 3\n1 4 1\n2 3 1\n4 2 2", "output": "2" } ]

1,697,538,298

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

3

46

0

n, m = map(int,input().split()) os=[] for i in range(m): os.append(list(map(int,input().split()))) for i in range(m): for j in range(m): if os[i][0]==os[j][1]: if os[i][2]<=os[j][2]: os[j][2]-=os[i][2] os[i][0]=os[j][0] else: os[i][2]-=os[j][2] os[j][0]=os[i][0] # if os[i][0]==os[i][1]: # os.remove(i) # if os[j][0]==os[j][1]: # os.remove(j) # print('yes',os[i][0],os[j][1]) # print(*os[i]) sum=0 for i in range(m): sum+=os[i][2] print(sum)

Title: I.O.U. Time Limit: None seconds Memory Limit: None megabytes Problem Description: Imagine that there is a group of three friends: A, B and С. A owes B 20 rubles and B owes C 20 rubles. The total sum of the debts is 40 rubles. You can see that the debts are not organized in a very optimal manner. Let's rearrange them like that: assume that A owes C 20 rubles and B doesn't owe anything to anybody. The debts still mean the same but the total sum of the debts now equals 20 rubles. This task is a generalisation of a described example. Imagine that your group of friends has *n* people and you know the debts between the people. Optimize the given debts without changing their meaning. In other words, finally for each friend the difference between the total money he should give and the total money he should take must be the same. Print the minimum sum of all debts in the optimal rearrangement of the debts. See the notes to the test samples to better understand the problem. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=100; 0<=≤<=*m*<=≤<=104). The next *m* lines contain the debts. The *i*-th line contains three integers *a**i*,<=*b**i*,<=*c**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*; *a**i*<=≠<=*b**i*; 1<=≤<=*c**i*<=≤<=100), which mean that person *a**i* owes person *b**i* *c**i* rubles. Assume that the people are numbered by integers from 1 to *n*. It is guaranteed that the same pair of people occurs at most once in the input. The input doesn't simultaneously contain pair of people (*x*,<=*y*) and pair of people (*y*,<=*x*). Output Specification: Print a single integer — the minimum sum of debts in the optimal rearrangement. Demo Input: ['5 3\n1 2 10\n2 3 1\n2 4 1\n', '3 0\n', '4 3\n1 2 1\n2 3 1\n3 1 1\n'] Demo Output: ['10\n', '0\n', '0\n'] Note: In the first sample, you can assume that person number 1 owes 8 rubles to person number 2, 1 ruble to person number 3 and 1 ruble to person number 4. He doesn't owe anybody else anything. In the end, the total debt equals 10. In the second sample, there are no debts. In the third sample, you can annul all the debts.

```python n, m = map(int,input().split()) os=[] for i in range(m): os.append(list(map(int,input().split()))) for i in range(m): for j in range(m): if os[i][0]==os[j][1]: if os[i][2]<=os[j][2]: os[j][2]-=os[i][2] os[i][0]=os[j][0] else: os[i][2]-=os[j][2] os[j][0]=os[i][0] # if os[i][0]==os[i][1]: # os.remove(i) # if os[j][0]==os[j][1]: # os.remove(j) # print('yes',os[i][0],os[j][1]) # print(*os[i]) sum=0 for i in range(m): sum+=os[i][2] print(sum) ```

0

988

A

Diverse Team

PROGRAMMING

800

[ "brute force", "implementation" ]

null

There are $n$ students in a school class, the rating of the $i$-th student on Codehorses is $a_i$. You have to form a team consisting of $k$ students ($1 \le k \le n$) such that the ratings of all team members are distinct. If it is impossible to form a suitable team, print "NO" (without quotes). Otherwise print "YES", and then print $k$ distinct numbers which should be the indices of students in the team you form. If there are multiple answers, print any of them.

The first line contains two integers $n$ and $k$ ($1 \le k \le n \le 100$) — the number of students and the size of the team you have to form. The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the rating of $i$-th student.

If it is impossible to form a suitable team, print "NO" (without quotes). Otherwise print "YES", and then print $k$ distinct integers from $1$ to $n$ which should be the indices of students in the team you form. All the ratings of the students in the team should be distinct. You may print the indices in any order. If there are multiple answers, print any of them. Assume that the students are numbered from $1$ to $n$.

[ "5 3\n15 13 15 15 12\n", "5 4\n15 13 15 15 12\n", "4 4\n20 10 40 30\n" ]

[ "YES\n1 2 5 \n", "NO\n", "YES\n1 2 3 4 \n" ]

All possible answers for the first example: - {1 2 5} - {2 3 5} - {2 4 5} Note that the order does not matter.

0

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

1,639,632,561

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

0

62

0

n,k = map(int,input().split()) arr = list(map(int,input().split())) dupArr = [] for i in arr: if(i not in dupArr): dupArr.append(i) ans = [] if(len(dupArr) != k): print("NO") else: for i in range(k): ans.append(arr.index(dupArr[i])+1) for i in ans: print(i,end=" ")

Title: Diverse Team Time Limit: None seconds Memory Limit: None megabytes Problem Description: There are $n$ students in a school class, the rating of the $i$-th student on Codehorses is $a_i$. You have to form a team consisting of $k$ students ($1 \le k \le n$) such that the ratings of all team members are distinct. If it is impossible to form a suitable team, print "NO" (without quotes). Otherwise print "YES", and then print $k$ distinct numbers which should be the indices of students in the team you form. If there are multiple answers, print any of them. Input Specification: The first line contains two integers $n$ and $k$ ($1 \le k \le n \le 100$) — the number of students and the size of the team you have to form. The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the rating of $i$-th student. Output Specification: If it is impossible to form a suitable team, print "NO" (without quotes). Otherwise print "YES", and then print $k$ distinct integers from $1$ to $n$ which should be the indices of students in the team you form. All the ratings of the students in the team should be distinct. You may print the indices in any order. If there are multiple answers, print any of them. Assume that the students are numbered from $1$ to $n$. Demo Input: ['5 3\n15 13 15 15 12\n', '5 4\n15 13 15 15 12\n', '4 4\n20 10 40 30\n'] Demo Output: ['YES\n1 2 5 \n', 'NO\n', 'YES\n1 2 3 4 \n'] Note: All possible answers for the first example: - {1 2 5} - {2 3 5} - {2 4 5} Note that the order does not matter.

```python n,k = map(int,input().split()) arr = list(map(int,input().split())) dupArr = [] for i in arr: if(i not in dupArr): dupArr.append(i) ans = [] if(len(dupArr) != k): print("NO") else: for i in range(k): ans.append(arr.index(dupArr[i])+1) for i in ans: print(i,end=" ") ```

0

559

B

Equivalent Strings

PROGRAMMING

1,700

[ "divide and conquer", "hashing", "sortings", "strings" ]

null

Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings *a* and *b* of equal length are called equivalent in one of the two cases: 1. They are equal. 1. If we split string *a* into two halves of the same size *a*1 and *a*2, and string *b* into two halves of the same size *b*1 and *b*2, then one of the following is correct: *a*1 is equivalent to *b*1, and *a*2 is equivalent to *b*2 1. *a*1 is equivalent to *b*2, and *a*2 is equivalent to *b*1 As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent. Gerald has already completed this home task. Now it's your turn!

The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200<=000 and consists of lowercase English letters. The strings have the same length.

Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise.

[ "aaba\nabaa\n", "aabb\nabab\n" ]

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

In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a". In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".

1,000

[ { "input": "aaba\nabaa", "output": "YES" }, { "input": "aabb\nabab", "output": "NO" }, { "input": "a\na", "output": "YES" }, { "input": "a\nb", "output": "NO" }, { "input": "ab\nab", "output": "YES" }, { "input": "ab\nba", "output": "YES" }, { "input": "ab\nbb", "output": "NO" }, { "input": "zzaa\naazz", "output": "YES" }, { "input": "azza\nzaaz", "output": "YES" }, { "input": "abc\nabc", "output": "YES" }, { "input": "abc\nacb", "output": "NO" }, { "input": "azzz\nzzaz", "output": "YES" }, { "input": "abcd\ndcab", "output": "YES" }, { "input": "abcd\ncdab", "output": "YES" }, { "input": "abcd\ndcba", "output": "YES" }, { "input": "abcd\nacbd", "output": "NO" }, { "input": "oloaxgddgujq\noloaxgujqddg", "output": "YES" }, { "input": "uwzwdxfmosmqatyv\ndxfmzwwusomqvyta", "output": "YES" }, { "input": "hagnzomowtledfdotnll\nledfdotnllomowthagnz", "output": "YES" }, { "input": "snyaydaeobufdg\nsnyaydaeobufdg", "output": "YES" }, { "input": "baaaaa\nabaaaa", "output": "NO" }, { "input": "hhiisug\nmzdjwju", "output": "NO" }, { "input": "bbbabbabaaab\naaaabbabbbbb", "output": "NO" }, { "input": "bbaaab\naababb", "output": "NO" }, { "input": "aabbaaaa\naaaaabab", "output": "NO" }, { "input": "aab\naba", "output": "NO" }, { "input": "abcddd\nbacddd", "output": "NO" }, { "input": "qgiufelsfhanx\naaaaaaaaaaaaa", "output": "NO" }, { "input": "aabaababaaba\naababaaababa", "output": "NO" }, { "input": "nocdqzdriyyil\naaaaaaaaaaaaa", "output": "NO" }, { "input": "zdmctxl\nkojqhgw", "output": "NO" }, { "input": "yhwepqwyhwepqwyhwepqweahnqtueahnqtueahnqtuyhwepqwyhwepqwyhwepqwyhwepqweahnqtueahnqtuyhwepqweahnqtueahnqtueahnqtueahnqtueahnqtueahnqtu\neahnqtueahnqtueahnqtuyhwepqweahnqtuyhwepqwyhwepqweahnqtuyhwepqweahnqtuyhwepqweahnqtueahnqtuyhwepqweahnqtueahnqtuyhwepqwyhwepqwyhwepqw", "output": "NO" }, { "input": "abc\nbac", "output": "NO" }, { "input": "ottceez\npcstdvz", "output": "NO" } ]

1,692,480,341

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

22

373

921,600

def verificar_equivalente(a: str, b: str) -> bool: if len(a) == 1: if a == b: return True return False if a == b: return True tamanho = len(a) return ((verificar_equivalente(a[:tamanho//2], b[:tamanho//2]) and verificar_equivalente(a[tamanho//2:], b[tamanho//2:])) or (verificar_equivalente(a[:tamanho//2], b[tamanho//2:]) and verificar_equivalente(a[tamanho//2:], b[:tamanho//2]))) a = input() b = input() if verificar_equivalente(a,b): print('YES') else: print('NO')

Title: Equivalent Strings Time Limit: None seconds Memory Limit: None megabytes Problem Description: Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings *a* and *b* of equal length are called equivalent in one of the two cases: 1. They are equal. 1. If we split string *a* into two halves of the same size *a*1 and *a*2, and string *b* into two halves of the same size *b*1 and *b*2, then one of the following is correct: *a*1 is equivalent to *b*1, and *a*2 is equivalent to *b*2 1. *a*1 is equivalent to *b*2, and *a*2 is equivalent to *b*1 As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent. Gerald has already completed this home task. Now it's your turn! Input Specification: The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200<=000 and consists of lowercase English letters. The strings have the same length. Output Specification: Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise. Demo Input: ['aaba\nabaa\n', 'aabb\nabab\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a". In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".

```python def verificar_equivalente(a: str, b: str) -> bool: if len(a) == 1: if a == b: return True return False if a == b: return True tamanho = len(a) return ((verificar_equivalente(a[:tamanho//2], b[:tamanho//2]) and verificar_equivalente(a[tamanho//2:], b[tamanho//2:])) or (verificar_equivalente(a[:tamanho//2], b[tamanho//2:]) and verificar_equivalente(a[tamanho//2:], b[:tamanho//2]))) a = input() b = input() if verificar_equivalente(a,b): print('YES') else: print('NO') ```

0

804

A

Find Amir

PROGRAMMING

1,000

[ "constructive algorithms", "greedy", "math" ]

null

A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends. There are *n* schools numerated from 1 to *n*. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools *i* and *j* costs and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of schools.

Print single integer: the minimum cost of tickets needed to visit all schools.

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

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

In the first example we can buy a ticket between the schools that costs <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c67d72010e0498bfd065a6a38fdeaec90358507b.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

500

[ { "input": "2", "output": "0" }, { "input": "10", "output": "4" }, { "input": "43670", "output": "21834" }, { "input": "4217", "output": "2108" }, { "input": "17879", "output": "8939" }, { "input": "31809", "output": "15904" }, { "input": "40873", "output": "20436" }, { "input": "77859", "output": "38929" }, { "input": "53022", "output": "26510" }, { "input": "79227", "output": "39613" }, { "input": "100000", "output": "49999" }, { "input": "82801", "output": "41400" }, { "input": "5188", "output": "2593" }, { "input": "86539", "output": "43269" }, { "input": "12802", "output": "6400" }, { "input": "20289", "output": "10144" }, { "input": "32866", "output": "16432" }, { "input": "33377", "output": "16688" }, { "input": "31775", "output": "15887" }, { "input": "60397", "output": "30198" }, { "input": "100000", "output": "49999" }, { "input": "99999", "output": "49999" }, { "input": "99998", "output": "49998" }, { "input": "99997", "output": "49998" }, { "input": "99996", "output": "49997" }, { "input": "1", "output": "0" }, { "input": "2", "output": "0" }, { "input": "3", "output": "1" }, { "input": "4", "output": "1" }, { "input": "1", "output": "0" }, { "input": "3", "output": "1" } ]

1,565,066,992

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

109

0

import math n = int(input()) k = math.ceil(n // 2) print((k + n) % (n + 1))

Title: Find Amir Time Limit: None seconds Memory Limit: None megabytes Problem Description: A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends. There are *n* schools numerated from 1 to *n*. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools *i* and *j* costs and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of schools. Output Specification: Print single integer: the minimum cost of tickets needed to visit all schools. Demo Input: ['2\n', '10\n'] Demo Output: ['0\n', '4\n'] Note: In the first example we can buy a ticket between the schools that costs <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c67d72010e0498bfd065a6a38fdeaec90358507b.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

```python import math n = int(input()) k = math.ceil(n // 2) print((k + n) % (n + 1)) ```

0

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,602,130,495

2,147,483,647

Python 3

OK

TESTS

23

218

0

n=int(input()) ans=(n//2)*3 print(ans)

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 n=int(input()) ans=(n//2)*3 print(ans) ```

3.9455

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,670,252,217

2,147,483,647

PyPy 3

OK

TESTS

81

186

0

res=[] n = int(input()) for i in range(n): l = list(map(int,input().split())) res.append(l) sums = [sum(t) for t in zip(*res)] if sums.count(0) == 3: 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 res=[] n = int(input()) for i in range(n): l = list(map(int,input().split())) res.append(l) sums = [sum(t) for t in zip(*res)] if sums.count(0) == 3: print('YES') else: print('NO') ```

3.9535

298

A

Snow Footprints

PROGRAMMING

1,300

[ "greedy", "implementation" ]

null

There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *i*-th block. Similarly, if one moves from the *i*-th block to the (*i*<=-<=1)-th block, he will leave a left footprint on the *i*-th block. If there already is a footprint on the *i*-th block, the new footprint will cover the old one. At the beginning, there were no footprints. Then polar bear Alice starts from the *s*-th block, makes a sequence of moves and ends in the *t*-th block. It is known that Alice never moves outside of the road. You are given the description of Alice's footprints. Your task is to find a pair of possible values of *s*,<=*t* by looking at the footprints.

The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=1000). The second line contains the description of the road — the string that consists of *n* characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint). It's guaranteed that the given string contains at least one character not equal to ".". Also, the first and the last character will always be ".". It's guaranteed that a solution exists.

Print two space-separated integers — the values of *s* and *t*. If there are several possible solutions you can print any of them.

[ "9\n..RRLL...\n", "11\n.RRRLLLLL..\n" ]

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

The first test sample is the one in the picture.

500

[ { "input": "11\n.RRRLLLLL..", "output": "7 5" }, { "input": "4\n.RL.", "output": "3 2" }, { "input": "3\n.L.", "output": "2 1" }, { "input": "3\n.R.", "output": "2 3" } ]

1,609,341,930

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

154

0

a=int(input()) b=list(input()) print((a-b.count('R')),(a.b.count('L')))

Title: Snow Footprints Time Limit: None seconds Memory Limit: None megabytes Problem Description: There is a straight snowy road, divided into *n* blocks. The blocks are numbered from 1 to *n* from left to right. If one moves from the *i*-th block to the (*i*<=+<=1)-th block, he will leave a right footprint on the *i*-th block. Similarly, if one moves from the *i*-th block to the (*i*<=-<=1)-th block, he will leave a left footprint on the *i*-th block. If there already is a footprint on the *i*-th block, the new footprint will cover the old one. At the beginning, there were no footprints. Then polar bear Alice starts from the *s*-th block, makes a sequence of moves and ends in the *t*-th block. It is known that Alice never moves outside of the road. You are given the description of Alice's footprints. Your task is to find a pair of possible values of *s*,<=*t* by looking at the footprints. Input Specification: The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=1000). The second line contains the description of the road — the string that consists of *n* characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint). It's guaranteed that the given string contains at least one character not equal to ".". Also, the first and the last character will always be ".". It's guaranteed that a solution exists. Output Specification: Print two space-separated integers — the values of *s* and *t*. If there are several possible solutions you can print any of them. Demo Input: ['9\n..RRLL...\n', '11\n.RRRLLLLL..\n'] Demo Output: ['3 4\n', '7 5\n'] Note: The first test sample is the one in the picture.

```python a=int(input()) b=list(input()) print((a-b.count('R')),(a.b.count('L'))) ```

-1

219

C

Color Stripe

PROGRAMMING

1,600

[ "brute force", "dp", "greedy" ]

null

A colored stripe is represented by a horizontal row of *n* square cells, each cell is pained one of *k* colors. Your task is to repaint the minimum number of cells so that no two neighbouring cells are of the same color. You can use any color from 1 to *k* to repaint the cells.

The first input line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=5·105; 2<=≤<=*k*<=≤<=26). The second line contains *n* uppercase English letters. Letter "A" stands for the first color, letter "B" stands for the second color and so on. The first *k* English letters may be used. Each letter represents the color of the corresponding cell of the stripe.

Print a single integer — the required minimum number of repaintings. In the second line print any possible variant of the repainted stripe.

[ "6 3\nABBACC\n", "3 2\nBBB\n" ]

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

none

1,500

[ { "input": "6 3\nABBACC", "output": "2\nABCACA" }, { "input": "3 2\nBBB", "output": "1\nBAB" }, { "input": "1 2\nA", "output": "0\nA" }, { "input": "1 26\nZ", "output": "0\nZ" }, { "input": "2 2\nAA", "output": "1\nAB" }, { "input": "2 2\nBA", "output": "0\nBA" }, { "input": "6 2\nAAABBB", "output": "2\nABABAB" }, { "input": "8 3\nAABBABBB", "output": "3\nBACBABCB" }, { "input": "10 26\nAAAAAAAAAA", "output": "5\nBABABABABA" }, { "input": "12 3\nAAABBBAAABBB", "output": "4\nABABCBABABCB" }, { "input": "3 2\nAAB", "output": "1\nBAB" }, { "input": "3 3\nBBA", "output": "1\nABA" }, { "input": "3 3\nCCC", "output": "1\nCAC" }, { "input": "8 3\nAABBCCBB", "output": "4\nBACBACAB" }, { "input": "200 2\nBABAABBABBABBABABBBABAAABABBABABBBAABBBBABBAABBABABAAAAABAABBBAAAAAAABBBABAAAABABBBAABABAABAABBBAABBABAAAABABAAAABABABBBABBBAAABAAABAAABABAAABABABBABABABBABBBABBBBBABABBBABAAABAAABAABBAABBABBBBBABBBAB", "output": "87\nABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB" }, { "input": "20 2\nBBBBAAAAAABBBAAAAAAB", "output": "10\nABABABABABABABABABAB" }, { "input": "20 3\nCCCCAAAAAAAAAAAAAAAA", "output": "10\nACACBABABABABABABABA" }, { "input": "100 2\nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", "output": "49\nABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB" }, { "input": "100 2\nBBBBBBBAAABBAAAABAABBBAABABAAABBBABBAAAABBABAAAAAAAAAAAAABAAABBBAAABAABBBBBBBABBBBAABAAABBBAABBAAAAB", "output": "48\nBABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABA" }, { "input": "100 2\nABAAABABABAAABAAABAAABABABAAABABABAAABABABAAABAAABAAABABABAAABAAABAAABABABAAABAAABAAABABABAAABABABAA", "output": "17\nABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB" }, { "input": "100 2\nABABABABABABABABABABABABABABABABABABABABABBBABABABABABABABABABABABABABABABABABABABABABABABABABABABAB", "output": "1\nABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB" }, { "input": "2 3\nAA", "output": "1\nBA" }, { "input": "12 2\nBBBBABABABAB", "output": "2\nABABABABABAB" }, { "input": "4 2\nAABA", "output": "1\nBABA" }, { "input": "6 2\nBAABAB", "output": "2\nABABAB" }, { "input": "10 2\nAABABABABA", "output": "1\nBABABABABA" }, { "input": "6 2\nBBABAB", "output": "1\nABABAB" }, { "input": "5 2\nBBABA", "output": "1\nABABA" }, { "input": "45 26\nABCDEFGHIJKLMNOOOOOPPPPPQQQQQQPPQZZZZASDASDGF", "output": "10\nABCDEFGHIJKLMNOPOPOPQPQPAQAQAQAPQAZAZASDASDGF" }, { "input": "3 2\nBBA", "output": "1\nABA" }, { "input": "4 2\nABBA", "output": "2\nABAB" }, { "input": "6 2\nAABABA", "output": "1\nBABABA" }, { "input": "6 2\nBAAAAB", "output": "3\nABABAB" }, { "input": "4 2\nAABB", "output": "2\nABAB" }, { "input": "7 2\nAAAABBB", "output": "3\nBABABAB" }, { "input": "41 2\nAABAAABBBBBBAAAABBBAAAAAABBBBBBBBAAAAAAAA", "output": "19\nBABABABABABABABABABABABABABABABABABABABAB" }, { "input": "8 2\nAABABABA", "output": "1\nBABABABA" }, { "input": "20 2\nABBABABBBABBABAAAABA", "output": "8\nBABABABABABABABABABA" }, { "input": "5 2\nABBAB", "output": "2\nBABAB" }, { "input": "10 2\nBBABABABAB", "output": "1\nABABABABAB" }, { "input": "6 2\nABBABB", "output": "3\nABABAB" } ]

1,685,629,404

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

92

0

import sys input = lambda: sys.stdin.readline().rstrip() N,K = map(int, input().split()) chars = [] for i in range(K): chars.append(chr(ord('A')+i)) S = [c for c in input()] for i in range(1,N): if S[i]==S[i-1]: tmp = [S[i]] if i+1<N: tmp.append(S[i+1]) nchar = '' for c in chars: if c not in tmp: nchar=c break S[i]=nchar print(''.join(S))

Title: Color Stripe Time Limit: None seconds Memory Limit: None megabytes Problem Description: A colored stripe is represented by a horizontal row of *n* square cells, each cell is pained one of *k* colors. Your task is to repaint the minimum number of cells so that no two neighbouring cells are of the same color. You can use any color from 1 to *k* to repaint the cells. Input Specification: The first input line contains two integers *n* and *k* (1<=≤<=*n*<=≤<=5·105; 2<=≤<=*k*<=≤<=26). The second line contains *n* uppercase English letters. Letter "A" stands for the first color, letter "B" stands for the second color and so on. The first *k* English letters may be used. Each letter represents the color of the corresponding cell of the stripe. Output Specification: Print a single integer — the required minimum number of repaintings. In the second line print any possible variant of the repainted stripe. Demo Input: ['6 3\nABBACC\n', '3 2\nBBB\n'] Demo Output: ['2\nABCACA\n', '1\nBAB\n'] Note: none

```python import sys input = lambda: sys.stdin.readline().rstrip() N,K = map(int, input().split()) chars = [] for i in range(K): chars.append(chr(ord('A')+i)) S = [c for c in input()] for i in range(1,N): if S[i]==S[i-1]: tmp = [S[i]] if i+1<N: tmp.append(S[i+1]) nchar = '' for c in chars: if c not in tmp: nchar=c break S[i]=nchar print(''.join(S)) ```

0

704

A

Thor

PROGRAMMING

1,600

[ "brute force", "data structures", "implementation" ]

null

Thor is getting used to the Earth. As a gift Loki gave him a smartphone. There are *n* applications on this phone. Thor is fascinated by this phone. He has only one minor issue: he can't count the number of unread notifications generated by those applications (maybe Loki put a curse on it so he can't). *q* events are about to happen (in chronological order). They are of three types: 1. Application *x* generates a notification (this new notification is unread). 1. Thor reads all notifications generated so far by application *x* (he may re-read some notifications). 1. Thor reads the first *t* notifications generated by phone applications (notifications generated in first *t* events of the first type). It's guaranteed that there were at least *t* events of the first type before this event. Please note that he doesn't read first *t* unread notifications, he just reads the very first *t* notifications generated on his phone and he may re-read some of them in this operation. Please help Thor and tell him the number of unread notifications after each event. You may assume that initially there are no notifications in the phone.

The first line of input contains two integers *n* and *q* (1<=≤<=*n*,<=*q*<=≤<=300<=000) — the number of applications and the number of events to happen. The next *q* lines contain the events. The *i*-th of these lines starts with an integer *type**i* — type of the *i*-th event. If *type**i*<==<=1 or *type**i*<==<=2 then it is followed by an integer *x**i*. Otherwise it is followed by an integer *t**i* (1<=≤<=*type**i*<=≤<=3,<=1<=≤<=*x**i*<=≤<=*n*,<=1<=≤<=*t**i*<=≤<=*q*).

Print the number of unread notifications after each event.

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

[ "1\n2\n3\n2\n", "1\n2\n3\n0\n1\n2\n" ]

In the first sample: 1. Application 3 generates a notification (there is 1 unread notification). 1. Application 1 generates a notification (there are 2 unread notifications). 1. Application 2 generates a notification (there are 3 unread notifications). 1. Thor reads the notification generated by application 3, there are 2 unread notifications left. In the second sample test: 1. Application 2 generates a notification (there is 1 unread notification). 1. Application 4 generates a notification (there are 2 unread notifications). 1. Application 2 generates a notification (there are 3 unread notifications). 1. Thor reads first three notifications and since there are only three of them so far, there will be no unread notification left. 1. Application 3 generates a notification (there is 1 unread notification). 1. Application 3 generates a notification (there are 2 unread notifications).

500

[ { "input": "3 4\n1 3\n1 1\n1 2\n2 3", "output": "1\n2\n3\n2" }, { "input": "4 6\n1 2\n1 4\n1 2\n3 3\n1 3\n1 3", "output": "1\n2\n3\n0\n1\n2" }, { "input": "10 85\n2 2\n1 10\n1 1\n2 6\n1 2\n1 4\n1 7\n2 1\n1 1\n3 3\n1 9\n1 6\n1 8\n1 10\n3 8\n2 8\n1 6\n1 3\n1 9\n1 6\n1 3\n1 8\n1 1\n1 6\n1 10\n2 1\n2 10\n1 10\n1 1\n1 10\n1 6\n1 2\n1 8\n1 3\n1 4\n1 9\n1 5\n1 5\n2 2\n2 4\n1 7\n1 1\n2 4\n1 9\n1 1\n1 7\n1 8\n3 33\n1 10\n2 2\n1 3\n1 10\n1 6\n3 32\n2 3\n1 5\n2 10\n2 2\n2 4\n2 3\n3 16\n1 3\n2 2\n1 1\n3 18\n2 2\n2 5\n1 5\n1 9\n2 4\n1 3\n1 4\n1 3\n1 6\n1 10\n2 2\n1 7\n1 7\n2 8\n1 1\n3 1\n1 8\n1 10\n1 7\n1 8", "output": "0\n1\n2\n2\n3\n4\n5\n4\n5\n3\n4\n5\n6\n7\n2\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n9\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n17\n16\n17\n18\n18\n19\n20\n21\n22\n3\n4\n4\n5\n6\n7\n7\n6\n7\n5\n5\n5\n5\n5\n6\n6\n7\n7\n7\n6\n7\n8\n8\n9\n10\n11\n12\n13\n13\n14\n15\n14\n15\n15\n16\n17\n18\n19" }, { "input": "300000 1\n1 300000", "output": "1" } ]

1,580,810,554

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

78

307,200

import numpy as np l=input().split() n=int(l[0]) q=int(l[1]) app_noti=np.arange(4,n*4+4,1,int) app_not=[] ans=[] for i in range(n*4): if(i%4==3): app_not.append([0]) continue app_not.append(app_noti[i]) j=0 for k in range(n): i=j*4 app_not[i+0]/=4 app_not[i+1]=0 app_not[i+2]=0 j+=1 tot_not=0 noti=0 for i in range(q): l=[] l=input().split() n1=int(l[0]) n2=int(l[1]) if(n1==1): app_not[(n2-1)*4+1]+=1 tot_not+=1 noti+=1 app_not[(n2-1)*4+3].append(i+1) if(n1==2): noti=noti-(app_not[(n2-1)*4+1]-app_not[(n2-1)*4+2]) app_not[(n2-1)*4+2]=app_not[(n2-1)*4+1] if(n1==3): n3=n2-(tot_not-noti) if(n3>=0): for i in range(int(tot_not-noti),int(n2+1)): for j in range(n): for k in range(len(app_not[(j*4)+3])): if(app_not[(j*4)+3][k]==i): app_not[(j*4)+2]+=1 noti = noti - n3 ans.append(noti) for i in range(len(ans)): print(ans[i])

Title: Thor Time Limit: None seconds Memory Limit: None megabytes Problem Description: Thor is getting used to the Earth. As a gift Loki gave him a smartphone. There are *n* applications on this phone. Thor is fascinated by this phone. He has only one minor issue: he can't count the number of unread notifications generated by those applications (maybe Loki put a curse on it so he can't). *q* events are about to happen (in chronological order). They are of three types: 1. Application *x* generates a notification (this new notification is unread). 1. Thor reads all notifications generated so far by application *x* (he may re-read some notifications). 1. Thor reads the first *t* notifications generated by phone applications (notifications generated in first *t* events of the first type). It's guaranteed that there were at least *t* events of the first type before this event. Please note that he doesn't read first *t* unread notifications, he just reads the very first *t* notifications generated on his phone and he may re-read some of them in this operation. Please help Thor and tell him the number of unread notifications after each event. You may assume that initially there are no notifications in the phone. Input Specification: The first line of input contains two integers *n* and *q* (1<=≤<=*n*,<=*q*<=≤<=300<=000) — the number of applications and the number of events to happen. The next *q* lines contain the events. The *i*-th of these lines starts with an integer *type**i* — type of the *i*-th event. If *type**i*<==<=1 or *type**i*<==<=2 then it is followed by an integer *x**i*. Otherwise it is followed by an integer *t**i* (1<=≤<=*type**i*<=≤<=3,<=1<=≤<=*x**i*<=≤<=*n*,<=1<=≤<=*t**i*<=≤<=*q*). Output Specification: Print the number of unread notifications after each event. Demo Input: ['3 4\n1 3\n1 1\n1 2\n2 3\n', '4 6\n1 2\n1 4\n1 2\n3 3\n1 3\n1 3\n'] Demo Output: ['1\n2\n3\n2\n', '1\n2\n3\n0\n1\n2\n'] Note: In the first sample: 1. Application 3 generates a notification (there is 1 unread notification). 1. Application 1 generates a notification (there are 2 unread notifications). 1. Application 2 generates a notification (there are 3 unread notifications). 1. Thor reads the notification generated by application 3, there are 2 unread notifications left. In the second sample test: 1. Application 2 generates a notification (there is 1 unread notification). 1. Application 4 generates a notification (there are 2 unread notifications). 1. Application 2 generates a notification (there are 3 unread notifications). 1. Thor reads first three notifications and since there are only three of them so far, there will be no unread notification left. 1. Application 3 generates a notification (there is 1 unread notification). 1. Application 3 generates a notification (there are 2 unread notifications).

```python import numpy as np l=input().split() n=int(l[0]) q=int(l[1]) app_noti=np.arange(4,n*4+4,1,int) app_not=[] ans=[] for i in range(n*4): if(i%4==3): app_not.append([0]) continue app_not.append(app_noti[i]) j=0 for k in range(n): i=j*4 app_not[i+0]/=4 app_not[i+1]=0 app_not[i+2]=0 j+=1 tot_not=0 noti=0 for i in range(q): l=[] l=input().split() n1=int(l[0]) n2=int(l[1]) if(n1==1): app_not[(n2-1)*4+1]+=1 tot_not+=1 noti+=1 app_not[(n2-1)*4+3].append(i+1) if(n1==2): noti=noti-(app_not[(n2-1)*4+1]-app_not[(n2-1)*4+2]) app_not[(n2-1)*4+2]=app_not[(n2-1)*4+1] if(n1==3): n3=n2-(tot_not-noti) if(n3>=0): for i in range(int(tot_not-noti),int(n2+1)): for j in range(n): for k in range(len(app_not[(j*4)+3])): if(app_not[(j*4)+3][k]==i): app_not[(j*4)+2]+=1 noti = noti - n3 ans.append(noti) for i in range(len(ans)): print(ans[i]) ```

-1

385

B

Bear and Strings

PROGRAMMING

1,200

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

null

The bear has a string *s*<==<=*s*1*s*2... *s*|*s*| (record |*s*| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices *i*,<=*j* (1<=≤<=*i*<=≤<=*j*<=≤<=|*s*|), that string *x*(*i*,<=*j*)<==<=*s**i**s**i*<=+<=1... *s**j* contains at least one string "bear" as a substring. String *x*(*i*,<=*j*) contains string "bear", if there is such index *k* (*i*<=≤<=*k*<=≤<=*j*<=-<=3), that *s**k*<==<=*b*, *s**k*<=+<=1<==<=*e*, *s**k*<=+<=2<==<=*a*, *s**k*<=+<=3<==<=*r*. Help the bear cope with the given problem.

The first line contains a non-empty string *s* (1<=≤<=|*s*|<=≤<=5000). It is guaranteed that the string only consists of lowercase English letters.

Print a single number — the answer to the problem.

[ "bearbtear\n", "bearaabearc\n" ]

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

In the first sample, the following pairs (*i*, *j*) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9). In the second sample, the following pairs (*i*, *j*) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).

1,000

[ { "input": "bearbtear", "output": "6" }, { "input": "bearaabearc", "output": "20" }, { "input": "pbearbearhbearzqbearjkterasjhy", "output": "291" }, { "input": "pbearjbearbebearnbabcffbearbearwubearjezpiorrbearbearjbdlbearbearqbearjbearwipmsbearoaftrsebearzsnqb", "output": "4419" }, { "input": "bear", "output": "1" }, { "input": "a", "output": "0" }, { "input": "be", "output": "0" } ]

1,620,211,917

2,147,483,647

PyPy 3

RUNTIME_ERROR

TESTS

0

124

2,150,400

t = int(input()) while t>0: s = input() n = len(s) no = [] for i in range(n-3): if s[i]=='b': if s[i+1]=="e": if s[i+2]=="a": if s[i+3]=="r": no.append([i,i+3]) #print(no) count = 0 for key in range(len(no)): count = count+(no[key][0]+1)+(no[key][0]+1)*(n-no[key][1]-1) if key>0: j=key while j>0: #print("j",j) if no[key][0]>=no[key-1][1]: i = no[key][1] #print("i",i) #print("n",n) while i<n: count-=1 i+=1 j-=1 #print("c",count) print(count) t-=1

Title: Bear and Strings Time Limit: None seconds Memory Limit: None megabytes Problem Description: The bear has a string *s*<==<=*s*1*s*2... *s*|*s*| (record |*s*| is the string's length), consisting of lowercase English letters. The bear wants to count the number of such pairs of indices *i*,<=*j* (1<=≤<=*i*<=≤<=*j*<=≤<=|*s*|), that string *x*(*i*,<=*j*)<==<=*s**i**s**i*<=+<=1... *s**j* contains at least one string "bear" as a substring. String *x*(*i*,<=*j*) contains string "bear", if there is such index *k* (*i*<=≤<=*k*<=≤<=*j*<=-<=3), that *s**k*<==<=*b*, *s**k*<=+<=1<==<=*e*, *s**k*<=+<=2<==<=*a*, *s**k*<=+<=3<==<=*r*. Help the bear cope with the given problem. Input Specification: The first line contains a non-empty string *s* (1<=≤<=|*s*|<=≤<=5000). It is guaranteed that the string only consists of lowercase English letters. Output Specification: Print a single number — the answer to the problem. Demo Input: ['bearbtear\n', 'bearaabearc\n'] Demo Output: ['6\n', '20\n'] Note: In the first sample, the following pairs (*i*, *j*) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9). In the second sample, the following pairs (*i*, *j*) match: (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 10), (2, 11), (3, 10), (3, 11), (4, 10), (4, 11), (5, 10), (5, 11), (6, 10), (6, 11), (7, 10), (7, 11).

```python t = int(input()) while t>0: s = input() n = len(s) no = [] for i in range(n-3): if s[i]=='b': if s[i+1]=="e": if s[i+2]=="a": if s[i+3]=="r": no.append([i,i+3]) #print(no) count = 0 for key in range(len(no)): count = count+(no[key][0]+1)+(no[key][0]+1)*(n-no[key][1]-1) if key>0: j=key while j>0: #print("j",j) if no[key][0]>=no[key-1][1]: i = no[key][1] #print("i",i) #print("n",n) while i<n: count-=1 i+=1 j-=1 #print("c",count) print(count) t-=1 ```

-1

677

A

Vanya and Fence

PROGRAMMING

800

[ "implementation" ]

null

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

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

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

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

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

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

500

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

1,689,699,481

2,147,483,647

PyPy 3-64

OK

TESTS

29

62

0

n, h = list(map(int,input().split())) count = 0 for person in list(map(int,input().split())): count += 1 if person<=h else 2 print(count)

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

```python n, h = list(map(int,input().split())) count = 0 for person in list(map(int,input().split())): count += 1 if person<=h else 2 print(count) ```

3

58

A

Chat room

PROGRAMMING

1,000

[ "greedy", "strings" ]

A. Chat room

1

256

Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*.

The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters.

If Vasya managed to say hello, print "YES", otherwise print "NO".

[ "ahhellllloou\n", "hlelo\n" ]

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

none

500

[ { "input": "ahhellllloou", "output": "YES" }, { "input": "hlelo", "output": "NO" }, { "input": "helhcludoo", "output": "YES" }, { "input": "hehwelloho", "output": "YES" }, { "input": "pnnepelqomhhheollvlo", "output": "YES" }, { "input": "tymbzjyqhymedasloqbq", "output": "NO" }, { "input": "yehluhlkwo", "output": "NO" }, { "input": "hatlevhhalrohairnolsvocafgueelrqmlqlleello", "output": "YES" }, { "input": "hhhtehdbllnhwmbyhvelqqyoulretpbfokflhlhreeflxeftelziclrwllrpflflbdtotvlqgoaoqldlroovbfsq", "output": "YES" }, { "input": "rzlvihhghnelqtwlexmvdjjrliqllolhyewgozkuovaiezgcilelqapuoeglnwmnlftxxiigzczlouooi", "output": "YES" }, { "input": "pfhhwctyqdlkrwhebfqfelhyebwllhemtrmeblgrynmvyhioesqklclocxmlffuormljszllpoo", "output": "YES" }, { "input": "lqllcolohwflhfhlnaow", "output": "NO" }, { "input": "heheeellollvoo", "output": "YES" }, { "input": "hellooo", "output": "YES" }, { "input": "o", "output": "NO" }, { "input": "hhqhzeclohlehljlhtesllylrolmomvuhcxsobtsckogdv", "output": "YES" }, { "input": "yoegfuzhqsihygnhpnukluutocvvwuldiighpogsifealtgkfzqbwtmgghmythcxflebrkctlldlkzlagovwlstsghbouk", "output": "YES" }, { "input": "uatqtgbvrnywfacwursctpagasnhydvmlinrcnqrry", "output": "NO" }, { "input": "tndtbldbllnrwmbyhvqaqqyoudrstpbfokfoclnraefuxtftmgzicorwisrpfnfpbdtatvwqgyalqtdtrjqvbfsq", "output": "NO" }, { "input": "rzlvirhgemelnzdawzpaoqtxmqucnahvqnwldklrmjiiyageraijfivigvozgwngiulttxxgzczptusoi", "output": "YES" }, { "input": "kgyelmchocojsnaqdsyeqgnllytbqietpdlgknwwumqkxrexgdcnwoldicwzwofpmuesjuxzrasscvyuqwspm", "output": "YES" }, { "input": "pnyvrcotjvgynbeldnxieghfltmexttuxzyac", "output": "NO" }, { "input": "dtwhbqoumejligbenxvzhjlhosqojetcqsynlzyhfaevbdpekgbtjrbhlltbceobcok", "output": "YES" }, { "input": "crrfpfftjwhhikwzeedrlwzblckkteseofjuxjrktcjfsylmlsvogvrcxbxtffujqshslemnixoeezivksouefeqlhhokwbqjz", "output": "YES" }, { "input": "jhfbndhyzdvhbvhmhmefqllujdflwdpjbehedlsqfdsqlyelwjtyloxwsvasrbqosblzbowlqjmyeilcvotdlaouxhdpoeloaovb", "output": "YES" }, { "input": "hwlghueoemiqtjhhpashjsouyegdlvoyzeunlroypoprnhlyiwiuxrghekaylndhrhllllwhbebezoglydcvykllotrlaqtvmlla", "output": "YES" }, { "input": "wshiaunnqnqxodholbipwhhjmyeblhgpeleblklpzwhdunmpqkbuzloetmwwxmeltkrcomulxauzlwmlklldjodozxryghsnwgcz", "output": "YES" }, { "input": "shvksednttggehroewuiptvvxtrzgidravtnjwuqrlnnkxbplctzkckinpkgjopjfoxdbojtcvsuvablcbkrzajrlhgobkcxeqti", "output": "YES" }, { "input": "hyyhddqhxhekehkwfhlnlsihzefwchzerevcjtokefplholrbvxlltdlafjxrfhleglrvlolojoqaolagtbeyogxlbgfolllslli", "output": "YES" }, { "input": "iaagrdhhelxpdegueiulflquvlzidoprzkehthkldaytrjwhyhprwjxlltinxvuilxohqgjqcvkkdcuoliekcnlilwgqlnlzouoo", "output": "YES" }, { "input": "wfluaeseldgxyvxpwuhkptdmlflnlhktwxiabsvkolsquymrmhzczzoybvlilhmvsuunggvgxzgyyffk", "output": "NO" }, { "input": "loee", "output": "NO" }, { "input": "izdipwylefqmjbuoznfglgcfvedeouflkeehxbasaqmiooppfsqlhprospqgxvzrcpwlfdddngoqvpwvggsnvvxhmjoslwjudjlo", "output": "NO" }, { "input": "pplynflbjlseflaegzqpdxswgunhnlglqhycrbcwdfhclmcrwekkzsoosmfblljeenwfjyifcvxihhhbyhmhlkvtskeglaovjnsi", "output": "YES" }, { "input": "xqjqmenkodmlhzyzmmvofdngktygbbxbzpluzcohohmalkoeuwfikblltaaigv", "output": "NO" }, { "input": "hello", "output": "YES" }, { "input": "oohell", "output": "NO" }, { "input": "hell", "output": "NO" }, { "input": "eloellohoelo", "output": "NO" }, { "input": "helllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllo", "output": "YES" } ]

1,660,765,474

2,147,483,647

Python 3

OK

TESTS

40

46

0

# 58/A w = input() s = list('hello') for c in w: if s[0] == c: s.pop(0) if len(s) == 0: break print('YES' if len(s) == 0 else 'NO')

Title: Chat room Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*. Input Specification: The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters. Output Specification: If Vasya managed to say hello, print "YES", otherwise print "NO". Demo Input: ['ahhellllloou\n', 'hlelo\n'] Demo Output: ['YES\n', 'NO\n'] Note: none

```python # 58/A w = input() s = list('hello') for c in w: if s[0] == c: s.pop(0) if len(s) == 0: break print('YES' if len(s) == 0 else 'NO') ```

3.977

239

A

Two Bags of Potatoes

PROGRAMMING

1,200

[ "greedy", "implementation", "math" ]

null

Valera had two bags of potatoes, the first of these bags contains *x* (*x*<=≥<=1) potatoes, and the second — *y* (*y*<=≥<=1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains *x* potatoes) Valera lost. Valera remembers that the total amount of potatoes (*x*<=+<=*y*) in the two bags, firstly, was not gerater than *n*, and, secondly, was divisible by *k*. Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order.

The first line of input contains three integers *y*, *k*, *n* (1<=≤<=*y*,<=*k*,<=*n*<=≤<=109; <=≤<=105).

Print the list of whitespace-separated integers — all possible values of *x* in ascending order. You should print each possible value of *x* exactly once. If there are no such values of *x* print a single integer -1.

[ "10 1 10\n", "10 6 40\n" ]

[ "-1\n", "2 8 14 20 26 \n" ]

none

500

[ { "input": "10 1 10", "output": "-1" }, { "input": "10 6 40", "output": "2 8 14 20 26 " }, { "input": "10 1 20", "output": "1 2 3 4 5 6 7 8 9 10 " }, { "input": "1 10000 1000000000", "output": "9999 19999 29999 39999 49999 59999 69999 79999 89999 99999 109999 119999 129999 139999 149999 159999 169999 179999 189999 199999 209999 219999 229999 239999 249999 259999 269999 279999 289999 299999 309999 319999 329999 339999 349999 359999 369999 379999 389999 399999 409999 419999 429999 439999 449999 459999 469999 479999 489999 499999 509999 519999 529999 539999 549999 559999 569999 579999 589999 599999 609999 619999 629999 639999 649999 659999 669999 679999 689999 699999 709999 719999 729999 739999 7499..." }, { "input": "84817 1 33457", "output": "-1" }, { "input": "21 37 99", "output": "16 53 " }, { "input": "78 7 15", "output": "-1" }, { "input": "74 17 27", "output": "-1" }, { "input": "79 23 43", "output": "-1" }, { "input": "32 33 3", "output": "-1" }, { "input": "55 49 44", "output": "-1" }, { "input": "64 59 404", "output": "54 113 172 231 290 " }, { "input": "61 69 820", "output": "8 77 146 215 284 353 422 491 560 629 698 " }, { "input": "17 28 532", "output": "11 39 67 95 123 151 179 207 235 263 291 319 347 375 403 431 459 487 515 " }, { "input": "46592 52 232", "output": "-1" }, { "input": "1541 58 648", "output": "-1" }, { "input": "15946 76 360", "output": "-1" }, { "input": "30351 86 424", "output": "-1" }, { "input": "1 2 37493", "output": "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 193 195 197 199 201 203 205 207 209 211 213 215 217 219 221 223 225 227 229 231 233 235 237 239 241 243 245 247 249 251 253 255 257 259 261 263 265 267 269 271 273 275 277 279 281 28..." }, { "input": "1 3 27764", "output": "2 5 8 11 14 17 20 23 26 29 32 35 38 41 44 47 50 53 56 59 62 65 68 71 74 77 80 83 86 89 92 95 98 101 104 107 110 113 116 119 122 125 128 131 134 137 140 143 146 149 152 155 158 161 164 167 170 173 176 179 182 185 188 191 194 197 200 203 206 209 212 215 218 221 224 227 230 233 236 239 242 245 248 251 254 257 260 263 266 269 272 275 278 281 284 287 290 293 296 299 302 305 308 311 314 317 320 323 326 329 332 335 338 341 344 347 350 353 356 359 362 365 368 371 374 377 380 383 386 389 392 395 398 401 404 407 410..." }, { "input": "10 4 9174", "output": "2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62 66 70 74 78 82 86 90 94 98 102 106 110 114 118 122 126 130 134 138 142 146 150 154 158 162 166 170 174 178 182 186 190 194 198 202 206 210 214 218 222 226 230 234 238 242 246 250 254 258 262 266 270 274 278 282 286 290 294 298 302 306 310 314 318 322 326 330 334 338 342 346 350 354 358 362 366 370 374 378 382 386 390 394 398 402 406 410 414 418 422 426 430 434 438 442 446 450 454 458 462 466 470 474 478 482 486 490 494 498 502 506 510 514 518 522 526 530 534 53..." }, { "input": "33 7 4971", "output": "2 9 16 23 30 37 44 51 58 65 72 79 86 93 100 107 114 121 128 135 142 149 156 163 170 177 184 191 198 205 212 219 226 233 240 247 254 261 268 275 282 289 296 303 310 317 324 331 338 345 352 359 366 373 380 387 394 401 408 415 422 429 436 443 450 457 464 471 478 485 492 499 506 513 520 527 534 541 548 555 562 569 576 583 590 597 604 611 618 625 632 639 646 653 660 667 674 681 688 695 702 709 716 723 730 737 744 751 758 765 772 779 786 793 800 807 814 821 828 835 842 849 856 863 870 877 884 891 898 905 912 919..." }, { "input": "981 1 3387", "output": "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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "386 1 2747", "output": "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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "123 2 50000", "output": "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 193 195 197 199 201 203 205 207 209 211 213 215 217 219 221 223 225 227 229 231 233 235 237 239 241 243 245 247 249 251 253 255 257 259 261 263 265 267 269 271 273 275 277 279 281 28..." }, { "input": "3123 100 10000000", "output": "77 177 277 377 477 577 677 777 877 977 1077 1177 1277 1377 1477 1577 1677 1777 1877 1977 2077 2177 2277 2377 2477 2577 2677 2777 2877 2977 3077 3177 3277 3377 3477 3577 3677 3777 3877 3977 4077 4177 4277 4377 4477 4577 4677 4777 4877 4977 5077 5177 5277 5377 5477 5577 5677 5777 5877 5977 6077 6177 6277 6377 6477 6577 6677 6777 6877 6977 7077 7177 7277 7377 7477 7577 7677 7777 7877 7977 8077 8177 8277 8377 8477 8577 8677 8777 8877 8977 9077 9177 9277 9377 9477 9577 9677 9777 9877 9977 10077 10177 10277 1037..." }, { "input": "2 10000 1000000000", "output": "9998 19998 29998 39998 49998 59998 69998 79998 89998 99998 109998 119998 129998 139998 149998 159998 169998 179998 189998 199998 209998 219998 229998 239998 249998 259998 269998 279998 289998 299998 309998 319998 329998 339998 349998 359998 369998 379998 389998 399998 409998 419998 429998 439998 449998 459998 469998 479998 489998 499998 509998 519998 529998 539998 549998 559998 569998 579998 589998 599998 609998 619998 629998 639998 649998 659998 669998 679998 689998 699998 709998 719998 729998 739998 7499..." }, { "input": "3 10000 1000000000", "output": "9997 19997 29997 39997 49997 59997 69997 79997 89997 99997 109997 119997 129997 139997 149997 159997 169997 179997 189997 199997 209997 219997 229997 239997 249997 259997 269997 279997 289997 299997 309997 319997 329997 339997 349997 359997 369997 379997 389997 399997 409997 419997 429997 439997 449997 459997 469997 479997 489997 499997 509997 519997 529997 539997 549997 559997 569997 579997 589997 599997 609997 619997 629997 639997 649997 659997 669997 679997 689997 699997 709997 719997 729997 739997 7499..." }, { "input": "12312223 10000 1000000000", "output": "7777 17777 27777 37777 47777 57777 67777 77777 87777 97777 107777 117777 127777 137777 147777 157777 167777 177777 187777 197777 207777 217777 227777 237777 247777 257777 267777 277777 287777 297777 307777 317777 327777 337777 347777 357777 367777 377777 387777 397777 407777 417777 427777 437777 447777 457777 467777 477777 487777 497777 507777 517777 527777 537777 547777 557777 567777 577777 587777 597777 607777 617777 627777 637777 647777 657777 667777 677777 687777 697777 707777 717777 727777 737777 7477..." }, { "input": "500000000 1000000000 1000000000", "output": "500000000 " }, { "input": "1 1000000000 1000000000", "output": "999999999 " }, { "input": "10 6 11", "output": "-1" }, { "input": "2 100 10", "output": "-1" }, { "input": "1 100000007 1000000000", "output": "100000006 200000013 300000020 400000027 500000034 600000041 700000048 800000055 900000062 " }, { "input": "1 999999999 1000000000", "output": "999999998 " }, { "input": "100000000 1000000000 1000000000", "output": "900000000 " }, { "input": "11 2 12", "output": "1 " }, { "input": "31 10 39", "output": "-1" }, { "input": "48 6 50", "output": "-1" }, { "input": "500000000 500000000 1000000000", "output": "500000000 " }, { "input": "1 1000000000 999999999", "output": "-1" }, { "input": "4 2 10", "output": "2 4 6 " }, { "input": "1000000000 1 1", "output": "-1" }, { "input": "1000000000 1 100000", "output": "-1" }, { "input": "1000000000 1 10", "output": "-1" }, { "input": "10 5 14", "output": "-1" }, { "input": "500000000 499999999 1000000000", "output": "499999998 " }, { "input": "1 999999997 1000000000", "output": "999999996 " } ]

1,589,892,451

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

3

1,000

0

y,k,n=map(int,input().split()) a=0 for i in range(1,n-y+1): if (i+y)%k==0: print(i,end=' ') a=1 if a==0:print(-1)

Title: Two Bags of Potatoes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Valera had two bags of potatoes, the first of these bags contains *x* (*x*<=≥<=1) potatoes, and the second — *y* (*y*<=≥<=1) potatoes. Valera — very scattered boy, so the first bag of potatoes (it contains *x* potatoes) Valera lost. Valera remembers that the total amount of potatoes (*x*<=+<=*y*) in the two bags, firstly, was not gerater than *n*, and, secondly, was divisible by *k*. Help Valera to determine how many potatoes could be in the first bag. Print all such possible numbers in ascending order. Input Specification: The first line of input contains three integers *y*, *k*, *n* (1<=≤<=*y*,<=*k*,<=*n*<=≤<=109; <=≤<=105). Output Specification: Print the list of whitespace-separated integers — all possible values of *x* in ascending order. You should print each possible value of *x* exactly once. If there are no such values of *x* print a single integer -1. Demo Input: ['10 1 10\n', '10 6 40\n'] Demo Output: ['-1\n', '2 8 14 20 26 \n'] Note: none

```python y,k,n=map(int,input().split()) a=0 for i in range(1,n-y+1): if (i+y)%k==0: print(i,end=' ') a=1 if a==0:print(-1) ```

0

445

A

DZY Loves Chessboard

PROGRAMMING

1,200

[ "dfs and similar", "implementation" ]

null

DZY loves chessboard, and he enjoys playing with it. He has a chessboard of *n* rows and *m* columns. Some cells of the chessboard are bad, others are good. For every good cell, DZY wants to put a chessman on it. Each chessman is either white or black. After putting all chessmen, DZY wants that no two chessmen with the same color are on two adjacent cells. Two cells are adjacent if and only if they share a common edge. You task is to find any suitable placement of chessmen on the given chessboard.

The first line contains two space-separated integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100). Each of the next *n* lines contains a string of *m* characters: the *j*-th character of the *i*-th string is either "." or "-". A "." means that the corresponding cell (in the *i*-th row and the *j*-th column) is good, while a "-" means it is bad.

Output must contain *n* lines, each line must contain a string of *m* characters. The *j*-th character of the *i*-th string should be either "W", "B" or "-". Character "W" means the chessman on the cell is white, "B" means it is black, "-" means the cell is a bad cell. If multiple answers exist, print any of them. It is guaranteed that at least one answer exists.

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

[ "B\n", "BW\nWB\n", "B-B\n---\n--B" ]

In the first sample, DZY puts a single black chessman. Of course putting a white one is also OK. In the second sample, all 4 cells are good. No two same chessmen share an edge in the sample output. In the third sample, no good cells are adjacent. So you can just put 3 chessmen, no matter what their colors are.

500

[ { "input": "1 1\n.", "output": "B" }, { "input": "2 2\n..\n..", "output": "BW\nWB" }, { "input": "3 3\n.-.\n---\n--.", "output": "B-B\n---\n--B" }, { "input": "3 1\n-\n.\n.", "output": "-\nW\nB" }, { "input": "11 11\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------", "output": "-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------\n-----------" }, { "input": "1 1\n-", "output": "-" }, { "input": "4 2\n..\n..\n..\n..", "output": "BW\nWB\nBW\nWB" }, { "input": "5 1\n.\n.\n.\n.\n.", "output": "B\nW\nB\nW\nB" } ]

1,677,277,337

2,147,483,647

Python 3

OK

TESTS

37

46

0

a=[int(x) for x in input().split()] n=a[0] m=a[1] for i in range(n): o=[] b=input() if i%2==0: for j in range(len(b)): if j%2==1: o.append("B") else: o.append("W") for p in range(len(b)): if p!=len(b)-1: if b[p]=='.': print(o[p],end="") else: print("-",end='') else: if b[p]=='.': print(o[p]) else: print("-") else: for j in range(len(b)): if j%2==1: o.append("W") else: o.append("B") for p in range(len(b)): if p!=len(b)-1: if b[p]=='.': print(o[p],end="") else: print("-",end='') else: if b[p]=='.': print(o[p]) else: print("-")

Title: DZY Loves Chessboard Time Limit: None seconds Memory Limit: None megabytes Problem Description: DZY loves chessboard, and he enjoys playing with it. He has a chessboard of *n* rows and *m* columns. Some cells of the chessboard are bad, others are good. For every good cell, DZY wants to put a chessman on it. Each chessman is either white or black. After putting all chessmen, DZY wants that no two chessmen with the same color are on two adjacent cells. Two cells are adjacent if and only if they share a common edge. You task is to find any suitable placement of chessmen on the given chessboard. Input Specification: The first line contains two space-separated integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100). Each of the next *n* lines contains a string of *m* characters: the *j*-th character of the *i*-th string is either "." or "-". A "." means that the corresponding cell (in the *i*-th row and the *j*-th column) is good, while a "-" means it is bad. Output Specification: Output must contain *n* lines, each line must contain a string of *m* characters. The *j*-th character of the *i*-th string should be either "W", "B" or "-". Character "W" means the chessman on the cell is white, "B" means it is black, "-" means the cell is a bad cell. If multiple answers exist, print any of them. It is guaranteed that at least one answer exists. Demo Input: ['1 1\n.\n', '2 2\n..\n..\n', '3 3\n.-.\n---\n--.'] Demo Output: ['B\n', 'BW\nWB\n', 'B-B\n---\n--B'] Note: In the first sample, DZY puts a single black chessman. Of course putting a white one is also OK. In the second sample, all 4 cells are good. No two same chessmen share an edge in the sample output. In the third sample, no good cells are adjacent. So you can just put 3 chessmen, no matter what their colors are.

```python a=[int(x) for x in input().split()] n=a[0] m=a[1] for i in range(n): o=[] b=input() if i%2==0: for j in range(len(b)): if j%2==1: o.append("B") else: o.append("W") for p in range(len(b)): if p!=len(b)-1: if b[p]=='.': print(o[p],end="") else: print("-",end='') else: if b[p]=='.': print(o[p]) else: print("-") else: for j in range(len(b)): if j%2==1: o.append("W") else: o.append("B") for p in range(len(b)): if p!=len(b)-1: if b[p]=='.': print(o[p],end="") else: print("-",end='') else: if b[p]=='.': print(o[p]) else: print("-") ```

3

621

A

Wet Shark and Odd and Even

PROGRAMMING

900

[ "implementation" ]

null

Today, Wet Shark is given *n* integers. Using any of these integers no more than once, Wet Shark wants to get maximum possible even (divisible by 2) sum. Please, calculate this value for Wet Shark. Note, that if Wet Shark uses no integers from the *n* integers, the sum is an even integer 0.

The first line of the input contains one integer, *n* (1<=≤<=*n*<=≤<=100<=000). The next line contains *n* space separated integers given to Wet Shark. Each of these integers is in range from 1 to 109, inclusive.

Print the maximum possible even sum that can be obtained if we use some of the given integers.

[ "3\n1 2 3\n", "5\n999999999 999999999 999999999 999999999 999999999\n" ]

[ "6", "3999999996" ]

In the first sample, we can simply take all three integers for a total sum of 6. In the second sample Wet Shark should take any four out of five integers 999 999 999.

500

[ { "input": "3\n1 2 3", "output": "6" }, { "input": "5\n999999999 999999999 999999999 999999999 999999999", "output": "3999999996" }, { "input": "1\n1", "output": "0" }, { "input": "15\n39 52 88 78 46 95 84 98 55 3 68 42 6 18 98", "output": "870" }, { "input": "15\n59 96 34 48 8 72 67 90 15 85 7 90 97 47 25", "output": "840" }, { "input": "15\n87 37 91 29 58 45 51 74 70 71 47 38 91 89 44", "output": "922" }, { "input": "15\n11 81 49 7 11 14 30 67 29 50 90 81 77 18 59", "output": "674" }, { "input": "15\n39 21 95 89 73 90 9 55 85 32 30 21 68 59 82", "output": "848" }, { "input": "15\n59 70 48 54 26 67 84 39 40 18 77 69 70 88 93", "output": "902" }, { "input": "15\n87 22 98 32 88 36 72 31 100 97 17 16 60 22 20", "output": "798" }, { "input": "15\n15 63 51 13 37 9 43 19 55 79 57 60 50 59 31", "output": "632" }, { "input": "1\n4", "output": "4" }, { "input": "2\n1 4", "output": "4" }, { "input": "3\n1 2 4", "output": "6" }, { "input": "2\n9 3", "output": "12" }, { "input": "2\n1000000000 1001", "output": "1000000000" }, { "input": "3\n1 8 4", "output": "12" }, { "input": "3\n7 4 4", "output": "8" }, { "input": "5\n2 3 4 5 3", "output": "14" }, { "input": "2\n4 5", "output": "4" }, { "input": "3\n2 4 5", "output": "6" }, { "input": "3\n2 2 3", "output": "4" }, { "input": "2\n2 3", "output": "2" }, { "input": "4\n2 3 7 7", "output": "16" }, { "input": "2\n999999999 2", "output": "2" }, { "input": "2\n2 5", "output": "2" }, { "input": "3\n5 3 1", "output": "8" }, { "input": "4\n3 2 5 7", "output": "14" } ]

1,658,951,537

2,147,483,647

PyPy 3-64

OK

TESTS

87

93

18,329,600

n = int(input()) numbers = list(map(int, input().split())) # Список четных чисел even = list() # Список нечетных чисел odd = list() for number in numbers: if number % 2 == 0: even.append(number) else: odd.append(number) if len(odd) % 2 == 0: result = sum(numbers) else: min_odd = min(odd) min_odd_index = numbers.index(min_odd) del numbers[min_odd_index] result = sum(numbers) print(result)

Title: Wet Shark and Odd and Even Time Limit: None seconds Memory Limit: None megabytes Problem Description: Today, Wet Shark is given *n* integers. Using any of these integers no more than once, Wet Shark wants to get maximum possible even (divisible by 2) sum. Please, calculate this value for Wet Shark. Note, that if Wet Shark uses no integers from the *n* integers, the sum is an even integer 0. Input Specification: The first line of the input contains one integer, *n* (1<=≤<=*n*<=≤<=100<=000). The next line contains *n* space separated integers given to Wet Shark. Each of these integers is in range from 1 to 109, inclusive. Output Specification: Print the maximum possible even sum that can be obtained if we use some of the given integers. Demo Input: ['3\n1 2 3\n', '5\n999999999 999999999 999999999 999999999 999999999\n'] Demo Output: ['6', '3999999996'] Note: In the first sample, we can simply take all three integers for a total sum of 6. In the second sample Wet Shark should take any four out of five integers 999 999 999.

```python n = int(input()) numbers = list(map(int, input().split())) # Список четных чисел even = list() # Список нечетных чисел odd = list() for number in numbers: if number % 2 == 0: even.append(number) else: odd.append(number) if len(odd) % 2 == 0: result = sum(numbers) else: min_odd = min(odd) min_odd_index = numbers.index(min_odd) del numbers[min_odd_index] result = sum(numbers) print(result) ```

3

0

none

0

[ "none" ]

null

All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland! It is well-known that there are *n* cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other. The tour will contain several episodes. In each of the episodes: - the wizard will disembark at some city *x* from the Helicopter; - he will give a performance and show a movie for free at the city *x*; - he will drive to some neighboring city *y* using a road; - he will give a performance and show a movie for free at the city *y*; - he will drive to some neighboring to *y* city *z*; - he will give a performance and show a movie for free at the city *z*; - he will embark the Helicopter and fly away from the city *z*. It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between *a* and *b* he only can drive once from *a* to *b*, or drive once from *b* to *a*, or do not use this road at all. The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard! Please note that the wizard can visit the same city multiple times, the restriction is on roads only.

The first line contains two integers *n*, *m* (1<=≤<=*n*<=≤<=2·105, 0<=≤<=*m*<=≤<=2·105) — the number of cities and the number of roads in Berland, respectively. The roads description follow, one in each line. Each description is a pair of two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), where *a**i* and *b**i* are the ids of the cities connected by the *i*-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to *n*. It is possible that the road network in Berland is not connected.

In the first line print *w* — the maximum possible number of episodes. The next *w* lines should contain the episodes in format *x*, *y*, *z* — the three integers denoting the ids of the cities in the order of the wizard's visits.

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

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

none

0

[ { "input": "4 5\n1 2\n3 2\n2 4\n3 4\n4 1", "output": "2\n1 4 2\n4 3 2" }, { "input": "5 8\n5 3\n1 2\n4 5\n5 1\n2 5\n4 3\n1 4\n3 2", "output": "4\n1 4 5\n2 3 4\n1 5 3\n5 2 1" }, { "input": "1 0", "output": "0" }, { "input": "2 1\n1 2", "output": "0" }, { "input": "3 2\n1 2\n3 2", "output": "1\n3 2 1" }, { "input": "10 9\n9 4\n8 5\n3 5\n9 7\n10 7\n1 9\n5 2\n6 4\n2 7", "output": "4\n6 4 9\n3 5 8\n5 2 7\n10 7 9" }, { "input": "7 3\n5 3\n2 5\n6 4", "output": "1\n3 5 2" }, { "input": "9 7\n7 1\n5 4\n8 6\n6 4\n7 4\n7 6\n3 9", "output": "3\n7 6 8\n5 4 6\n4 7 1" }, { "input": "5 5\n4 2\n2 1\n5 2\n3 1\n4 5", "output": "2\n2 5 4\n4 2 1" }, { "input": "8 22\n6 1\n3 8\n8 5\n3 7\n1 3\n6 8\n3 5\n6 2\n2 8\n4 1\n1 5\n4 3\n8 1\n7 8\n2 7\n1 2\n2 5\n2 4\n5 4\n6 7\n4 7\n3 6", "output": "11\n1 4 2\n3 4 7\n1 5 3\n4 5 8\n1 2 5\n6 2 8\n2 7 6\n8 7 3\n1 3 6\n1 8 3\n8 6 1" }, { "input": "19 22\n10 8\n1 14\n12 15\n1 16\n3 6\n6 2\n17 6\n2 10\n2 18\n8 2\n13 10\n8 7\n7 11\n9 15\n19 12\n18 14\n13 5\n12 18\n4 14\n2 19\n15 17\n10 18", "output": "11\n2 19 12\n18 12 15\n9 15 17\n3 6 17\n11 7 8\n2 8 10\n5 13 10\n18 10 2\n6 2 18\n4 14 18\n14 1 16" }, { "input": "5 10\n3 5\n5 2\n1 3\n4 1\n2 3\n4 5\n2 1\n4 2\n1 5\n3 4", "output": "5\n1 4 3\n5 4 2\n1 2 3\n1 5 2\n5 3 1" }, { "input": "7 8\n5 2\n4 5\n4 3\n4 1\n5 6\n6 4\n7 3\n5 1", "output": "4\n4 6 5\n1 5 2\n7 3 4\n5 4 1" }, { "input": "5 10\n3 5\n5 1\n3 2\n2 4\n5 4\n4 3\n2 1\n3 1\n5 2\n4 1", "output": "5\n1 4 3\n5 4 2\n1 2 5\n1 3 2\n3 5 1" }, { "input": "9 7\n5 9\n4 2\n6 3\n1 3\n1 7\n1 2\n7 8", "output": "3\n6 3 1\n8 7 1\n4 2 1" }, { "input": "10 6\n9 2\n3 8\n10 8\n5 2\n1 9\n9 3", "output": "3\n5 2 9\n10 8 3\n3 9 1" }, { "input": "9 10\n6 7\n4 3\n3 5\n9 4\n9 1\n5 9\n9 8\n6 2\n4 8\n9 2", "output": "5\n9 5 3\n9 8 4\n3 4 9\n7 6 2\n2 9 1" }, { "input": "59 58\n53 2\n48 47\n59 2\n24 12\n53 55\n54 52\n44 57\n36 51\n10 26\n39 4\n19 22\n58 53\n3 11\n28 31\n16 26\n10 8\n34 25\n55 41\n46 21\n23 13\n9 39\n10 48\n15 37\n55 31\n14 40\n23 50\n25 45\n42 32\n49 8\n1 38\n55 50\n37 41\n38 49\n51 57\n46 52\n3 6\n29 40\n7 57\n11 12\n18 20\n26 52\n48 5\n5 45\n30 20\n35 58\n55 34\n31 18\n28 42\n11 2\n33 51\n32 43\n8 27\n36 17\n7 22\n57 41\n10 56\n9 47\n29 23", "output": "29\n21 46 52\n54 52 26\n16 26 10\n4 39 9\n9 47 48\n6 3 11\n24 12 11\n11 2 59\n35 58 53\n2 53 55\n15 37 41\n17 36 51\n33 51 57\n19 22 7\n7 57 44\n57 41 55\n43 32 42\n42 28 31\n30 20 18\n18 31 55\n14 40 29\n13 23 29\n23 50 55\n55 34 25\n25 45 5\n5 48 10\n56 10 8\n27 8 49\n49 38 1" }, { "input": "73 72\n52 51\n12 47\n19 42\n44 22\n31 51\n61 29\n56 15\n58 42\n8 4\n6 62\n69 66\n3 18\n69 3\n7 47\n15 33\n1 20\n59 58\n58 61\n70 64\n21 14\n6 70\n32 71\n52 32\n23 34\n67 7\n26 13\n33 45\n22 21\n13 63\n53 26\n40 36\n6 27\n53 32\n30 49\n59 53\n49 54\n47 46\n28 69\n18 41\n36 49\n3 42\n16 49\n23 5\n47 54\n23 11\n24 36\n2 12\n44 48\n22 43\n45 68\n2 17\n68 30\n70 39\n37 62\n35 2\n71 35\n4 32\n49 5\n31 70\n17 48\n15 65\n9 57\n20 67\n61 73\n6 57\n10 58\n11 72\n44 50\n25 19\n44 55\n60 56\n38 24", "output": "36\n14 21 22\n43 22 44\n50 44 55\n44 48 17\n37 62 6\n9 57 6\n27 6 70\n39 70 64\n70 31 51\n51 52 32\n63 13 26\n25 19 42\n41 18 3\n28 69 66\n69 3 42\n29 61 73\n10 58 42\n61 58 59\n26 53 59\n8 4 32\n53 32 71\n71 35 2\n17 2 12\n60 56 15\n65 15 33\n33 45 68\n68 30 49\n38 24 36\n40 36 49\n72 11 23\n34 23 5\n5 49 16\n49 54 47\n12 47 46\n47 7 67\n67 20 1" } ]

1,691,931,121

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

30

0

print("_RANDOM_GUESS_1691931120.987873")# 1691931120.9878886

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland! It is well-known that there are *n* cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other. The tour will contain several episodes. In each of the episodes: - the wizard will disembark at some city *x* from the Helicopter; - he will give a performance and show a movie for free at the city *x*; - he will drive to some neighboring city *y* using a road; - he will give a performance and show a movie for free at the city *y*; - he will drive to some neighboring to *y* city *z*; - he will give a performance and show a movie for free at the city *z*; - he will embark the Helicopter and fly away from the city *z*. It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between *a* and *b* he only can drive once from *a* to *b*, or drive once from *b* to *a*, or do not use this road at all. The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard! Please note that the wizard can visit the same city multiple times, the restriction is on roads only. Input Specification: The first line contains two integers *n*, *m* (1<=≤<=*n*<=≤<=2·105, 0<=≤<=*m*<=≤<=2·105) — the number of cities and the number of roads in Berland, respectively. The roads description follow, one in each line. Each description is a pair of two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), where *a**i* and *b**i* are the ids of the cities connected by the *i*-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to *n*. It is possible that the road network in Berland is not connected. Output Specification: In the first line print *w* — the maximum possible number of episodes. The next *w* lines should contain the episodes in format *x*, *y*, *z* — the three integers denoting the ids of the cities in the order of the wizard's visits. Demo Input: ['4 5\n1 2\n3 2\n2 4\n3 4\n4 1\n', '5 8\n5 3\n1 2\n4 5\n5 1\n2 5\n4 3\n1 4\n3 2\n'] Demo Output: ['2\n1 4 2\n4 3 2\n', '4\n1 4 5\n2 3 4\n1 5 3\n5 2 1\n'] Note: none

```python print("_RANDOM_GUESS_1691931120.987873")# 1691931120.9878886 ```

0

768

A

Oath of the Night's Watch

PROGRAMMING

900

[ "constructive algorithms", "sortings" ]

null

"Night gathers, and now my watch begins. It shall not end until my death. I shall take no wife, hold no lands, father no children. I shall wear no crowns and win no glory. I shall live and die at my post. I am the sword in the darkness. I am the watcher on the walls. I am the shield that guards the realms of men. I pledge my life and honor to the Night's Watch, for this night and all the nights to come." — The Night's Watch oath. With that begins the watch of Jon Snow. He is assigned the task to support the stewards. This time he has *n* stewards with him whom he has to provide support. Each steward has his own strength. Jon Snow likes to support a steward only if there exists at least one steward who has strength strictly less than him and at least one steward who has strength strictly greater than him. Can you find how many stewards will Jon support?

First line consists of a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of stewards with Jon Snow. Second line consists of *n* space separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=109) representing the values assigned to the stewards.

Output a single integer representing the number of stewards which Jon will feed.

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

[ "0", "1" ]

In the first sample, Jon Snow cannot support steward with strength 1 because there is no steward with strength less than 1 and he cannot support steward with strength 5 because there is no steward with strength greater than 5. In the second sample, Jon Snow can support steward with strength 2 because there are stewards with strength less than 2 and greater than 2.

500

[ { "input": "2\n1 5", "output": "0" }, { "input": "3\n1 2 5", "output": "1" }, { "input": "4\n1 2 3 4", "output": "2" }, { "input": "8\n7 8 9 4 5 6 1 2", "output": "6" }, { "input": "1\n1", "output": "0" }, { "input": "1\n100", "output": "0" }, { "input": "205\n5 5 3 3 6 2 9 3 8 9 6 6 10 8 1 5 3 3 1 2 9 9 9 3 9 10 3 9 8 3 5 6 6 4 6 9 2 9 10 9 5 6 6 7 4 2 6 3 4 1 10 1 7 2 7 7 3 2 6 5 5 2 9 3 8 8 7 6 6 4 2 2 6 2 3 5 7 2 2 10 1 4 6 9 2 3 7 2 2 7 4 4 9 10 7 5 8 6 5 3 6 10 2 7 5 6 6 8 3 3 9 4 3 5 7 9 3 2 1 1 3 2 1 9 3 1 4 4 10 2 5 5 8 1 4 8 5 3 1 10 8 6 5 8 3 5 4 5 4 4 6 7 2 8 10 8 7 6 6 9 6 7 1 10 3 2 5 10 4 4 5 4 3 4 8 5 3 8 10 3 10 9 7 2 1 8 6 4 6 5 8 10 2 6 7 4 9 4 5 1 8 7 10 3 1", "output": "174" }, { "input": "4\n1000000000 99999999 1000000000 1000000000", "output": "0" }, { "input": "3\n2 2 2", "output": "0" }, { "input": "5\n1 1 1 1 1", "output": "0" }, { "input": "3\n1 1 1", "output": "0" }, { "input": "6\n1 1 3 3 2 2", "output": "2" }, { "input": "7\n1 1 1 1 1 1 1", "output": "0" }, { "input": "4\n1 1 2 5", "output": "1" }, { "input": "3\n0 0 0", "output": "0" }, { "input": "5\n0 0 0 0 0", "output": "0" }, { "input": "5\n1 1 1 1 5", "output": "0" }, { "input": "5\n1 1 2 3 3", "output": "1" }, { "input": "3\n1 1 3", "output": "0" }, { "input": "3\n2 2 3", "output": "0" }, { "input": "1\n6", "output": "0" }, { "input": "5\n1 5 3 5 1", "output": "1" }, { "input": "7\n1 2 2 2 2 2 3", "output": "5" }, { "input": "4\n2 2 2 2", "output": "0" }, { "input": "9\n2 2 2 3 4 5 6 6 6", "output": "3" }, { "input": "10\n1 1 1 2 3 3 3 3 3 3", "output": "1" }, { "input": "6\n1 1 1 1 1 1", "output": "0" }, { "input": "3\n0 0 1", "output": "0" }, { "input": "9\n1 1 1 2 2 2 3 3 3", "output": "3" }, { "input": "3\n1 2 2", "output": "0" }, { "input": "6\n2 2 2 2 2 2", "output": "0" }, { "input": "5\n2 2 2 2 2", "output": "0" }, { "input": "5\n5 5 5 5 5", "output": "0" }, { "input": "1\n0", "output": "0" }, { "input": "6\n1 2 5 5 5 5", "output": "1" }, { "input": "5\n1 2 3 3 3", "output": "1" }, { "input": "3\n1 1 2", "output": "0" }, { "input": "6\n1 1 1 1 1 2", "output": "0" }, { "input": "5\n1 1 2 4 4", "output": "1" }, { "input": "3\n999999 5999999 9999999", "output": "1" }, { "input": "4\n1 1 5 5", "output": "0" }, { "input": "9\n1 1 1 2 2 2 4 4 4", "output": "3" }, { "input": "5\n1 3 4 5 1", "output": "2" }, { "input": "5\n3 3 3 3 3", "output": "0" }, { "input": "5\n1 1 2 2 2", "output": "0" }, { "input": "5\n2 1 1 1 3", "output": "1" }, { "input": "5\n0 0 0 1 2", "output": "1" }, { "input": "4\n2 2 2 3", "output": "0" }, { "input": "7\n1 1 1 1 5 5 5", "output": "0" }, { "input": "5\n1 2 3 4 4", "output": "2" }, { "input": "2\n5 4", "output": "0" }, { "input": "4\n5 5 5 5", "output": "0" }, { "input": "5\n1 1 1 5 5", "output": "0" }, { "input": "2\n1 1", "output": "0" }, { "input": "1\n3", "output": "0" }, { "input": "3\n2 1 2", "output": "0" }, { "input": "4\n1 2 2 2", "output": "0" }, { "input": "8\n1000000000 1000000000 1000000000 999999999 999999999 999999999 999999998 999999998", "output": "3" }, { "input": "5\n1 1 3 4 4", "output": "1" }, { "input": "6\n1 1 2 2 3 3", "output": "2" }, { "input": "4\n1 1 1 1", "output": "0" }, { "input": "9\n1 2 3 4 1 5 6 7 8", "output": "6" }, { "input": "8\n5 4 4 6 6 4 4 3", "output": "5" }, { "input": "8\n4 3 3 3 3 3 3 3", "output": "0" }, { "input": "7\n4 3 3 3 3 3 3", "output": "0" }, { "input": "6\n4 3 3 3 3 3", "output": "0" }, { "input": "5\n4 3 3 3 3", "output": "0" } ]

1,658,947,448

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

2

2,000

7,987,200

n = int(input()) lst = list(map(int, input().split())) counter = 0 for i in range(n): if lst[i] != max(lst) and lst[i] != min(lst): counter += 1 print(counter)

Title: Oath of the Night's Watch Time Limit: None seconds Memory Limit: None megabytes Problem Description: "Night gathers, and now my watch begins. It shall not end until my death. I shall take no wife, hold no lands, father no children. I shall wear no crowns and win no glory. I shall live and die at my post. I am the sword in the darkness. I am the watcher on the walls. I am the shield that guards the realms of men. I pledge my life and honor to the Night's Watch, for this night and all the nights to come." — The Night's Watch oath. With that begins the watch of Jon Snow. He is assigned the task to support the stewards. This time he has *n* stewards with him whom he has to provide support. Each steward has his own strength. Jon Snow likes to support a steward only if there exists at least one steward who has strength strictly less than him and at least one steward who has strength strictly greater than him. Can you find how many stewards will Jon support? Input Specification: First line consists of a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of stewards with Jon Snow. Second line consists of *n* space separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=109) representing the values assigned to the stewards. Output Specification: Output a single integer representing the number of stewards which Jon will feed. Demo Input: ['2\n1 5\n', '3\n1 2 5\n'] Demo Output: ['0', '1'] Note: In the first sample, Jon Snow cannot support steward with strength 1 because there is no steward with strength less than 1 and he cannot support steward with strength 5 because there is no steward with strength greater than 5. In the second sample, Jon Snow can support steward with strength 2 because there are stewards with strength less than 2 and greater than 2.

```python n = int(input()) lst = list(map(int, input().split())) counter = 0 for i in range(n): if lst[i] != max(lst) and lst[i] != min(lst): counter += 1 print(counter) ```

0

588

A

Duff and Meat

PROGRAMMING

900

[ "greedy" ]

null

Duff is addicted to meat! Malek wants to keep her happy for *n* days. In order to be happy in *i*-th day, she needs to eat exactly *a**i* kilograms of meat. There is a big shop uptown and Malek wants to buy meat for her from there. In *i*-th day, they sell meat for *p**i* dollars per kilogram. Malek knows all numbers *a*1,<=...,<=*a**n* and *p*1,<=...,<=*p**n*. In each day, he can buy arbitrary amount of meat, also he can keep some meat he has for the future. Malek is a little tired from cooking meat, so he asked for your help. Help him to minimize the total money he spends to keep Duff happy for *n* days.

The first line of input contains integer *n* (1<=≤<=*n*<=≤<=105), the number of days. In the next *n* lines, *i*-th line contains two integers *a**i* and *p**i* (1<=≤<=*a**i*,<=*p**i*<=≤<=100), the amount of meat Duff needs and the cost of meat in that day.

Print the minimum money needed to keep Duff happy for *n* days, in one line.

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

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

In the first sample case: An optimal way would be to buy 1 kg on the first day, 2 kg on the second day and 3 kg on the third day. In the second sample case: An optimal way would be to buy 1 kg on the first day and 5 kg (needed meat for the second and third day) on the second day.

750

[ { "input": "3\n1 3\n2 2\n3 1", "output": "10" }, { "input": "3\n1 3\n2 1\n3 2", "output": "8" }, { "input": "1\n39 52", "output": "2028" }, { "input": "2\n25 56\n94 17", "output": "2998" }, { "input": "5\n39 21\n95 89\n73 90\n9 55\n85 32", "output": "6321" }, { "input": "12\n70 11\n74 27\n32 11\n26 83\n57 18\n97 28\n75 43\n75 21\n84 29\n16 2\n89 63\n21 88", "output": "6742" }, { "input": "2\n100 68\n38 80", "output": "9384" } ]

1,618,789,821

2,147,483,647

Python 3

OK

TESTS

30

358

16,281,600

DAYS = [] N = -1 MAX_PRICE = 100 def entrypoint(): global DAYS, N N = int(input()) get_input = lambda : list(map(int, input().split())) def process_input(): amount, price = get_input() DAYS.append({ 'amount': amount, 'price': price }) [process_input() for _ in range(N)] def process(): curr_minimal = MAX_PRICE + 1 for i in range(N): curr_minimal = min(curr_minimal, DAYS[i]['price']) DAYS[i]['price'] = curr_minimal compute_price_day = lambda x : x['amount'] * x['price'] min_money = sum(list(map(compute_price_day, DAYS))) return min_money def main(): entrypoint() print(process()) if __name__ == '__main__': main()

Title: Duff and Meat Time Limit: None seconds Memory Limit: None megabytes Problem Description: Duff is addicted to meat! Malek wants to keep her happy for *n* days. In order to be happy in *i*-th day, she needs to eat exactly *a**i* kilograms of meat. There is a big shop uptown and Malek wants to buy meat for her from there. In *i*-th day, they sell meat for *p**i* dollars per kilogram. Malek knows all numbers *a*1,<=...,<=*a**n* and *p*1,<=...,<=*p**n*. In each day, he can buy arbitrary amount of meat, also he can keep some meat he has for the future. Malek is a little tired from cooking meat, so he asked for your help. Help him to minimize the total money he spends to keep Duff happy for *n* days. Input Specification: The first line of input contains integer *n* (1<=≤<=*n*<=≤<=105), the number of days. In the next *n* lines, *i*-th line contains two integers *a**i* and *p**i* (1<=≤<=*a**i*,<=*p**i*<=≤<=100), the amount of meat Duff needs and the cost of meat in that day. Output Specification: Print the minimum money needed to keep Duff happy for *n* days, in one line. Demo Input: ['3\n1 3\n2 2\n3 1\n', '3\n1 3\n2 1\n3 2\n'] Demo Output: ['10\n', '8\n'] Note: In the first sample case: An optimal way would be to buy 1 kg on the first day, 2 kg on the second day and 3 kg on the third day. In the second sample case: An optimal way would be to buy 1 kg on the first day and 5 kg (needed meat for the second and third day) on the second day.

```python DAYS = [] N = -1 MAX_PRICE = 100 def entrypoint(): global DAYS, N N = int(input()) get_input = lambda : list(map(int, input().split())) def process_input(): amount, price = get_input() DAYS.append({ 'amount': amount, 'price': price }) [process_input() for _ in range(N)] def process(): curr_minimal = MAX_PRICE + 1 for i in range(N): curr_minimal = min(curr_minimal, DAYS[i]['price']) DAYS[i]['price'] = curr_minimal compute_price_day = lambda x : x['amount'] * x['price'] min_money = sum(list(map(compute_price_day, DAYS))) return min_money def main(): entrypoint() print(process()) if __name__ == '__main__': main() ```

3

579

A

Raising Bacteria

PROGRAMMING

1,000

[ "bitmasks" ]

null

You are a lover of bacteria. You want to raise some bacteria in a box. Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly *x* bacteria in the box at some moment. What is the minimum number of bacteria you need to put into the box across those days?

The only line containing one integer *x* (1<=≤<=*x*<=≤<=109).

The only line containing one integer: the answer.

[ "5\n", "8\n" ]

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

For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2. For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. So the answer is 1.

250

[ { "input": "5", "output": "2" }, { "input": "8", "output": "1" }, { "input": "536870911", "output": "29" }, { "input": "1", "output": "1" }, { "input": "343000816", "output": "14" }, { "input": "559980448", "output": "12" }, { "input": "697681824", "output": "14" }, { "input": "41313494", "output": "14" }, { "input": "673935585", "output": "13" }, { "input": "117422204", "output": "19" }, { "input": "954746654", "output": "15" }, { "input": "536838144", "output": "14" }, { "input": "1000000000", "output": "13" }, { "input": "2", "output": "1" }, { "input": "3", "output": "2" }, { "input": "4", "output": "1" }, { "input": "6", "output": "2" }, { "input": "7", "output": "3" }, { "input": "9", "output": "2" }, { "input": "10", "output": "2" }, { "input": "999999999", "output": "21" }, { "input": "999999998", "output": "20" }, { "input": "999999997", "output": "20" }, { "input": "999999996", "output": "19" }, { "input": "999999995", "output": "20" }, { "input": "999999994", "output": "19" }, { "input": "999999993", "output": "19" }, { "input": "999999992", "output": "18" }, { "input": "999999991", "output": "20" }, { "input": "999999990", "output": "19" }, { "input": "536870910", "output": "28" }, { "input": "536870912", "output": "1" }, { "input": "536870913", "output": "2" }, { "input": "536870914", "output": "2" }, { "input": "22", "output": "3" }, { "input": "14", "output": "3" } ]

1,690,920,316

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

31

0

num = int(input()) count = 1 while count < num : count *= 2 if count > num : count //= 2 print(1 + num - count)

Title: Raising Bacteria Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are a lover of bacteria. You want to raise some bacteria in a box. Initially, the box is empty. Each morning, you can put any number of bacteria into the box. And each night, every bacterium in the box will split into two bacteria. You hope to see exactly *x* bacteria in the box at some moment. What is the minimum number of bacteria you need to put into the box across those days? Input Specification: The only line containing one integer *x* (1<=≤<=*x*<=≤<=109). Output Specification: The only line containing one integer: the answer. Demo Input: ['5\n', '8\n'] Demo Output: ['2\n', '1\n'] Note: For the first sample, we can add one bacterium in the box in the first day morning and at the third morning there will be 4 bacteria in the box. Now we put one more resulting 5 in the box. We added 2 bacteria in the process so the answer is 2. For the second sample, we can put one in the first morning and in the 4-th morning there will be 8 in the box. So the answer is 1.

```python num = int(input()) count = 1 while count < num : count *= 2 if count > num : count //= 2 print(1 + num - count) ```

0

3

C

Tic-tac-toe

PROGRAMMING

1,800

[ "brute force", "games", "implementation" ]

C. Tic-tac-toe

1

64

Certainly, everyone is familiar with tic-tac-toe game. The rules are very simple indeed. Two players take turns marking the cells in a 3<=×<=3 grid (one player always draws crosses, the other — noughts). The player who succeeds first in placing three of his marks in a horizontal, vertical or diagonal line wins, and the game is finished. The player who draws crosses goes first. If the grid is filled, but neither Xs, nor 0s form the required line, a draw is announced. You are given a 3<=×<=3 grid, each grid cell is empty, or occupied by a cross or a nought. You have to find the player (first or second), whose turn is next, or print one of the verdicts below: - illegal — if the given board layout can't appear during a valid game; - the first player won — if in the given board layout the first player has just won; - the second player won — if in the given board layout the second player has just won; - draw — if the given board layout has just let to a draw.

The input consists of three lines, each of the lines contains characters ".", "X" or "0" (a period, a capital letter X, or a digit zero).

Print one of the six verdicts: first, second, illegal, the first player won, the second player won or draw.

[ "X0X\n.0.\n.X.\n" ]

[ "second\n" ]

none

0

[ { "input": "X0X\n.0.\n.X.", "output": "second" }, { "input": "0.X\nXX.\n000", "output": "illegal" }, { "input": "XXX\n.0.\n000", "output": "illegal" }, { "input": "XXX\n...\n000", "output": "illegal" }, { "input": "X.X\nX..\n00.", "output": "second" }, { "input": "X.X\nX.0\n0.0", "output": "first" }, { "input": "XXX\nX00\nX00", "output": "the first player won" }, { "input": "000\nX.X\nX.X", "output": "illegal" }, { "input": "XXX\n0.0\n0..", "output": "illegal" }, { "input": "X0X\n0X0\nX0X", "output": "the first player won" }, { "input": "XX.\nX0X\nX..", "output": "illegal" }, { "input": "X0X\n0X0\nX..", "output": "the first player won" }, { "input": "XX0\n0..\n000", "output": "illegal" }, { "input": "XXX\n0..\n.0.", "output": "the first player won" }, { "input": "XXX\nX..\n.00", "output": "illegal" }, { "input": "X00\n0.0\nXX0", "output": "illegal" }, { "input": "0.0\n0XX\n..0", "output": "illegal" }, { "input": ".00\nX.X\n0..", "output": "illegal" }, { "input": "..0\n.00\n.0X", "output": "illegal" }, { "input": "..0\n0..\n00X", "output": "illegal" }, { "input": "..0\n.XX\nX..", "output": "illegal" }, { "input": "0.X\n0X0\n.00", "output": "illegal" }, { "input": "..X\n0X0\n0X.", "output": "first" }, { "input": "0X0\nX..\nX.0", "output": "first" }, { "input": ".0.\nX.X\n0..", "output": "first" }, { "input": "0X0\n00X\n.00", "output": "illegal" }, { "input": ".0.\n.X0\nX..", "output": "first" }, { "input": "00X\n0.X\n00X", "output": "illegal" }, { "input": "00X\n0XX\n0X.", "output": "the second player won" }, { "input": "X00\n..0\nX.X", "output": "first" }, { "input": "X00\nX00\n.X0", "output": "illegal" }, { "input": "X0X\n.X0\n0..", "output": "first" }, { "input": "..0\nXXX\n000", "output": "illegal" }, { "input": "XXX\n...\n.0.", "output": "illegal" }, { "input": "0..\n000\nX0X", "output": "illegal" }, { "input": ".00\n0X.\n0.0", "output": "illegal" }, { "input": "X..\nX00\n0.0", "output": "illegal" }, { "input": ".X0\nXX0\nX.X", "output": "illegal" }, { "input": "X.X\n0.0\nX..", "output": "second" }, { "input": "00X\n.00\n..0", "output": "illegal" }, { "input": "..0\n0.X\n00.", "output": "illegal" }, { "input": "0.X\nX0X\n.X0", "output": "illegal" }, { "input": "0X.\n.X.\n0X0", "output": "illegal" }, { "input": "00.\nX0.\n..X", "output": "illegal" }, { "input": "..X\n.00\nXX.", "output": "second" }, { "input": ".00\n.0.\n.X.", "output": "illegal" }, { "input": "XX0\nX.0\nXX0", "output": "illegal" }, { "input": "00.\n00.\nX.X", "output": "illegal" }, { "input": "X00\nX.0\nX.0", "output": "illegal" }, { "input": "0X.\n0XX\n000", "output": "illegal" }, { "input": "00.\n00.\n.X.", "output": "illegal" }, { "input": "X0X\n00.\n0.X", "output": "illegal" }, { "input": "XX0\nXXX\n0X0", "output": "illegal" }, { "input": "XX0\n..X\nXX0", "output": "illegal" }, { "input": "0X.\n..X\nX..", "output": "illegal" }, { "input": "...\nX0.\nXX0", "output": "second" }, { "input": "..X\n.0.\n0..", "output": "illegal" }, { "input": "00X\nXX.\n00X", "output": "first" }, { "input": "..0\nXX0\n..X", "output": "second" }, { "input": ".0.\n.00\nX00", "output": "illegal" }, { "input": "X00\n.XX\n00.", "output": "illegal" }, { "input": ".00\n0.X\n000", "output": "illegal" }, { "input": "X0.\n..0\nX.0", "output": "illegal" }, { "input": "X0X\n.XX\n00.", "output": "second" }, { "input": "0X.\n00.\n.X.", "output": "illegal" }, { "input": ".0.\n...\n0.0", "output": "illegal" }, { "input": "..X\nX00\n0.0", "output": "illegal" }, { "input": "0XX\n...\nX0.", "output": "second" }, { "input": "X.X\n0X.\n.0X", "output": "illegal" }, { "input": "XX0\nX.X\n00.", "output": "second" }, { "input": ".0X\n.00\n00.", "output": "illegal" }, { "input": ".XX\nXXX\n0..", "output": "illegal" }, { "input": "XX0\n.X0\n.0.", "output": "first" }, { "input": "X00\n0.X\nX..", "output": "first" }, { "input": "X..\n.X0\nX0.", "output": "second" }, { "input": ".0X\nX..\nXXX", "output": "illegal" }, { "input": "X0X\nXXX\nX.X", "output": "illegal" }, { "input": ".00\nX0.\n00X", "output": "illegal" }, { "input": "0XX\n.X0\n0.0", "output": "illegal" }, { "input": "00X\nXXX\n..0", "output": "the first player won" }, { "input": "X0X\n...\n.X.", "output": "illegal" }, { "input": ".X0\n...\n0X.", "output": "first" }, { "input": "X..\n0X0\nX.0", "output": "first" }, { "input": "..0\n.00\nX.0", "output": "illegal" }, { "input": ".XX\n.0.\nX0X", "output": "illegal" }, { "input": "00.\n0XX\n..0", "output": "illegal" }, { "input": ".0.\n00.\n00.", "output": "illegal" }, { "input": "00.\n000\nX.X", "output": "illegal" }, { "input": "0X0\n.X0\n.X.", "output": "illegal" }, { "input": "00X\n0..\n0..", "output": "illegal" }, { "input": ".X.\n.X0\nX.0", "output": "second" }, { "input": ".0.\n0X0\nX0X", "output": "illegal" }, { "input": "...\nX.0\n0..", "output": "illegal" }, { "input": "..0\nXX.\n00X", "output": "first" }, { "input": "0.X\n.0X\nX00", "output": "illegal" }, { "input": "..X\n0X.\n.0.", "output": "first" }, { "input": "..X\nX.0\n.0X", "output": "second" }, { "input": "X0.\n.0X\nX0X", "output": "illegal" }, { "input": "...\n.0.\n.X0", "output": "illegal" }, { "input": ".X0\nXX0\n0..", "output": "first" }, { "input": "0X.\n...\nX..", "output": "second" }, { "input": ".0.\n0.0\n0.X", "output": "illegal" }, { "input": "XX.\n.X0\n.0X", "output": "illegal" }, { "input": ".0.\nX0X\nX00", "output": "illegal" }, { "input": "0X.\n.X0\nX..", "output": "second" }, { "input": "..0\n0X.\n000", "output": "illegal" }, { "input": "0.0\nX.X\nXX.", "output": "illegal" }, { "input": ".X.\n.XX\nX0.", "output": "illegal" }, { "input": "X.X\n.XX\n0X.", "output": "illegal" }, { "input": "X.0\n0XX\n..0", "output": "first" }, { "input": "X.0\n0XX\n.X0", "output": "second" }, { "input": "X00\n0XX\n.X0", "output": "first" }, { "input": "X00\n0XX\nXX0", "output": "draw" }, { "input": "X00\n0XX\n0X0", "output": "illegal" }, { "input": "XXX\nXXX\nXXX", "output": "illegal" }, { "input": "000\n000\n000", "output": "illegal" }, { "input": "XX0\n00X\nXX0", "output": "draw" }, { "input": "X00\n00X\nXX0", "output": "illegal" }, { "input": "X.0\n00.\nXXX", "output": "the first player won" }, { "input": "X..\nX0.\nX0.", "output": "the first player won" }, { "input": ".XX\n000\nXX0", "output": "the second player won" }, { "input": "X0.\nX.X\nX00", "output": "the first player won" }, { "input": "00X\nX00\nXXX", "output": "the first player won" }, { "input": "XXX\n.00\nX0.", "output": "the first player won" }, { "input": "XX0\n000\nXX.", "output": "the second player won" }, { "input": ".X0\n0.0\nXXX", "output": "the first player won" }, { "input": "0XX\nX00\n0XX", "output": "draw" }, { "input": "0XX\nX0X\n00X", "output": "the first player won" }, { "input": "XX0\n0XX\n0X0", "output": "the first player won" }, { "input": "0X0\nX0X\nX0X", "output": "draw" }, { "input": "X0X\n0XX\n00X", "output": "the first player won" }, { "input": "0XX\nX0.\nX00", "output": "the second player won" }, { "input": "X.0\n0X0\nXX0", "output": "the second player won" }, { "input": "X0X\nX0X\n0X0", "output": "draw" }, { "input": "X.0\n00X\n0XX", "output": "the second player won" }, { "input": "00X\nX0X\n.X0", "output": "the second player won" }, { "input": "X0X\n.00\nX0X", "output": "the second player won" }, { "input": "0XX\nX00\nX0X", "output": "draw" }, { "input": "000\nX0X\n.XX", "output": "the second player won" }, { "input": "0.0\n0.X\nXXX", "output": "the first player won" }, { "input": "X.0\nX0.\n0X.", "output": "the second player won" }, { "input": "X0X\n0X0\n..X", "output": "the first player won" }, { "input": "0X0\nXX0\n.X.", "output": "the first player won" }, { "input": "X0.\n.X.\n0.X", "output": "the first player won" }, { "input": "0XX\nX00\n.X0", "output": "the second player won" }, { "input": "0.0\nXXX\n0.X", "output": "the first player won" }, { "input": ".0X\n.X.\nX.0", "output": "the first player won" }, { "input": "XXX\nX.0\n0.0", "output": "the first player won" }, { "input": "XX0\nX..\nX00", "output": "the first player won" }, { "input": "XXX\n00X\n00X", "output": "the first player won" }, { "input": "X00\n00X\nXXX", "output": "the first player won" }, { "input": "0X0\nX0X\n0X.", "output": "the second player won" }, { "input": "XX0\nX00\n0X.", "output": "the second player won" }, { "input": "..X\n0X0\nX..", "output": "the first player won" }, { "input": "X0.\n00.\nXXX", "output": "the first player won" }, { "input": "0.X\nX00\nXX0", "output": "the second player won" }, { "input": "X0.\n0X.\n..X", "output": "the first player won" }, { "input": "00X\nX0.\nXX0", "output": "the second player won" }, { "input": "XX.\n000\n0XX", "output": "the second player won" }, { "input": "..X\n0.X\n.0X", "output": "the first player won" }, { "input": "X00\n.0X\n0XX", "output": "the second player won" }, { "input": "00X\n0X.\nXX.", "output": "the first player won" }, { "input": "X00\nXX.\n0.X", "output": "the first player won" }, { "input": "XXX\n00X\n0X0", "output": "the first player won" }, { "input": "X00\nXX0\n0XX", "output": "the first player won" }, { "input": "0X0\nX00\nXXX", "output": "the first player won" }, { "input": "XX0\nX00\n.X0", "output": "the second player won" } ]

1,536,964,352

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

7

248

0

# cross go first # illigal: # 1 x win, but n_o >= n_x # draw: # n_o + n_x = 9, no winner def win(board, mark): win = True for i in range(3): win = True for j in range(3): if board[i][j] != mark: win = False if win: return True for i in range(3): win = True for j in range(3): if board[j][i] != mark: win = False if win: return True if board[0][0] == board[1][1] == board[2][2] == mark: return True elif board[2][0] == board[1][1] == board[0][2] == mark: return True def double_win(board, mark = 'X'): #print(board) win = True count = 0 for i in range(3): win = True for j in range(3): if board[i][j] != mark: win = False if win: count += 1 for i in range(3): win = True for j in range(3): if board[j][i] != mark: win = False if win: count += 1 if board[0][0] == board[1][1] == board[2][2] == mark: count += 1 elif board[2][0] == board[1][1] == board[0][2] == mark: count += 1 if count > 1: return True board = [] for i in range(3): board.append(input()) n_x = 0 n_o = 0 for i in board: for j in i: if j == 'X': n_x += 1 if j == '0': n_o += 1 if n_o > n_x: print('illegal') elif n_x - n_o > 1: print('illegal') elif win(board, 'X') and win(board, '0'): print('illegal') elif win(board, 'X') and n_o >= n_x: print('illegal') elif double_win(board): print('illegal') elif win(board, 'X') and n_o <= n_x: print("the first player won") elif win(board, '0') and n_o <= n_x: print("the second player won") elif n_o + n_x == 9: print('draw') elif n_o == n_x: print('first') elif n_o == n_x - 1: print('second')

Title: Tic-tac-toe Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: Certainly, everyone is familiar with tic-tac-toe game. The rules are very simple indeed. Two players take turns marking the cells in a 3<=×<=3 grid (one player always draws crosses, the other — noughts). The player who succeeds first in placing three of his marks in a horizontal, vertical or diagonal line wins, and the game is finished. The player who draws crosses goes first. If the grid is filled, but neither Xs, nor 0s form the required line, a draw is announced. You are given a 3<=×<=3 grid, each grid cell is empty, or occupied by a cross or a nought. You have to find the player (first or second), whose turn is next, or print one of the verdicts below: - illegal — if the given board layout can't appear during a valid game; - the first player won — if in the given board layout the first player has just won; - the second player won — if in the given board layout the second player has just won; - draw — if the given board layout has just let to a draw. Input Specification: The input consists of three lines, each of the lines contains characters ".", "X" or "0" (a period, a capital letter X, or a digit zero). Output Specification: Print one of the six verdicts: first, second, illegal, the first player won, the second player won or draw. Demo Input: ['X0X\n.0.\n.X.\n'] Demo Output: ['second\n'] Note: none

```python # cross go first # illigal: # 1 x win, but n_o >= n_x # draw: # n_o + n_x = 9, no winner def win(board, mark): win = True for i in range(3): win = True for j in range(3): if board[i][j] != mark: win = False if win: return True for i in range(3): win = True for j in range(3): if board[j][i] != mark: win = False if win: return True if board[0][0] == board[1][1] == board[2][2] == mark: return True elif board[2][0] == board[1][1] == board[0][2] == mark: return True def double_win(board, mark = 'X'): #print(board) win = True count = 0 for i in range(3): win = True for j in range(3): if board[i][j] != mark: win = False if win: count += 1 for i in range(3): win = True for j in range(3): if board[j][i] != mark: win = False if win: count += 1 if board[0][0] == board[1][1] == board[2][2] == mark: count += 1 elif board[2][0] == board[1][1] == board[0][2] == mark: count += 1 if count > 1: return True board = [] for i in range(3): board.append(input()) n_x = 0 n_o = 0 for i in board: for j in i: if j == 'X': n_x += 1 if j == '0': n_o += 1 if n_o > n_x: print('illegal') elif n_x - n_o > 1: print('illegal') elif win(board, 'X') and win(board, '0'): print('illegal') elif win(board, 'X') and n_o >= n_x: print('illegal') elif double_win(board): print('illegal') elif win(board, 'X') and n_o <= n_x: print("the first player won") elif win(board, '0') and n_o <= n_x: print("the second player won") elif n_o + n_x == 9: print('draw') elif n_o == n_x: print('first') elif n_o == n_x - 1: print('second') ```

0

979

A

Pizza, Pizza, Pizza!!!

PROGRAMMING

1,000

[ "math" ]

null

Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems. Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro. She has ordered a very big round pizza, in order to serve her many friends. Exactly $n$ of Shiro's friends are here. That's why she has to divide the pizza into $n + 1$ slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over. Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator. As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?

A single line contains one non-negative integer $n$ ($0 \le n \leq 10^{18}$) — the number of Shiro's friends. The circular pizza has to be sliced into $n + 1$ pieces.

A single integer — the number of straight cuts Shiro needs.

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

[ "2", "5" ]

To cut the round pizza into quarters one has to make two cuts through the center with angle $90^{\circ}$ between them. To cut the round pizza into five equal parts one has to make five cuts.

500

[ { "input": "3", "output": "2" }, { "input": "4", "output": "5" }, { "input": "10", "output": "11" }, { "input": "10000000000", "output": "10000000001" }, { "input": "1234567891", "output": "617283946" }, { "input": "7509213957", "output": "3754606979" }, { "input": "99999999999999999", "output": "50000000000000000" }, { "input": "21", "output": "11" }, { "input": "712394453192", "output": "712394453193" }, { "input": "172212168", "output": "172212169" }, { "input": "822981260158260519", "output": "411490630079130260" }, { "input": "28316250877914571", "output": "14158125438957286" }, { "input": "779547116602436424", "output": "779547116602436425" }, { "input": "578223540024979436", "output": "578223540024979437" }, { "input": "335408917861648766", "output": "335408917861648767" }, { "input": "74859962623690078", "output": "74859962623690079" }, { "input": "252509054433933439", "output": "126254527216966720" }, { "input": "760713016476190622", "output": "760713016476190623" }, { "input": "919845426262703496", "output": "919845426262703497" }, { "input": "585335723211047194", "output": "585335723211047195" }, { "input": "522842184971407769", "output": "261421092485703885" }, { "input": "148049062628894320", "output": "148049062628894321" }, { "input": "84324828731963974", "output": "84324828731963975" }, { "input": "354979173822804781", "output": "177489586911402391" }, { "input": "1312150450968413", "output": "656075225484207" }, { "input": "269587449430302150", "output": "269587449430302151" }, { "input": "645762258982631926", "output": "645762258982631927" }, { "input": "615812229161735895", "output": "307906114580867948" }, { "input": "0", "output": "0" }, { "input": "349993004923078531", "output": "174996502461539266" }, { "input": "891351282707723851", "output": "445675641353861926" }, { "input": "563324731189330734", "output": "563324731189330735" }, { "input": "520974001910286909", "output": "260487000955143455" }, { "input": "666729339802329204", "output": "666729339802329205" }, { "input": "856674611404539671", "output": "428337305702269836" }, { "input": "791809296303238499", "output": "395904648151619250" }, { "input": "711066337317063338", "output": "711066337317063339" }, { "input": "931356503492686566", "output": "931356503492686567" }, { "input": "234122432773361866", "output": "234122432773361867" }, { "input": "1000000000000000000", "output": "1000000000000000001" }, { "input": "1", "output": "1" }, { "input": "2", "output": "3" }, { "input": "7", "output": "4" }, { "input": "63", "output": "32" }, { "input": "24", "output": "25" }, { "input": "8", "output": "9" }, { "input": "15", "output": "8" } ]

1,591,530,834

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

28

109

0

# -*- coding: utf-8 -*- """ Created on Sun Jun 7 17:20:59 2020 @author: user """ def solve(n): if(n%2==0): print(n//2) else: print(n) n=int(input()) solve(n+1)

Title: Pizza, Pizza, Pizza!!! Time Limit: None seconds Memory Limit: None megabytes Problem Description: Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems. Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro. She has ordered a very big round pizza, in order to serve her many friends. Exactly $n$ of Shiro's friends are here. That's why she has to divide the pizza into $n + 1$ slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over. Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator. As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem? Input Specification: A single line contains one non-negative integer $n$ ($0 \le n \leq 10^{18}$) — the number of Shiro's friends. The circular pizza has to be sliced into $n + 1$ pieces. Output Specification: A single integer — the number of straight cuts Shiro needs. Demo Input: ['3\n', '4\n'] Demo Output: ['2', '5'] Note: To cut the round pizza into quarters one has to make two cuts through the center with angle $90^{\circ}$ between them. To cut the round pizza into five equal parts one has to make five cuts.

```python # -*- coding: utf-8 -*- """ Created on Sun Jun 7 17:20:59 2020 @author: user """ def solve(n): if(n%2==0): print(n//2) else: print(n) n=int(input()) solve(n+1) ```

0

999

C

Alphabetic Removals

PROGRAMMING

1,200

[ "implementation" ]

null

You are given a string $s$ consisting of $n$ lowercase Latin letters. Polycarp wants to remove exactly $k$ characters ($k \le n$) from the string $s$. Polycarp uses the following algorithm $k$ times: - if there is at least one letter 'a', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; - if there is at least one letter 'b', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; - ... - remove the leftmost occurrence of the letter 'z' and stop the algorithm. This algorithm removes a single letter from the string. Polycarp performs this algorithm exactly $k$ times, thus removing exactly $k$ characters. Help Polycarp find the resulting string.

The first line of input contains two integers $n$ and $k$ ($1 \le k \le n \le 4 \cdot 10^5$) — the length of the string and the number of letters Polycarp will remove. The second line contains the string $s$ consisting of $n$ lowercase Latin letters.

Print the string that will be obtained from $s$ after Polycarp removes exactly $k$ letters using the above algorithm $k$ times. If the resulting string is empty, print nothing. It is allowed to print nothing or an empty line (line break).

[ "15 3\ncccaabababaccbc\n", "15 9\ncccaabababaccbc\n", "1 1\nu\n" ]

[ "cccbbabaccbc\n", "cccccc\n", "" ]

none

0

[ { "input": "15 3\ncccaabababaccbc", "output": "cccbbabaccbc" }, { "input": "15 9\ncccaabababaccbc", "output": "cccccc" }, { "input": "5 2\nzyzyx", "output": "zzy" }, { "input": "4 3\nhack", "output": "k" }, { "input": "4 3\nzzzz", "output": "z" }, { "input": "6 5\naaccdd", "output": "d" }, { "input": "2 1\nzz", "output": "z" }, { "input": "14 5\nhxehmvkybeklnj", "output": "xmvkyklnj" } ]

1,656,510,334

2,147,483,647

PyPy 3-64

OK

TESTS

44

124

4,915,200

import sys sc = sys.stdin.readline n,x=map(int,sc().rstrip().split()) s=str(sc()) a,o='a',0 while o<=26: if s.count(chr(ord(a)+ o))>=x: s=s.replace(chr(ord(a) + o), '',x) break else: x-=s.count(chr(ord(a) + o)) s= s.replace(chr(ord(a) + o), '') o+=1 sys.stdout.write(str(s))

Title: Alphabetic Removals Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a string $s$ consisting of $n$ lowercase Latin letters. Polycarp wants to remove exactly $k$ characters ($k \le n$) from the string $s$. Polycarp uses the following algorithm $k$ times: - if there is at least one letter 'a', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; - if there is at least one letter 'b', remove the leftmost occurrence and stop the algorithm, otherwise go to next item; - ... - remove the leftmost occurrence of the letter 'z' and stop the algorithm. This algorithm removes a single letter from the string. Polycarp performs this algorithm exactly $k$ times, thus removing exactly $k$ characters. Help Polycarp find the resulting string. Input Specification: The first line of input contains two integers $n$ and $k$ ($1 \le k \le n \le 4 \cdot 10^5$) — the length of the string and the number of letters Polycarp will remove. The second line contains the string $s$ consisting of $n$ lowercase Latin letters. Output Specification: Print the string that will be obtained from $s$ after Polycarp removes exactly $k$ letters using the above algorithm $k$ times. If the resulting string is empty, print nothing. It is allowed to print nothing or an empty line (line break). Demo Input: ['15 3\ncccaabababaccbc\n', '15 9\ncccaabababaccbc\n', '1 1\nu\n'] Demo Output: ['cccbbabaccbc\n', 'cccccc\n', ''] Note: none

```python import sys sc = sys.stdin.readline n,x=map(int,sc().rstrip().split()) s=str(sc()) a,o='a',0 while o<=26: if s.count(chr(ord(a)+ o))>=x: s=s.replace(chr(ord(a) + o), '',x) break else: x-=s.count(chr(ord(a) + o)) s= s.replace(chr(ord(a) + o), '') o+=1 sys.stdout.write(str(s)) ```

3

110

A

Nearly Lucky Number

PROGRAMMING

800

[ "implementation" ]

A. Nearly Lucky Number

2

256

Petya loves lucky numbers. We all know that 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. Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number *n* is a nearly lucky number.

The only line contains an integer *n* (1<=≤<=*n*<=≤<=1018). Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.

Print on the single line "YES" if *n* is a nearly lucky number. Otherwise, print "NO" (without the quotes).

[ "40047\n", "7747774\n", "1000000000000000000\n" ]

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

In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO". In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES". In the third sample there are no lucky digits, so the answer is "NO".

500

[ { "input": "40047", "output": "NO" }, { "input": "7747774", "output": "YES" }, { "input": "1000000000000000000", "output": "NO" }, { "input": "7", "output": "NO" }, { "input": "4", "output": "NO" }, { "input": "474404774", "output": "NO" }, { "input": "4744000695826", "output": "YES" }, { "input": "10000000004744744", "output": "YES" }, { "input": "446486416781684178", "output": "YES" }, { "input": "999999999", "output": "NO" }, { "input": "7777", "output": "YES" }, { "input": "87414417444", "output": "NO" }, { "input": "111222333444555667", "output": "YES" }, { "input": "1", "output": "NO" }, { "input": "4700", "output": "NO" }, { "input": "3794555488744477", "output": "NO" }, { "input": "444444444444444444", "output": "NO" }, { "input": "474447447774444774", "output": "NO" }, { "input": "777777777777777", "output": "NO" }, { "input": "34777745021000000", "output": "NO" }, { "input": "963", "output": "NO" }, { "input": "855474448854788540", "output": "NO" }, { "input": "999999999999994744", "output": "YES" }, { "input": "400000000474", "output": "YES" }, { "input": "123456789123456789", "output": "YES" }, { "input": "740577777584945874", "output": "NO" }, { "input": "7777777", "output": "YES" }, { "input": "4444000111222333", "output": "YES" }, { "input": "9847745885202111", "output": "YES" }, { "input": "123456000000", "output": "NO" }, { "input": "4744447444444", "output": "NO" }, { "input": "7477", "output": "YES" }, { "input": "4747477", "output": "YES" }, { "input": "777777777444444444", "output": "NO" } ]

1,694,554,650

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

30

0

def nearlyLucky(money): count = 0 while money > 0: if money % 10 == 4 or money % 10 == 7: count += 1 money //= 10 return count in ( 4 ,7) if __name__ == "__main__": money = int(input()) print ("yes" if nearlyLucky(money) else "no")

Title: Nearly Lucky Number Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Petya loves lucky numbers. We all know that 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. Unfortunately, not all numbers are lucky. Petya calls a number nearly lucky if the number of lucky digits in it is a lucky number. He wonders whether number *n* is a nearly lucky number. Input Specification: The only line contains an integer *n* (1<=≤<=*n*<=≤<=1018). Please do not use the %lld specificator to read or write 64-bit numbers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. Output Specification: Print on the single line "YES" if *n* is a nearly lucky number. Otherwise, print "NO" (without the quotes). Demo Input: ['40047\n', '7747774\n', '1000000000000000000\n'] Demo Output: ['NO\n', 'YES\n', 'NO\n'] Note: In the first sample there are 3 lucky digits (first one and last two), so the answer is "NO". In the second sample there are 7 lucky digits, 7 is lucky number, so the answer is "YES". In the third sample there are no lucky digits, so the answer is "NO".

```python def nearlyLucky(money): count = 0 while money > 0: if money % 10 == 4 or money % 10 == 7: count += 1 money //= 10 return count in ( 4 ,7) if __name__ == "__main__": money = int(input()) print ("yes" if nearlyLucky(money) else "no") ```

0

492

A

Vanya and Cubes

PROGRAMMING

800

[ "implementation" ]

null

Vanya got *n* cubes. He decided to build a pyramid from them. Vanya wants to build the pyramid as follows: the top level of the pyramid must consist of 1 cube, the second level must consist of 1<=+<=2<==<=3 cubes, the third level must have 1<=+<=2<=+<=3<==<=6 cubes, and so on. Thus, the *i*-th level of the pyramid must have 1<=+<=2<=+<=...<=+<=(*i*<=-<=1)<=+<=*i* cubes. Vanya wants to know what is the maximum height of the pyramid that he can make using the given cubes.

The first line contains integer *n* (1<=≤<=*n*<=≤<=104) — the number of cubes given to Vanya.

Print the maximum possible height of the pyramid in the single line.

[ "1\n", "25\n" ]

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

Illustration to the second sample:

500

[ { "input": "1", "output": "1" }, { "input": "25", "output": "4" }, { "input": "2", "output": "1" }, { "input": "4115", "output": "28" }, { "input": "9894", "output": "38" }, { "input": "7969", "output": "35" }, { "input": "6560", "output": "33" }, { "input": "4", "output": "2" }, { "input": "3", "output": "1" }, { "input": "5", "output": "2" }, { "input": "19", "output": "3" }, { "input": "20", "output": "4" }, { "input": "9880", "output": "38" }, { "input": "9879", "output": "37" }, { "input": "7770", "output": "35" }, { "input": "7769", "output": "34" }, { "input": "2925", "output": "25" }, { "input": "220", "output": "10" }, { "input": "219", "output": "9" }, { "input": "3046", "output": "25" }, { "input": "7590", "output": "34" }, { "input": "1014", "output": "17" }, { "input": "7142", "output": "34" }, { "input": "9999", "output": "38" }, { "input": "10000", "output": "38" } ]

1,696,144,818

2,147,483,647

Python 3

OK

TESTS

25

46

0

n = int(input()) h= 0 c= 0 while c+ (h + 1) * (h+ 2) // 2 <= n: h += 1 c += h * (h + 1) // 2 print(h)

Title: Vanya and Cubes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vanya got *n* cubes. He decided to build a pyramid from them. Vanya wants to build the pyramid as follows: the top level of the pyramid must consist of 1 cube, the second level must consist of 1<=+<=2<==<=3 cubes, the third level must have 1<=+<=2<=+<=3<==<=6 cubes, and so on. Thus, the *i*-th level of the pyramid must have 1<=+<=2<=+<=...<=+<=(*i*<=-<=1)<=+<=*i* cubes. Vanya wants to know what is the maximum height of the pyramid that he can make using the given cubes. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=104) — the number of cubes given to Vanya. Output Specification: Print the maximum possible height of the pyramid in the single line. Demo Input: ['1\n', '25\n'] Demo Output: ['1\n', '4\n'] Note: Illustration to the second sample:

```python n = int(input()) h= 0 c= 0 while c+ (h + 1) * (h+ 2) // 2 <= n: h += 1 c += h * (h + 1) // 2 print(h) ```

3

363

A

Soroban

PROGRAMMING

800

[ "implementation" ]

null

You know that Japan is the country with almost the largest 'electronic devices per person' ratio. So you might be quite surprised to find out that the primary school in Japan teaches to count using a Soroban — an abacus developed in Japan. This phenomenon has its reasons, of course, but we are not going to speak about them. Let's have a look at the Soroban's construction. Soroban consists of some number of rods, each rod contains five beads. We will assume that the rods are horizontal lines. One bead on each rod (the leftmost one) is divided from the others by a bar (the reckoning bar). This single bead is called go-dama and four others are ichi-damas. Each rod is responsible for representing a single digit from 0 to 9. We can obtain the value of a digit by following simple algorithm: - Set the value of a digit equal to 0. - If the go-dama is shifted to the right, add 5. - Add the number of ichi-damas shifted to the left. Thus, the upper rod on the picture shows digit 0, the middle one shows digit 2 and the lower one shows 7. We will consider the top rod to represent the last decimal digit of a number, so the picture shows number 720. Write the program that prints the way Soroban shows the given number *n*.

The first line contains a single integer *n* (0<=≤<=*n*<=<<=109).

Print the description of the decimal digits of number *n* from the last one to the first one (as mentioned on the picture in the statement), one per line. Print the beads as large English letters 'O', rod pieces as character '-' and the reckoning bar as '|'. Print as many rods, as many digits are in the decimal representation of number *n* without leading zeroes. We can assume that number 0 has no leading zeroes.

[ "2\n", "13\n", "720\n" ]

none

500

[ { "input": "2", "output": "O-|OO-OO" }, { "input": "13", "output": "O-|OOO-O\nO-|O-OOO" }, { "input": "720", "output": "O-|-OOOO\nO-|OO-OO\n-O|OO-OO" }, { "input": "0", "output": "O-|-OOOO" }, { "input": "1", "output": "O-|O-OOO" }, { "input": "3", "output": "O-|OOO-O" }, { "input": "4", "output": "O-|OOOO-" }, { "input": "5", "output": "-O|-OOOO" }, { "input": "6", "output": "-O|O-OOO" }, { "input": "637", "output": "-O|OO-OO\nO-|OOO-O\n-O|O-OOO" }, { "input": "7", "output": "-O|OO-OO" }, { "input": "8", "output": "-O|OOO-O" }, { "input": "9", "output": "-O|OOOO-" }, { "input": "10", "output": "O-|-OOOO\nO-|O-OOO" }, { "input": "11", "output": "O-|O-OOO\nO-|O-OOO" }, { "input": "100", "output": "O-|-OOOO\nO-|-OOOO\nO-|O-OOO" }, { "input": "99", "output": "-O|OOOO-\n-O|OOOO-" }, { "input": "245", "output": "-O|-OOOO\nO-|OOOO-\nO-|OO-OO" }, { "input": "118", "output": "-O|OOO-O\nO-|O-OOO\nO-|O-OOO" }, { "input": "429", "output": "-O|OOOO-\nO-|OO-OO\nO-|OOOO-" }, { "input": "555", "output": "-O|-OOOO\n-O|-OOOO\n-O|-OOOO" }, { "input": "660", "output": "O-|-OOOO\n-O|O-OOO\n-O|O-OOO" }, { "input": "331", "output": "O-|O-OOO\nO-|OOO-O\nO-|OOO-O" }, { "input": "987", "output": "-O|OO-OO\n-O|OOO-O\n-O|OOOO-" }, { "input": "123456789", "output": "-O|OOOO-\n-O|OOO-O\n-O|OO-OO\n-O|O-OOO\n-O|-OOOO\nO-|OOOO-\nO-|OOO-O\nO-|OO-OO\nO-|O-OOO" }, { "input": "234567890", "output": "O-|-OOOO\n-O|OOOO-\n-O|OOO-O\n-O|OO-OO\n-O|O-OOO\n-O|-OOOO\nO-|OOOO-\nO-|OOO-O\nO-|OO-OO" }, { "input": "100000000", "output": "O-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|O-OOO" }, { "input": "111111111", "output": "O-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO\nO-|O-OOO" }, { "input": "90909090", "output": "O-|-OOOO\n-O|OOOO-\nO-|-OOOO\n-O|OOOO-\nO-|-OOOO\n-O|OOOO-\nO-|-OOOO\n-O|OOOO-" }, { "input": "987654321", "output": "O-|O-OOO\nO-|OO-OO\nO-|OOO-O\nO-|OOOO-\n-O|-OOOO\n-O|O-OOO\n-O|OO-OO\n-O|OOO-O\n-O|OOOO-" }, { "input": "45165125", "output": "-O|-OOOO\nO-|OO-OO\nO-|O-OOO\n-O|-OOOO\n-O|O-OOO\nO-|O-OOO\n-O|-OOOO\nO-|OOOO-" }, { "input": "445511006", "output": "-O|O-OOO\nO-|-OOOO\nO-|-OOOO\nO-|O-OOO\nO-|O-OOO\n-O|-OOOO\n-O|-OOOO\nO-|OOOO-\nO-|OOOO-" }, { "input": "999999999", "output": "-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-\n-O|OOOO-" }, { "input": "984218523", "output": "O-|OOO-O\nO-|OO-OO\n-O|-OOOO\n-O|OOO-O\nO-|O-OOO\nO-|OO-OO\nO-|OOOO-\n-O|OOO-O\n-O|OOOO-" }, { "input": "19", "output": "-O|OOOO-\nO-|O-OOO" }, { "input": "10000000", "output": "O-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|-OOOO\nO-|O-OOO" } ]

1,674,024,765

2,147,483,647

Python 3

OK

TESTS

36

46

0

d = { '0': "O-|-OOOO", '1': "O-|O-OOO", '2': "O-|OO-OO", '3': "O-|OOO-O", '4': "O-|OOOO-", '5': "-O|-OOOO", '6': "-O|O-OOO", '7': "-O|OO-OO", '8': "-O|OOO-O", '9': "-O|OOOO-" } for c in input()[::-1]: print(d[c]) """"""""""""""""""""""""""""""""""""""""" ///////////////////////////////////////// // // // Implemented by brownfox2k6 // // // ///////////////////////////////////////// """""""""""""""""""""""""""""""""""""""""

Title: Soroban Time Limit: None seconds Memory Limit: None megabytes Problem Description: You know that Japan is the country with almost the largest 'electronic devices per person' ratio. So you might be quite surprised to find out that the primary school in Japan teaches to count using a Soroban — an abacus developed in Japan. This phenomenon has its reasons, of course, but we are not going to speak about them. Let's have a look at the Soroban's construction. Soroban consists of some number of rods, each rod contains five beads. We will assume that the rods are horizontal lines. One bead on each rod (the leftmost one) is divided from the others by a bar (the reckoning bar). This single bead is called go-dama and four others are ichi-damas. Each rod is responsible for representing a single digit from 0 to 9. We can obtain the value of a digit by following simple algorithm: - Set the value of a digit equal to 0. - If the go-dama is shifted to the right, add 5. - Add the number of ichi-damas shifted to the left. Thus, the upper rod on the picture shows digit 0, the middle one shows digit 2 and the lower one shows 7. We will consider the top rod to represent the last decimal digit of a number, so the picture shows number 720. Write the program that prints the way Soroban shows the given number *n*. Input Specification: The first line contains a single integer *n* (0<=≤<=*n*<=<<=109). Output Specification: Print the description of the decimal digits of number *n* from the last one to the first one (as mentioned on the picture in the statement), one per line. Print the beads as large English letters 'O', rod pieces as character '-' and the reckoning bar as '|'. Print as many rods, as many digits are in the decimal representation of number *n* without leading zeroes. We can assume that number 0 has no leading zeroes. Demo Input: ['2\n', '13\n', '720\n'] Demo Output: ['O-|OO-OO\n', 'O-|OOO-O\nO-|O-OOO\n', 'O-|-OOOO\nO-|OO-OO\n-O|OO-OO\n'] Note: none

```python d = { '0': "O-|-OOOO", '1': "O-|O-OOO", '2': "O-|OO-OO", '3': "O-|OOO-O", '4': "O-|OOOO-", '5': "-O|-OOOO", '6': "-O|O-OOO", '7': "-O|OO-OO", '8': "-O|OOO-O", '9': "-O|OOOO-" } for c in input()[::-1]: print(d[c]) """"""""""""""""""""""""""""""""""""""""" ///////////////////////////////////////// // // // Implemented by brownfox2k6 // // // ///////////////////////////////////////// """"""""""""""""""""""""""""""""""""""""" ```

3

82

A

Double Cola

PROGRAMMING

1,100

[ "implementation", "math" ]

A. Double Cola

1

256

Sheldon, Leonard, Penny, Rajesh and Howard are in the queue for a "Double Cola" drink vending machine; there are no other people in the queue. The first one in the queue (Sheldon) buys a can, drinks it and doubles! The resulting two Sheldons go to the end of the queue. Then the next in the queue (Leonard) buys a can, drinks it and gets to the end of the queue as two Leonards, and so on. This process continues ad infinitum. For example, Penny drinks the third can of cola and the queue will look like this: Rajesh, Howard, Sheldon, Sheldon, Leonard, Leonard, Penny, Penny. Write a program that will print the name of a man who will drink the *n*-th can. Note that in the very beginning the queue looks like that: Sheldon, Leonard, Penny, Rajesh, Howard. The first person is Sheldon.

The input data consist of a single integer *n* (1<=≤<=*n*<=≤<=109). It is guaranteed that the pretests check the spelling of all the five names, that is, that they contain all the five possible answers.

Print the single line — the name of the person who drinks the *n*-th can of cola. The cans are numbered starting from 1. Please note that you should spell the names like this: "Sheldon", "Leonard", "Penny", "Rajesh", "Howard" (without the quotes). In that order precisely the friends are in the queue initially.

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

[ "Sheldon\n", "Sheldon\n", "Penny\n" ]

none

500

[ { "input": "1", "output": "Sheldon" }, { "input": "6", "output": "Sheldon" }, { "input": "1802", "output": "Penny" }, { "input": "1", "output": "Sheldon" }, { "input": "2", "output": "Leonard" }, { "input": "3", "output": "Penny" }, { "input": "4", "output": "Rajesh" }, { "input": "5", "output": "Howard" }, { "input": "10", "output": "Penny" }, { "input": "534", "output": "Rajesh" }, { "input": "5033", "output": "Howard" }, { "input": "10010", "output": "Howard" }, { "input": "500000000", "output": "Penny" }, { "input": "63", "output": "Rajesh" }, { "input": "841", "output": "Leonard" }, { "input": "3667", "output": "Penny" }, { "input": "38614", "output": "Howard" }, { "input": "282798", "output": "Rajesh" }, { "input": "9266286", "output": "Rajesh" }, { "input": "27385966", "output": "Leonard" }, { "input": "121580142", "output": "Penny" }, { "input": "5", "output": "Howard" }, { "input": "300", "output": "Howard" }, { "input": "1745", "output": "Leonard" }, { "input": "8302", "output": "Rajesh" }, { "input": "184518", "output": "Sheldon" }, { "input": "1154414", "output": "Rajesh" }, { "input": "28643950", "output": "Leonard" }, { "input": "159222638", "output": "Howard" }, { "input": "24", "output": "Penny" }, { "input": "505", "output": "Penny" }, { "input": "4425", "output": "Rajesh" }, { "input": "12079", "output": "Sheldon" }, { "input": "469726", "output": "Penny" }, { "input": "3961838", "output": "Penny" }, { "input": "57710446", "output": "Leonard" }, { "input": "80719470", "output": "Howard" }, { "input": "1000000000", "output": "Penny" }, { "input": "999999999", "output": "Penny" }, { "input": "999999998", "output": "Penny" }, { "input": "5", "output": "Howard" } ]

1,545,848,950

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

93

0

t=int(input()) peo=["Sheldon","Leonard","Penny","Rajesh","Howard"] def main(t,n=0): if t>5*(2**n): return main(t-5*(2**n),n+1) else: return t//(2**(n))+1 print(peo[main(t)-1])

Title: Double Cola Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Sheldon, Leonard, Penny, Rajesh and Howard are in the queue for a "Double Cola" drink vending machine; there are no other people in the queue. The first one in the queue (Sheldon) buys a can, drinks it and doubles! The resulting two Sheldons go to the end of the queue. Then the next in the queue (Leonard) buys a can, drinks it and gets to the end of the queue as two Leonards, and so on. This process continues ad infinitum. For example, Penny drinks the third can of cola and the queue will look like this: Rajesh, Howard, Sheldon, Sheldon, Leonard, Leonard, Penny, Penny. Write a program that will print the name of a man who will drink the *n*-th can. Note that in the very beginning the queue looks like that: Sheldon, Leonard, Penny, Rajesh, Howard. The first person is Sheldon. Input Specification: The input data consist of a single integer *n* (1<=≤<=*n*<=≤<=109). It is guaranteed that the pretests check the spelling of all the five names, that is, that they contain all the five possible answers. Output Specification: Print the single line — the name of the person who drinks the *n*-th can of cola. The cans are numbered starting from 1. Please note that you should spell the names like this: "Sheldon", "Leonard", "Penny", "Rajesh", "Howard" (without the quotes). In that order precisely the friends are in the queue initially. Demo Input: ['1\n', '6\n', '1802\n'] Demo Output: ['Sheldon\n', 'Sheldon\n', 'Penny\n'] Note: none

```python t=int(input()) peo=["Sheldon","Leonard","Penny","Rajesh","Howard"] def main(t,n=0): if t>5*(2**n): return main(t-5*(2**n),n+1) else: return t//(2**(n))+1 print(peo[main(t)-1]) ```

0

879

B

Table Tennis

PROGRAMMING

1,200

[ "data structures", "implementation" ]

null

*n* people are standing in a line to play table tennis. At first, the first two players in the line play a game. Then the loser goes to the end of the line, and the winner plays with the next person from the line, and so on. They play until someone wins *k* games in a row. This player becomes the winner. For each of the participants, you know the power to play table tennis, and for all players these values are different. In a game the player with greater power always wins. Determine who will be the winner.

The first line contains two integers: *n* and *k* (2<=≤<=*n*<=≤<=500, 2<=≤<=*k*<=≤<=1012) — the number of people and the number of wins. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*n*) — powers of the player. It's guaranteed that this line contains a valid permutation, i.e. all *a**i* are distinct.

Output a single integer — power of the winner.

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

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

Games in the second sample: 3 plays with 1. 3 wins. 1 goes to the end of the line. 3 plays with 2. 3 wins. He wins twice in a row. He becomes the winner.

1,000

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

1,683,385,833

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

8

46

0

numOfPlayer,numOfWins =map(int,input().split()) powerOfPlayer = list(map(int,input().split())) position = 0 timeOfWin = 0 playerWin = powerOfPlayer[0] while(position < numOfPlayer and timeOfWin < numOfWins-1): if (playerWin > powerOfPlayer[position+1]): powerOfPlayer.append(powerOfPlayer[position+1]) timeOfWin += 1 else: powerOfPlayer.append(playerWin) playerWin = powerOfPlayer[position+1] timeOfWin = 0 position +=1 print(playerWin)

Title: Table Tennis Time Limit: None seconds Memory Limit: None megabytes Problem Description: *n* people are standing in a line to play table tennis. At first, the first two players in the line play a game. Then the loser goes to the end of the line, and the winner plays with the next person from the line, and so on. They play until someone wins *k* games in a row. This player becomes the winner. For each of the participants, you know the power to play table tennis, and for all players these values are different. In a game the player with greater power always wins. Determine who will be the winner. Input Specification: The first line contains two integers: *n* and *k* (2<=≤<=*n*<=≤<=500, 2<=≤<=*k*<=≤<=1012) — the number of people and the number of wins. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=*n*) — powers of the player. It's guaranteed that this line contains a valid permutation, i.e. all *a**i* are distinct. Output Specification: Output a single integer — power of the winner. Demo Input: ['2 2\n1 2\n', '4 2\n3 1 2 4\n', '6 2\n6 5 3 1 2 4\n', '2 10000000000\n2 1\n'] Demo Output: ['2 ', '3 ', '6 ', '2\n'] Note: Games in the second sample: 3 plays with 1. 3 wins. 1 goes to the end of the line. 3 plays with 2. 3 wins. He wins twice in a row. He becomes the winner.

```python numOfPlayer,numOfWins =map(int,input().split()) powerOfPlayer = list(map(int,input().split())) position = 0 timeOfWin = 0 playerWin = powerOfPlayer[0] while(position < numOfPlayer and timeOfWin < numOfWins-1): if (playerWin > powerOfPlayer[position+1]): powerOfPlayer.append(powerOfPlayer[position+1]) timeOfWin += 1 else: powerOfPlayer.append(playerWin) playerWin = powerOfPlayer[position+1] timeOfWin = 0 position +=1 print(playerWin) ```

0

61

A

Ultra-Fast Mathematician

PROGRAMMING

800

[ "implementation" ]

A. Ultra-Fast Mathematician

2

256

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

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

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

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

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

none

500

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

1,675,158,192

2,147,483,647

Python 3

OK

TESTS

102

46

0

def main(): b1 = input().strip() b2 = input().strip() res = "" for i in range(len(b1)): if b1[i] != b2[i]: res += "1" else: res += "0" print(res) if __name__ == '__main__': main()

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

```python def main(): b1 = input().strip() b2 = input().strip() res = "" for i in range(len(b1)): if b1[i] != b2[i]: res += "1" else: res += "0" print(res) if __name__ == '__main__': main() ```

3.9885

363

B

Fence

PROGRAMMING

1,100

[ "brute force", "dp" ]

null

There is a fence in front of Polycarpus's home. The fence consists of *n* planks of the same width which go one after another from left to right. The height of the *i*-th plank is *h**i* meters, distinct planks can have distinct heights. Polycarpus has bought a posh piano and is thinking about how to get it into the house. In order to carry out his plan, he needs to take exactly *k* consecutive planks from the fence. Higher planks are harder to tear off the fence, so Polycarpus wants to find such *k* consecutive planks that the sum of their heights is minimal possible. Write the program that finds the indexes of *k* consecutive planks with minimal total height. Pay attention, the fence is not around Polycarpus's home, it is in front of home (in other words, the fence isn't cyclic).

The first line of the input contains integers *n* and *k* (1<=≤<=*n*<=≤<=1.5·105,<=1<=≤<=*k*<=≤<=*n*) — the number of planks in the fence and the width of the hole for the piano. The second line contains the sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=100), where *h**i* is the height of the *i*-th plank of the fence.

Print such integer *j* that the sum of the heights of planks *j*, *j*<=+<=1, ..., *j*<=+<=*k*<=-<=1 is the minimum possible. If there are multiple such *j*'s, print any of them.

[ "7 3\n1 2 6 1 1 7 1\n" ]

[ "3\n" ]

In the sample, your task is to find three consecutive planks with the minimum sum of heights. In the given case three planks with indexes 3, 4 and 5 have the required attribute, their total height is 8.

1,000

[ { "input": "7 3\n1 2 6 1 1 7 1", "output": "3" }, { "input": "1 1\n100", "output": "1" }, { "input": "2 1\n10 20", "output": "1" }, { "input": "10 5\n1 2 3 1 2 2 3 1 4 5", "output": "1" }, { "input": "10 2\n3 1 4 1 4 6 2 1 4 6", "output": "7" }, { "input": "2 2\n20 10", "output": "1" }, { "input": "2 1\n20 1", "output": "2" }, { "input": "3 1\n1 2 3", "output": "1" }, { "input": "3 1\n2 1 3", "output": "2" }, { "input": "3 1\n3 2 1", "output": "3" }, { "input": "3 2\n1 2 3", "output": "1" }, { "input": "3 2\n3 2 1", "output": "2" }, { "input": "3 3\n1 2 3", "output": "1" }, { "input": "4 2\n9 8 11 7", "output": "1" }, { "input": "4 2\n10 1 2 3", "output": "2" }, { "input": "6 3\n56 56 56 2 1 2", "output": "4" }, { "input": "8 3\n1 1 1 1 2 60 90 1", "output": "1" }, { "input": "4 1\n1 5 2 2", "output": "1" }, { "input": "4 2\n4 6 7 4", "output": "1" }, { "input": "10 4\n1 1 1 4 4 4 4 4 4 3", "output": "1" }, { "input": "6 3\n1 2 1 3 1 1", "output": "1" }, { "input": "5 2\n100 100 100 1 1", "output": "4" } ]

1,681,515,522

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

30

0

from sys import * input=stdin.readline n,k=map(int,input().split()) b=list(map(int,input().split())) for i in range(n-1): b[i+1]+=b[i] m=0 o=0 w=0 v=[] for j in range(n-k+1): r=k-1 + j if j==0: m=j o+=b[r] else: w+=b[r]-b[j-1] if w < o: o=w m=j-1 print(m+1)

Title: Fence Time Limit: None seconds Memory Limit: None megabytes Problem Description: There is a fence in front of Polycarpus's home. The fence consists of *n* planks of the same width which go one after another from left to right. The height of the *i*-th plank is *h**i* meters, distinct planks can have distinct heights. Polycarpus has bought a posh piano and is thinking about how to get it into the house. In order to carry out his plan, he needs to take exactly *k* consecutive planks from the fence. Higher planks are harder to tear off the fence, so Polycarpus wants to find such *k* consecutive planks that the sum of their heights is minimal possible. Write the program that finds the indexes of *k* consecutive planks with minimal total height. Pay attention, the fence is not around Polycarpus's home, it is in front of home (in other words, the fence isn't cyclic). Input Specification: The first line of the input contains integers *n* and *k* (1<=≤<=*n*<=≤<=1.5·105,<=1<=≤<=*k*<=≤<=*n*) — the number of planks in the fence and the width of the hole for the piano. The second line contains the sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=100), where *h**i* is the height of the *i*-th plank of the fence. Output Specification: Print such integer *j* that the sum of the heights of planks *j*, *j*<=+<=1, ..., *j*<=+<=*k*<=-<=1 is the minimum possible. If there are multiple such *j*'s, print any of them. Demo Input: ['7 3\n1 2 6 1 1 7 1\n'] Demo Output: ['3\n'] Note: In the sample, your task is to find three consecutive planks with the minimum sum of heights. In the given case three planks with indexes 3, 4 and 5 have the required attribute, their total height is 8.

```python from sys import * input=stdin.readline n,k=map(int,input().split()) b=list(map(int,input().split())) for i in range(n-1): b[i+1]+=b[i] m=0 o=0 w=0 v=[] for j in range(n-k+1): r=k-1 + j if j==0: m=j o+=b[r] else: w+=b[r]-b[j-1] if w < o: o=w m=j-1 print(m+1) ```

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,693,819,775

2,147,483,647

Python 3

OK

TESTS

32

92

0

n=int(input()) ev,od,x,y=0,0,0,0 num=list(map(int,input().split())) for i in range(n): if(num[i]%2==0): ev+=1 x=i+1 else: od+=1 y=i+1 if ev>od: print(y) else: print(x)

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()) ev,od,x,y=0,0,0,0 num=list(map(int,input().split())) for i in range(n): if(num[i]%2==0): ev+=1 x=i+1 else: od+=1 y=i+1 if ev>od: print(y) else: print(x) ```

3.977

0

none

0

[ "none" ]

null

All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland! It is well-known that there are *n* cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other. The tour will contain several episodes. In each of the episodes: - the wizard will disembark at some city *x* from the Helicopter; - he will give a performance and show a movie for free at the city *x*; - he will drive to some neighboring city *y* using a road; - he will give a performance and show a movie for free at the city *y*; - he will drive to some neighboring to *y* city *z*; - he will give a performance and show a movie for free at the city *z*; - he will embark the Helicopter and fly away from the city *z*. It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between *a* and *b* he only can drive once from *a* to *b*, or drive once from *b* to *a*, or do not use this road at all. The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard! Please note that the wizard can visit the same city multiple times, the restriction is on roads only.

The first line contains two integers *n*, *m* (1<=≤<=*n*<=≤<=2·105, 0<=≤<=*m*<=≤<=2·105) — the number of cities and the number of roads in Berland, respectively. The roads description follow, one in each line. Each description is a pair of two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), where *a**i* and *b**i* are the ids of the cities connected by the *i*-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to *n*. It is possible that the road network in Berland is not connected.

In the first line print *w* — the maximum possible number of episodes. The next *w* lines should contain the episodes in format *x*, *y*, *z* — the three integers denoting the ids of the cities in the order of the wizard's visits.

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

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

none

0

[]

1,505,661,357

7,857

Python 3

WRONG_ANSWER

PRETESTS

1

62

4,608,000

print(2) print("1 4 2") print("4 3 2")

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: All Berland residents are waiting for an unprecedented tour of wizard in his Blue Helicopter over the cities of Berland! It is well-known that there are *n* cities in Berland, some pairs of which are connected by bidirectional roads. Each pair of cities is connected by no more than one road. It is not guaranteed that the road network is connected, i.e. it is possible that you can't reach some city from some other. The tour will contain several episodes. In each of the episodes: - the wizard will disembark at some city *x* from the Helicopter; - he will give a performance and show a movie for free at the city *x*; - he will drive to some neighboring city *y* using a road; - he will give a performance and show a movie for free at the city *y*; - he will drive to some neighboring to *y* city *z*; - he will give a performance and show a movie for free at the city *z*; - he will embark the Helicopter and fly away from the city *z*. It is known that the wizard doesn't like to use roads, so he agrees to use each road at most once (regardless of direction). In other words, for road between *a* and *b* he only can drive once from *a* to *b*, or drive once from *b* to *a*, or do not use this road at all. The wizards wants to plan as many episodes as possible without violation the above rules. Help the wizard! Please note that the wizard can visit the same city multiple times, the restriction is on roads only. Input Specification: The first line contains two integers *n*, *m* (1<=≤<=*n*<=≤<=2·105, 0<=≤<=*m*<=≤<=2·105) — the number of cities and the number of roads in Berland, respectively. The roads description follow, one in each line. Each description is a pair of two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*, *a**i*<=≠<=*b**i*), where *a**i* and *b**i* are the ids of the cities connected by the *i*-th road. It is guaranteed that there are no two roads connecting the same pair of cities. Every road is bidirectional. The cities are numbered from 1 to *n*. It is possible that the road network in Berland is not connected. Output Specification: In the first line print *w* — the maximum possible number of episodes. The next *w* lines should contain the episodes in format *x*, *y*, *z* — the three integers denoting the ids of the cities in the order of the wizard's visits. Demo Input: ['4 5\n1 2\n3 2\n2 4\n3 4\n4 1\n', '5 8\n5 3\n1 2\n4 5\n5 1\n2 5\n4 3\n1 4\n3 2\n'] Demo Output: ['2\n1 4 2\n4 3 2\n', '4\n1 4 5\n2 3 4\n1 5 3\n5 2 1\n'] Note: none

```python print(2) print("1 4 2") print("4 3 2") ```

0

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,665,026,789

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

1

30

0

a, b = map(int, input().split(' ')) q = [] for i in range(a): s = list(map(int, input())) w = s.index(max(s)) q.append(w) print(len(set(q)))

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 a, b = map(int, input().split(' ')) q = [] for i in range(a): s = list(map(int, input())) w = s.index(max(s)) q.append(w) print(len(set(q))) ```

0

906

D

Power Tower

PROGRAMMING

2,700

[ "chinese remainder theorem", "math", "number theory" ]

null

Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from *k*<=-<=1 rocks, possesses power *p* and we want to add the rock charged with power *w**k* then value of power of a new tower will be {*w**k*}*p*. Rocks are added from the last to the first. That is for sequence *w*1,<=...,<=*w**m* value of power will be After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo *m*. Priests have *n* rocks numbered from 1 to *n*. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered *l*,<=*l*<=+<=1,<=...,<=*r*.

First line of input contains two integers *n* (1<=≤<=*n*<=≤<=105) and *m* (1<=≤<=*m*<=≤<=109). Second line of input contains *n* integers *w**k* (1<=≤<=*w**k*<=≤<=109) which is the power of rocks that priests have. Third line of input contains single integer *q* (1<=≤<=*q*<=≤<=105) which is amount of queries from priests to you. *k**th* of next *q* lines contains two integers *l**k* and *r**k* (1<=≤<=*l**k*<=≤<=*r**k*<=≤<=*n*).

Output *q* integers. *k*-th of them must be the amount of cumulative power the tower will have if is built from rocks *l**k*,<=*l**k*<=+<=1,<=...,<=*r**k*.

[ "6 1000000000\n1 2 2 3 3 3\n8\n1 1\n1 6\n2 2\n2 3\n2 4\n4 4\n4 5\n4 6\n" ]

[ "1\n1\n2\n4\n256\n3\n27\n597484987\n" ]

327 = 7625597484987

2,000

[ { "input": "6 1000000000\n1 2 2 3 3 3\n8\n1 1\n1 6\n2 2\n2 3\n2 4\n4 4\n4 5\n4 6", "output": "1\n1\n2\n4\n256\n3\n27\n597484987" }, { "input": "10 20\n792708224 4633945 600798790 384332600 283309209 762285205 750900274 160512987 390669628 205259431\n10\n5 9\n10 10\n8 10\n7 10\n7 10\n10 10\n4 4\n10 10\n7 7\n4 8", "output": "9\n11\n1\n4\n4\n11\n0\n11\n14\n0" }, { "input": "10 18634\n157997476 953632869 382859292 108314887 739258690 110965928 172586126 28393671 86410659 427585718\n10\n8 10\n6 10\n5 10\n1 5\n10 10\n2 5\n9 9\n7 10\n10 10\n7 8", "output": "15189\n1038\n6792\n3640\n9954\n18165\n4801\n10646\n9954\n7258" }, { "input": "10 50836233\n851634701 930436567 638750681 245433831 713210442 596964772 755991944 672347390 511061574 910341009\n10\n2 7\n6 8\n5 8\n9 10\n2 6\n1 10\n7 9\n5 9\n7 7\n1 9", "output": "12393313\n39557380\n49292502\n46903641\n12393313\n7141667\n33887764\n49292502\n44284682\n7141667" }, { "input": "10 1\n688064407 427303738 659797188 392572027 589349296 634815051 224079967 887153080 734271558 734494149\n10\n6 6\n3 5\n1 8\n3 6\n3 10\n4 7\n8 10\n8 8\n8 8\n10 10", "output": "0\n0\n0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "10 2\n955038141 449680214 399763026 876295481 481249362 481742997 44362794 989248781 543311754 393585591\n10\n10 10\n7 10\n7 9\n5 5\n8 10\n7 10\n9 9\n2 9\n1 1\n2 5", "output": "1\n0\n0\n0\n1\n0\n0\n0\n1\n0" }, { "input": "10 1000000000\n641599168 361387653 420063230 331976084 135516559 581380892 330923930 354835866 161468011 903819305\n10\n5 7\n3 4\n6 9\n8 8\n9 9\n10 10\n2 4\n1 10\n8 10\n9 9", "output": "566300161\n0\n787109376\n354835866\n161468011\n903819305\n1\n766599168\n508591616\n161468011" }, { "input": "10 13\n26 81 5 48 77 72 64 31 64 64\n10\n2 9\n3 6\n6 10\n3 9\n3 3\n10 10\n6 9\n7 8\n7 9\n7 7", "output": "3\n1\n9\n1\n5\n12\n9\n12\n12\n12" }, { "input": "10 11626\n75 62 33 89 15 23 79 44 42 64\n10\n3 10\n8 9\n4 6\n1 3\n8 9\n2 7\n10 10\n4 8\n4 4\n9 10", "output": "9537\n4034\n1353\n6273\n4034\n4810\n64\n475\n89\n1090" }, { "input": "10 493276887\n45 69 40 89 90 36 66 45 80 79\n10\n6 8\n7 10\n9 10\n2 4\n3 3\n4 10\n6 10\n2 6\n1 9\n7 8", "output": "9246240\n133793487\n168548840\n347974281\n40\n335479897\n429073974\n253420560\n465717924\n439476282" }, { "input": "10 1\n90 2 82 24 22 84 7 7 71 96\n10\n5 7\n2 9\n5 5\n9 10\n1 2\n10 10\n2 4\n7 8\n4 8\n2 7", "output": "0\n0\n0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "10 2\n82 24 48 92 69 79 34 61 22 51\n10\n7 9\n3 8\n10 10\n6 10\n4 10\n7 10\n2 2\n7 10\n9 10\n4 7", "output": "0\n0\n1\n1\n0\n0\n0\n0\n0\n0" }, { "input": "10 1000000000\n38 41 74 34 75 43 34 67 80 61\n10\n3 9\n3 8\n3 4\n8 9\n3 3\n5 5\n10 10\n6 10\n8 9\n10 10", "output": "678552576\n678552576\n570840576\n371278401\n74\n75\n61\n683084801\n371278401\n61" }, { "input": "10 17\n3 1 4 3 2 3 2 4 1 2\n10\n8 10\n3 6\n10 10\n2 4\n2 9\n2 4\n10 10\n10 10\n1 6\n8 9", "output": "4\n4\n2\n1\n1\n1\n2\n2\n3\n4" }, { "input": "10 16228\n2 1 1 3 2 1 1 3 2 4\n10\n8 10\n2 5\n9 10\n8 9\n3 4\n5 7\n1 3\n6 6\n8 10\n2 8", "output": "10065\n1\n16\n9\n1\n2\n2\n1\n10065\n1" }, { "input": "10 544434102\n1 4 4 2 3 1 1 2 3 2\n10\n3 9\n8 10\n8 8\n10 10\n1 10\n4 9\n3 8\n2 7\n10 10\n10 10", "output": "65536\n512\n2\n2\n1\n8\n65536\n127776064\n2\n2" }, { "input": "10 1\n2 1 1 4 2 1 2 3 4 1\n10\n6 8\n9 9\n10 10\n9 9\n10 10\n3 7\n5 7\n5 5\n9 9\n1 6", "output": "0\n0\n0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "10 2\n2 1 3 2 2 3 1 2 2 4\n10\n5 7\n9 10\n6 8\n8 10\n10 10\n3 10\n8 10\n2 7\n9 10\n10 10", "output": "0\n0\n1\n0\n0\n1\n0\n1\n0\n0" }, { "input": "10 1000000000\n1 1 4 4 4 1 1 2 1 2\n10\n3 7\n3 9\n2 5\n3 9\n1 9\n7 10\n5 10\n3 9\n5 5\n10 10", "output": "6084096\n6084096\n1\n6084096\n1\n1\n4\n6084096\n4\n2" }, { "input": "10 17\n3 1 4 3 2 3 2 4 1 2\n10\n8 10\n3 4\n10 10\n2 2\n2 4\n2 5\n10 10\n10 10\n1 1\n8 9", "output": "4\n13\n2\n1\n1\n1\n2\n2\n3\n4" }, { "input": "10 16228\n2 1 1 3 2 1 1 3 2 4\n10\n8 10\n2 6\n9 10\n8 9\n3 4\n5 8\n1 3\n6 6\n8 10\n2 6", "output": "10065\n1\n16\n9\n1\n2\n2\n1\n10065\n1" }, { "input": "10 544434102\n1 4 4 2 3 1 1 2 3 2\n10\n3 3\n8 10\n8 8\n10 10\n1 5\n4 7\n3 4\n2 5\n10 10\n10 10", "output": "4\n512\n2\n2\n1\n8\n16\n127776064\n2\n2" }, { "input": "10 1\n2 1 1 4 2 1 2 3 4 1\n10\n6 8\n9 9\n10 10\n9 9\n10 10\n3 7\n5 9\n5 9\n9 9\n1 1", "output": "0\n0\n0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "10 2\n2 1 3 2 2 3 1 2 2 4\n10\n5 8\n9 10\n6 8\n8 10\n10 10\n3 6\n8 10\n2 4\n9 10\n10 10", "output": "0\n0\n1\n0\n0\n1\n0\n1\n0\n0" }, { "input": "10 1000000000\n1 1 4 4 4 1 1 2 1 2\n10\n3 6\n3 5\n2 2\n3 3\n1 4\n7 10\n5 8\n3 4\n5 6\n10 10", "output": "6084096\n6084096\n1\n4\n1\n1\n4\n256\n4\n2" }, { "input": "10 20\n792708224 4633945 600798790 384332600 283309209 762285205 750900274 160512987 390669628 205259431\n10\n5 9\n10 10\n8 10\n7 10\n7 10\n10 10\n4 6\n10 10\n7 7\n4 5", "output": "9\n11\n1\n4\n4\n11\n0\n11\n14\n0" }, { "input": "10 18634\n157997476 953632869 382859292 108314887 739258690 110965928 172586126 28393671 86410659 427585718\n10\n8 10\n6 10\n5 7\n1 5\n10 10\n2 4\n9 9\n7 10\n10 10\n7 8", "output": "15189\n1038\n8556\n3640\n9954\n2093\n4801\n10646\n9954\n7258" }, { "input": "10 50836233\n851634701 930436567 638750681 245433831 713210442 596964772 755991944 672347390 511061574 910341009\n10\n2 3\n6 8\n5 7\n9 10\n2 4\n1 5\n7 9\n5 6\n7 7\n1 4", "output": "50678308\n39557380\n29895264\n46903641\n9930496\n7141667\n33887764\n3470796\n44284682\n7141667" }, { "input": "10 1\n688064407 427303738 659797188 392572027 589349296 634815051 224079967 887153080 734271558 734494149\n10\n6 6\n3 5\n1 3\n3 4\n3 7\n4 8\n8 10\n8 8\n8 8\n10 10", "output": "0\n0\n0\n0\n0\n0\n0\n0\n0\n0" }, { "input": "10 2\n955038141 449680214 399763026 876295481 481249362 481742997 44362794 989248781 543311754 393585591\n10\n10 10\n7 10\n7 9\n5 6\n8 10\n7 10\n9 9\n2 3\n1 1\n2 5", "output": "1\n0\n0\n0\n1\n0\n0\n0\n1\n0" }, { "input": "10 1000000000\n641599168 361387653 420063230 331976084 135516559 581380892 330923930 354835866 161468011 903819305\n10\n5 8\n3 7\n6 9\n8 8\n9 9\n10 10\n2 4\n1 5\n8 10\n9 9", "output": "20733441\n0\n787109376\n354835866\n161468011\n903819305\n1\n766599168\n508591616\n161468011" } ]

1,625,404,257

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

0

4,500

9,113,600

n,k=map(int,input().split()) m=list(map(int,input().split())) m.insert(0,0) print(m) q = int(input()) for i in range(1, q + 1): l,r=map(int,input().split()) ans = m[l] print(ans) for j in range(l + 1, r +1): ans = m[j] ** ans print(ans % k)

Title: Power Tower Time Limit: None seconds Memory Limit: None megabytes Problem Description: Priests of the Quetzalcoatl cult want to build a tower to represent a power of their god. Tower is usually made of power-charged rocks. It is built with the help of rare magic by levitating the current top of tower and adding rocks at its bottom. If top, which is built from *k*<=-<=1 rocks, possesses power *p* and we want to add the rock charged with power *w**k* then value of power of a new tower will be {*w**k*}*p*. Rocks are added from the last to the first. That is for sequence *w*1,<=...,<=*w**m* value of power will be After tower is built, its power may be extremely large. But still priests want to get some information about it, namely they want to know a number called cumulative power which is the true value of power taken modulo *m*. Priests have *n* rocks numbered from 1 to *n*. They ask you to calculate which value of cumulative power will the tower possess if they will build it from rocks numbered *l*,<=*l*<=+<=1,<=...,<=*r*. Input Specification: First line of input contains two integers *n* (1<=≤<=*n*<=≤<=105) and *m* (1<=≤<=*m*<=≤<=109). Second line of input contains *n* integers *w**k* (1<=≤<=*w**k*<=≤<=109) which is the power of rocks that priests have. Third line of input contains single integer *q* (1<=≤<=*q*<=≤<=105) which is amount of queries from priests to you. *k**th* of next *q* lines contains two integers *l**k* and *r**k* (1<=≤<=*l**k*<=≤<=*r**k*<=≤<=*n*). Output Specification: Output *q* integers. *k*-th of them must be the amount of cumulative power the tower will have if is built from rocks *l**k*,<=*l**k*<=+<=1,<=...,<=*r**k*. Demo Input: ['6 1000000000\n1 2 2 3 3 3\n8\n1 1\n1 6\n2 2\n2 3\n2 4\n4 4\n4 5\n4 6\n'] Demo Output: ['1\n1\n2\n4\n256\n3\n27\n597484987\n'] Note: 327 = 7625597484987

```python n,k=map(int,input().split()) m=list(map(int,input().split())) m.insert(0,0) print(m) q = int(input()) for i in range(1, q + 1): l,r=map(int,input().split()) ans = m[l] print(ans) for j in range(l + 1, r +1): ans = m[j] ** ans print(ans % k) ```

0

698

A

Vacations

PROGRAMMING

1,400

[ "dp" ]

null

Vasya has *n* days of vacations! So he decided to improve his IT skills and do sport. Vasya knows the following information about each of this *n* days: whether that gym opened and whether a contest was carried out in the Internet on that day. For the *i*-th day there are four options: 1. on this day the gym is closed and the contest is not carried out; 1. on this day the gym is closed and the contest is carried out; 1. on this day the gym is open and the contest is not carried out; 1. on this day the gym is open and the contest is carried out. On each of days Vasya can either have a rest or write the contest (if it is carried out on this day), or do sport (if the gym is open on this day). Find the minimum number of days on which Vasya will have a rest (it means, he will not do sport and write the contest at the same time). The only limitation that Vasya has — he does not want to do the same activity on two consecutive days: it means, he will not do sport on two consecutive days, and write the contest on two consecutive days.

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of days of Vasya's vacations. The second line contains the sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=3) separated by space, where: - *a**i* equals 0, if on the *i*-th day of vacations the gym is closed and the contest is not carried out; - *a**i* equals 1, if on the *i*-th day of vacations the gym is closed, but the contest is carried out; - *a**i* equals 2, if on the *i*-th day of vacations the gym is open and the contest is not carried out; - *a**i* equals 3, if on the *i*-th day of vacations the gym is open and the contest is carried out.

Print the minimum possible number of days on which Vasya will have a rest. Remember that Vasya refuses: - to do sport on any two consecutive days, - to write the contest on any two consecutive days.

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

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

In the first test Vasya can write the contest on the day number 1 and do sport on the day number 3. Thus, he will have a rest for only 2 days. In the second test Vasya should write contests on days number 1, 3, 5 and 7, in other days do sport. Thus, he will not have a rest for a single day. In the third test Vasya can do sport either on a day number 1 or number 2. He can not do sport in two days, because it will be contrary to the his limitation. Thus, he will have a rest for only one day.

500

[ { "input": "4\n1 3 2 0", "output": "2" }, { "input": "7\n1 3 3 2 1 2 3", "output": "0" }, { "input": "2\n2 2", "output": "1" }, { "input": "1\n0", "output": "1" }, { "input": "10\n0 0 1 1 0 0 0 0 1 0", "output": "8" }, { "input": "100\n3 2 3 3 3 2 3 1 3 2 2 3 2 3 3 3 3 3 3 1 2 2 3 1 3 3 2 2 2 3 1 0 3 3 3 2 3 3 1 1 3 1 3 3 3 1 3 1 3 0 1 3 2 3 2 1 1 3 2 3 3 3 2 3 1 3 3 3 3 2 2 2 1 3 1 3 3 3 3 1 3 2 3 3 0 3 3 3 3 3 1 0 2 1 3 3 0 2 3 3", "output": "16" }, { "input": "10\n2 3 0 1 3 1 2 2 1 0", "output": "3" }, { "input": "45\n3 3 2 3 2 3 3 3 0 3 3 3 3 3 3 3 1 3 2 3 2 3 2 2 2 3 2 3 3 3 3 3 1 2 3 3 2 2 2 3 3 3 3 1 3", "output": "6" }, { "input": "1\n1", "output": "0" }, { "input": "1\n2", "output": "0" }, { "input": "1\n3", "output": "0" }, { "input": "2\n1 1", "output": "1" }, { "input": "2\n1 3", "output": "0" }, { "input": "2\n0 1", "output": "1" }, { "input": "2\n0 0", "output": "2" }, { "input": "2\n3 3", "output": "0" }, { "input": "3\n3 3 3", "output": "0" }, { "input": "2\n3 2", "output": "0" }, { "input": "2\n0 2", "output": "1" }, { "input": "10\n2 2 3 3 3 3 2 1 3 2", "output": "2" }, { "input": "15\n0 1 0 0 0 2 0 1 0 0 0 2 0 0 0", "output": "11" }, { "input": "15\n1 3 2 2 2 3 3 3 3 2 3 2 2 1 1", "output": "4" }, { "input": "15\n3 1 3 2 3 2 2 2 3 3 3 3 2 3 2", "output": "3" }, { "input": "20\n0 2 0 1 0 0 0 1 2 0 1 1 1 0 1 1 0 1 1 0", "output": "12" }, { "input": "20\n2 3 2 3 3 3 3 2 0 3 1 1 2 3 0 3 2 3 0 3", "output": "5" }, { "input": "20\n3 3 3 3 2 3 3 2 1 3 3 2 2 2 3 2 2 2 2 2", "output": "4" }, { "input": "25\n0 0 1 0 0 1 0 0 1 0 0 1 0 2 0 0 2 0 0 1 0 2 0 1 1", "output": "16" }, { "input": "25\n1 3 3 2 2 3 3 3 3 3 1 2 2 3 2 0 2 1 0 1 3 2 2 3 3", "output": "5" }, { "input": "25\n2 3 1 3 3 2 1 3 3 3 1 3 3 1 3 2 3 3 1 3 3 3 2 3 3", "output": "3" }, { "input": "30\n0 0 1 0 1 0 1 1 0 0 0 0 0 0 1 0 0 1 1 0 0 2 0 0 1 1 2 0 0 0", "output": "22" }, { "input": "30\n1 1 3 2 2 0 3 2 3 3 1 2 0 1 1 2 3 3 2 3 1 3 2 3 0 2 0 3 3 2", "output": "9" }, { "input": "30\n1 2 3 2 2 3 3 3 3 3 3 3 3 3 3 1 2 2 3 2 3 3 3 2 1 3 3 3 1 3", "output": "2" }, { "input": "35\n0 1 1 0 0 2 0 0 1 0 0 0 1 0 1 0 1 0 0 0 1 2 1 0 2 2 1 0 1 0 1 1 1 0 0", "output": "21" }, { "input": "35\n2 2 0 3 2 2 0 3 3 1 1 3 3 1 2 2 0 2 2 2 2 3 1 0 2 1 3 2 2 3 2 3 3 1 2", "output": "11" }, { "input": "35\n1 2 2 3 3 3 3 3 2 2 3 3 2 3 3 2 3 2 3 3 2 2 2 3 3 2 3 3 3 1 3 3 2 2 2", "output": "7" }, { "input": "40\n2 0 1 1 0 0 0 0 2 0 1 1 1 0 0 1 0 0 0 0 0 2 0 0 0 2 1 1 1 3 0 0 0 0 0 0 0 1 1 0", "output": "28" }, { "input": "40\n2 2 3 2 0 2 3 2 1 2 3 0 2 3 2 1 1 3 1 1 0 2 3 1 3 3 1 1 3 3 2 2 1 3 3 3 2 3 3 1", "output": "10" }, { "input": "40\n1 3 2 3 3 2 3 3 2 2 3 1 2 1 2 2 3 1 2 2 1 2 2 2 1 2 2 3 2 3 2 3 2 3 3 3 1 3 2 3", "output": "8" }, { "input": "45\n2 1 0 0 0 2 1 0 1 0 0 2 2 1 1 0 0 2 0 0 0 0 0 0 1 0 0 2 0 0 1 1 0 0 1 0 0 1 1 2 0 0 2 0 2", "output": "29" }, { "input": "45\n3 3 2 3 3 3 2 2 3 2 3 1 3 2 3 2 2 1 1 3 2 3 2 1 3 1 2 3 2 2 0 3 3 2 3 2 3 2 3 2 0 3 1 1 3", "output": "8" }, { "input": "50\n3 0 0 0 2 0 0 0 0 0 0 0 2 1 0 2 0 1 0 1 3 0 2 1 1 0 0 1 1 0 0 1 2 1 1 2 1 1 0 0 0 0 0 0 0 1 2 2 0 0", "output": "32" }, { "input": "50\n3 3 3 3 1 0 3 3 0 2 3 1 1 1 3 2 3 3 3 3 3 1 0 1 2 2 3 3 2 3 0 0 0 2 1 0 1 2 2 2 2 0 2 2 2 1 2 3 3 2", "output": "16" }, { "input": "50\n3 2 3 1 2 1 2 3 3 2 3 3 2 1 3 3 3 3 3 3 2 3 2 3 2 2 3 3 3 2 3 3 3 3 2 3 1 2 3 3 2 3 3 1 2 2 1 1 3 3", "output": "7" }, { "input": "55\n0 0 1 1 0 1 0 0 1 0 1 0 0 0 2 0 0 1 0 0 0 1 0 0 0 0 3 1 0 0 0 1 0 0 0 0 2 0 0 0 2 0 2 1 0 0 0 0 0 0 0 0 2 0 0", "output": "40" }, { "input": "55\n3 0 3 3 3 2 0 2 3 0 3 2 3 3 0 3 3 1 3 3 1 2 3 2 0 3 3 2 1 2 3 2 3 0 3 2 2 1 2 3 2 2 1 3 2 2 3 1 3 2 2 3 3 2 2", "output": "13" }, { "input": "55\n3 3 1 3 2 3 2 3 2 2 3 3 3 3 3 1 1 3 3 2 3 2 3 2 0 1 3 3 3 3 2 3 2 3 1 1 2 2 2 3 3 3 3 3 2 2 2 3 2 3 3 3 3 1 3", "output": "7" }, { "input": "60\n0 1 0 0 0 0 0 0 0 2 1 1 3 0 0 0 0 0 1 0 1 1 0 0 0 3 0 1 0 1 0 2 0 0 0 0 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 0 0 0", "output": "44" }, { "input": "60\n3 2 1 3 2 2 3 3 3 1 1 3 2 2 3 3 1 3 2 2 3 3 2 2 2 2 0 2 2 3 2 3 0 3 3 3 2 3 3 0 1 3 2 1 3 1 1 2 1 3 1 1 2 2 1 3 3 3 2 2", "output": "15" }, { "input": "60\n3 2 2 3 2 3 2 3 3 2 3 2 3 3 2 3 3 3 3 3 3 2 3 3 1 2 3 3 3 2 1 3 3 1 3 1 3 0 3 3 3 2 3 2 3 2 3 3 1 1 2 3 3 3 3 2 1 3 2 3", "output": "8" }, { "input": "65\n1 0 2 1 1 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 1 2 0 2 1 0 2 1 0 1 0 1 1 0 1 1 1 2 1 0 1 0 0 0 0 1 2 2 1 0 0 1 2 1 2 0 2 0 0 0 1 1", "output": "35" }, { "input": "65\n2 2 2 3 0 2 1 2 3 3 1 3 1 2 1 3 2 3 2 2 2 1 2 0 3 1 3 1 1 3 1 3 3 3 3 3 1 3 0 3 1 3 1 2 2 3 2 0 3 1 3 2 1 2 2 2 3 3 2 3 3 3 2 2 3", "output": "13" }, { "input": "65\n3 2 3 3 3 2 3 2 3 3 3 3 3 3 3 3 3 2 3 2 3 2 2 3 3 3 3 3 2 2 2 3 3 2 3 3 2 3 3 3 3 2 3 3 3 2 2 3 3 3 3 3 3 2 2 3 3 2 3 3 1 3 3 3 3", "output": "6" }, { "input": "70\n1 0 0 0 1 0 1 0 0 0 1 1 0 1 0 0 1 1 1 0 1 1 0 0 1 1 1 3 1 1 0 1 2 0 2 1 0 0 0 1 1 1 1 1 0 0 1 0 0 0 1 1 1 3 0 0 1 0 0 0 1 0 0 0 0 0 1 0 1 1", "output": "43" }, { "input": "70\n2 3 3 3 1 3 3 1 2 1 1 2 2 3 0 2 3 3 1 3 3 2 2 3 3 3 2 2 2 2 1 3 3 0 2 1 1 3 2 3 3 2 2 3 1 3 1 2 3 2 3 3 2 2 2 3 1 1 2 1 3 3 2 2 3 3 3 1 1 1", "output": "16" }, { "input": "70\n3 3 2 2 1 2 1 2 2 2 2 2 3 3 2 3 3 3 3 2 2 2 2 3 3 3 1 3 3 3 2 3 3 3 3 2 3 3 1 3 1 3 2 3 3 2 3 3 3 2 3 2 3 3 1 2 3 3 2 2 2 3 2 3 3 3 3 3 3 1", "output": "10" }, { "input": "75\n1 0 0 1 1 0 0 1 0 1 2 0 0 2 1 1 0 0 0 0 0 0 2 1 1 0 0 0 0 1 0 1 0 1 1 1 0 1 0 0 1 0 0 0 0 0 0 1 1 0 0 1 2 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 1 0 1 0", "output": "51" }, { "input": "75\n1 3 3 3 1 1 3 2 3 3 1 3 3 3 2 1 3 2 2 3 1 1 1 1 1 1 2 3 3 3 3 3 3 2 3 3 3 3 3 2 3 3 2 2 2 1 2 3 3 2 2 3 0 1 1 3 3 0 0 1 1 3 2 3 3 3 3 1 2 2 3 3 3 3 1", "output": "16" }, { "input": "75\n3 3 3 3 2 2 3 2 2 3 2 2 1 2 3 3 2 2 3 3 1 2 2 2 1 3 3 3 1 2 2 3 3 3 2 3 2 2 2 3 3 1 3 2 2 3 3 3 0 3 2 1 3 3 2 3 3 3 3 1 2 3 3 3 2 2 3 3 3 3 2 2 3 3 1", "output": "11" }, { "input": "80\n0 0 0 0 2 0 1 1 1 1 1 0 0 0 0 2 0 0 1 0 0 0 0 1 1 0 2 2 1 1 0 1 0 1 0 1 1 1 0 1 2 1 1 0 0 0 1 1 0 1 1 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 2 2 0 1 1 0 0 0 0 0 0 0 0 1", "output": "56" }, { "input": "80\n2 2 3 3 2 1 0 1 0 3 2 2 3 2 1 3 1 3 3 2 3 3 3 2 3 3 3 2 1 3 3 1 3 3 3 3 3 3 2 2 2 1 3 2 1 3 2 1 1 0 1 1 2 1 3 0 1 2 3 2 2 3 2 3 1 3 3 2 1 1 0 3 3 3 3 1 2 1 2 0", "output": "17" }, { "input": "80\n2 3 3 2 2 2 3 3 2 3 3 3 3 3 2 3 2 3 2 3 3 3 3 3 3 3 3 3 2 3 1 3 2 3 3 0 3 1 2 3 3 1 2 3 2 3 3 2 3 3 3 3 3 2 2 3 0 3 3 3 3 3 2 2 3 2 3 3 3 3 3 2 3 2 3 3 3 3 2 3", "output": "9" }, { "input": "85\n0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 2 0 1 0 0 2 0 1 1 0 0 0 0 2 2 0 0 0 1 0 0 0 1 2 0 1 0 0 0 2 1 1 2 0 3 1 0 2 2 1 0 0 1 1 0 0 0 0 1 0 2 1 1 2 1 0 0 1 2 1 2 0 0 1 0 1 0", "output": "54" }, { "input": "85\n2 3 1 3 2 3 1 3 3 2 1 2 1 2 2 3 2 2 3 2 0 3 3 2 1 2 2 2 3 3 2 3 3 3 2 1 1 3 1 3 2 2 2 3 3 2 3 2 3 1 1 3 2 3 1 3 3 2 3 3 2 2 3 0 1 1 2 2 2 2 1 2 3 1 3 3 1 3 2 2 3 2 3 3 3", "output": "19" }, { "input": "85\n1 2 1 2 3 2 3 3 3 3 3 3 3 2 1 3 2 3 3 3 3 2 3 3 3 1 3 3 3 3 2 3 3 3 3 3 3 2 2 1 3 3 3 3 2 2 3 1 1 2 3 3 3 2 3 3 3 3 3 2 3 3 3 2 2 3 3 1 1 1 3 3 3 3 1 3 3 3 1 3 3 1 3 2 3", "output": "9" }, { "input": "90\n2 0 1 0 0 0 0 0 0 1 1 2 0 0 0 0 0 0 0 2 2 0 2 0 0 2 1 0 2 0 1 0 1 0 0 1 2 2 0 0 1 0 0 1 0 1 0 2 0 1 1 1 0 1 1 0 1 0 2 0 1 0 1 0 0 0 1 0 0 1 2 0 0 0 1 0 0 2 2 0 0 0 0 0 1 3 1 1 0 1", "output": "57" }, { "input": "90\n2 3 3 3 2 3 2 1 3 0 3 2 3 3 2 1 3 3 2 3 2 3 3 2 1 3 1 3 3 1 2 2 3 3 2 1 2 3 2 3 0 3 3 2 2 3 1 0 3 3 1 3 3 3 3 2 1 2 2 1 3 2 1 3 3 1 2 0 2 2 3 2 2 3 3 3 1 3 2 1 2 3 3 2 3 2 3 3 2 1", "output": "17" }, { "input": "90\n2 3 2 3 2 2 3 3 2 3 2 1 2 3 3 3 2 3 2 3 3 2 3 3 3 1 3 3 1 3 2 3 2 2 1 3 3 3 3 3 3 3 3 3 3 2 3 2 3 2 1 3 3 3 3 2 2 3 3 3 3 3 3 3 3 3 3 3 3 2 2 3 3 3 3 1 3 2 3 3 3 2 2 3 2 3 2 1 3 2", "output": "9" }, { "input": "95\n0 0 3 0 2 0 1 0 0 2 0 0 0 0 0 0 0 1 0 0 0 2 0 0 0 0 0 1 0 0 2 1 0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0 1 2 0 1 2 2 0 0 1 0 2 0 0 0 1 0 2 1 2 1 0 1 0 0 0 1 0 0 1 1 2 1 1 1 1 2 0 0 0 0 0 1 1 0 1", "output": "61" }, { "input": "95\n2 3 3 2 1 1 3 3 3 2 3 3 3 2 3 2 3 3 3 2 3 2 2 3 3 2 1 2 3 3 3 1 3 0 3 3 1 3 3 1 0 1 3 3 3 0 2 1 3 3 3 3 0 1 3 2 3 3 2 1 3 1 2 1 1 2 3 0 3 3 2 1 3 2 1 3 3 3 2 2 3 2 3 3 3 2 1 3 3 3 2 3 3 1 2", "output": "15" }, { "input": "95\n2 3 3 2 3 2 2 1 3 1 2 1 2 3 1 2 3 3 1 3 3 3 1 2 3 2 2 2 2 3 3 3 2 2 3 3 3 3 3 1 2 2 3 3 3 3 2 3 2 2 2 3 3 2 3 3 3 3 3 3 3 0 3 2 0 3 3 1 3 3 3 2 3 2 3 2 3 3 3 3 2 2 1 1 3 3 3 3 3 1 3 3 3 3 2", "output": "14" }, { "input": "100\n1 0 2 0 0 0 0 2 0 0 0 1 0 1 0 0 1 0 1 2 0 1 1 0 0 1 0 1 1 0 0 0 2 0 1 0 0 2 0 0 0 0 0 1 1 1 0 0 1 0 2 0 0 0 0 1 0 1 0 1 0 1 0 1 2 2 0 0 2 0 1 0 1 0 1 0 0 0 1 0 0 2 1 1 1 0 0 1 0 0 0 2 0 0 2 1 1 0 0 2", "output": "63" }, { "input": "100\n3 2 1 3 2 3 2 3 2 2 3 1 3 3 3 3 3 2 2 3 2 2 3 2 3 3 3 2 3 1 2 1 3 3 3 3 1 3 3 3 3 3 2 3 2 1 3 3 1 2 2 3 1 3 3 1 2 2 1 3 1 3 2 2 3 3 1 3 2 3 1 2 1 2 3 3 2 2 1 2 3 3 3 3 3 1 3 3 3 3 2 1 3 0 3 3 3 2 3 3", "output": "15" }, { "input": "100\n1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2", "output": "0" }, { "input": "100\n3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3", "output": "0" }, { "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": "50" }, { "input": "100\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2", "output": "50" }, { "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 1", "output": "49" }, { "input": "100\n2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1", "output": "0" }, { "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": "2\n0 3", "output": "1" }, { "input": "2\n1 0", "output": "1" }, { "input": "2\n1 2", "output": "0" }, { "input": "2\n2 0", "output": "1" }, { "input": "2\n2 1", "output": "0" }, { "input": "2\n2 3", "output": "0" }, { "input": "2\n3 0", "output": "1" }, { "input": "2\n3 1", "output": "0" }, { "input": "100\n3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0 3 0", "output": "50" } ]

1,586,862,849

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

5

109

307,200

def rev(a) : if a == 1 : return 2 return 1 def solve(n,s): for i in range(n): if(s[i] == 3 and i == 0) : k = 0 for j in range(n) : k = j - 1 if(s[j] != 3) : break for j in range(k,-1,-1): s[j] = rev(s[j+1]) elif(i != 0) : if(s[i] == 3) : s[i] = rev(s[i-1]) elif(s[i] == 0) : s[i] = 0 else : if(s[i] == s[i-1]) : s[i] = 0 return s.count(0) n = int(input()) li = list(map(int,input().split())) print(solve(n,li))

Title: Vacations Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya has *n* days of vacations! So he decided to improve his IT skills and do sport. Vasya knows the following information about each of this *n* days: whether that gym opened and whether a contest was carried out in the Internet on that day. For the *i*-th day there are four options: 1. on this day the gym is closed and the contest is not carried out; 1. on this day the gym is closed and the contest is carried out; 1. on this day the gym is open and the contest is not carried out; 1. on this day the gym is open and the contest is carried out. On each of days Vasya can either have a rest or write the contest (if it is carried out on this day), or do sport (if the gym is open on this day). Find the minimum number of days on which Vasya will have a rest (it means, he will not do sport and write the contest at the same time). The only limitation that Vasya has — he does not want to do the same activity on two consecutive days: it means, he will not do sport on two consecutive days, and write the contest on two consecutive days. Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100) — the number of days of Vasya's vacations. The second line contains the sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=3) separated by space, where: - *a**i* equals 0, if on the *i*-th day of vacations the gym is closed and the contest is not carried out; - *a**i* equals 1, if on the *i*-th day of vacations the gym is closed, but the contest is carried out; - *a**i* equals 2, if on the *i*-th day of vacations the gym is open and the contest is not carried out; - *a**i* equals 3, if on the *i*-th day of vacations the gym is open and the contest is carried out. Output Specification: Print the minimum possible number of days on which Vasya will have a rest. Remember that Vasya refuses: - to do sport on any two consecutive days, - to write the contest on any two consecutive days. Demo Input: ['4\n1 3 2 0\n', '7\n1 3 3 2 1 2 3\n', '2\n2 2\n'] Demo Output: ['2\n', '0\n', '1\n'] Note: In the first test Vasya can write the contest on the day number 1 and do sport on the day number 3. Thus, he will have a rest for only 2 days. In the second test Vasya should write contests on days number 1, 3, 5 and 7, in other days do sport. Thus, he will not have a rest for a single day. In the third test Vasya can do sport either on a day number 1 or number 2. He can not do sport in two days, because it will be contrary to the his limitation. Thus, he will have a rest for only one day.

```python def rev(a) : if a == 1 : return 2 return 1 def solve(n,s): for i in range(n): if(s[i] == 3 and i == 0) : k = 0 for j in range(n) : k = j - 1 if(s[j] != 3) : break for j in range(k,-1,-1): s[j] = rev(s[j+1]) elif(i != 0) : if(s[i] == 3) : s[i] = rev(s[i-1]) elif(s[i] == 0) : s[i] = 0 else : if(s[i] == s[i-1]) : s[i] = 0 return s.count(0) n = int(input()) li = list(map(int,input().split())) print(solve(n,li)) ```

0

755

B

PolandBall and Game

PROGRAMMING

1,100

[ "binary search", "data structures", "games", "greedy", "sortings", "strings" ]

null

PolandBall is playing a game with EnemyBall. The rules are simple. Players have to say words in turns. You cannot say a word which was already said. PolandBall starts. The Ball which can't say a new word loses. You're given two lists of words familiar to PolandBall and EnemyBall. Can you determine who wins the game, if both play optimally?

The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=103) — number of words PolandBall and EnemyBall know, respectively. Then *n* strings follow, one per line — words familiar to PolandBall. Then *m* strings follow, one per line — words familiar to EnemyBall. Note that one Ball cannot know a word more than once (strings are unique), but some words can be known by both players. Each word is non-empty and consists of no more than 500 lowercase English alphabet letters.

In a single line of print the answer — "YES" if PolandBall wins and "NO" otherwise. Both Balls play optimally.

[ "5 1\npolandball\nis\na\ncool\ncharacter\nnope\n", "2 2\nkremowka\nwadowicka\nkremowka\nwiedenska\n", "1 2\na\na\nb\n" ]

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

In the first example PolandBall knows much more words and wins effortlessly. In the second example if PolandBall says kremowka first, then EnemyBall cannot use that word anymore. EnemyBall can only say wiedenska. PolandBall says wadowicka and wins.

1,000

[ { "input": "5 1\npolandball\nis\na\ncool\ncharacter\nnope", "output": "YES" }, { "input": "2 2\nkremowka\nwadowicka\nkremowka\nwiedenska", "output": "YES" }, { "input": "1 2\na\na\nb", "output": "NO" }, { "input": "2 2\na\nb\nb\nc", "output": "YES" }, { "input": "2 1\nc\na\na", "output": "YES" }, { "input": "3 3\nab\nbc\ncd\ncd\ndf\nfg", "output": "YES" }, { "input": "3 3\nc\na\nb\na\nd\ng", "output": "YES" }, { "input": "1 1\naa\naa", "output": "YES" }, { "input": "2 1\na\nb\na", "output": "YES" }, { "input": "6 5\na\nb\nc\nd\ne\nf\nf\ne\nd\nz\ny", "output": "YES" }, { "input": "3 2\na\nb\nc\nd\ne", "output": "YES" } ]

1,624,383,516

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

10

62

1,843,200

n, m = map(int, input().split()) a, b = [], [] for _ in range(n): a.append(input()) for _ in range(m): b.append(input()) d, i, j, k = {}, 0, 0, 0 while (k == 0 and i < len(a)) or (k==1 and j < len(b)): if k == 0: if a[i] in d: i += 1 continue d[a[i]] = 1 k, i = (k + 1) % 2, i + 1 else: if b[j] in d: j += 1 continue d[b[j]] = 2 k, j = (k + 1) % 2, j + 1 if i == len(a) and k==0: print("NO") else: print("YES")

Title: PolandBall and Game Time Limit: None seconds Memory Limit: None megabytes Problem Description: PolandBall is playing a game with EnemyBall. The rules are simple. Players have to say words in turns. You cannot say a word which was already said. PolandBall starts. The Ball which can't say a new word loses. You're given two lists of words familiar to PolandBall and EnemyBall. Can you determine who wins the game, if both play optimally? Input Specification: The first input line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=103) — number of words PolandBall and EnemyBall know, respectively. Then *n* strings follow, one per line — words familiar to PolandBall. Then *m* strings follow, one per line — words familiar to EnemyBall. Note that one Ball cannot know a word more than once (strings are unique), but some words can be known by both players. Each word is non-empty and consists of no more than 500 lowercase English alphabet letters. Output Specification: In a single line of print the answer — "YES" if PolandBall wins and "NO" otherwise. Both Balls play optimally. Demo Input: ['5 1\npolandball\nis\na\ncool\ncharacter\nnope\n', '2 2\nkremowka\nwadowicka\nkremowka\nwiedenska\n', '1 2\na\na\nb\n'] Demo Output: ['YES', 'YES', 'NO'] Note: In the first example PolandBall knows much more words and wins effortlessly. In the second example if PolandBall says kremowka first, then EnemyBall cannot use that word anymore. EnemyBall can only say wiedenska. PolandBall says wadowicka and wins.

```python n, m = map(int, input().split()) a, b = [], [] for _ in range(n): a.append(input()) for _ in range(m): b.append(input()) d, i, j, k = {}, 0, 0, 0 while (k == 0 and i < len(a)) or (k==1 and j < len(b)): if k == 0: if a[i] in d: i += 1 continue d[a[i]] = 1 k, i = (k + 1) % 2, i + 1 else: if b[j] in d: j += 1 continue d[b[j]] = 2 k, j = (k + 1) % 2, j + 1 if i == len(a) and k==0: print("NO") else: print("YES") ```

0

none

0

[ "none" ]

null

Treeland is a country in which there are *n* towns connected by *n*<=-<=1 two-way road such that it's possible to get from any town to any other town. In Treeland there are 2*k* universities which are located in different towns. Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done! To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in *k* pairs should be as large as possible. Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.

The first line of the input contains two integers *n* and *k* (2<=≤<=*n*<=≤<=200<=000, 1<=≤<=*k*<=≤<=*n*<=/<=2) — the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to *n*. The second line contains 2*k* distinct integers *u*1,<=*u*2,<=...,<=*u*2*k* (1<=≤<=*u**i*<=≤<=*n*) — indices of towns in which universities are located. The next *n*<=-<=1 line contains the description of roads. Each line contains the pair of integers *x**j* and *y**j* (1<=≤<=*x**j*,<=*y**j*<=≤<=*n*), which means that the *j*-th road connects towns *x**j* and *y**j*. All of them are two-way roads. You can move from any town to any other using only these roads.

Print the maximum possible sum of distances in the division of universities into *k* pairs.

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

[ "6\n", "9\n" ]

The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.

0

[ { "input": "7 2\n1 5 6 2\n1 3\n3 2\n4 5\n3 7\n4 3\n4 6", "output": "6" }, { "input": "9 3\n3 2 1 6 5 9\n8 9\n3 2\n2 7\n3 4\n7 6\n4 5\n2 1\n2 8", "output": "9" }, { "input": "41 3\n11 10 15 35 34 6\n28 2\n25 3\n9 4\n11 5\n7 6\n24 7\n19 8\n1 9\n34 10\n23 11\n17 12\n32 13\n32 14\n32 15\n33 16\n8 17\n19 18\n40 19\n15 20\n6 21\n41 22\n35 23\n13 24\n6 25\n22 26\n4 27\n31 28\n34 29\n41 30\n15 31\n4 32\n41 33\n23 34\n21 35\n13 36\n2 37\n22 38\n34 39\n29 40\n34 41", "output": "16" }, { "input": "2 1\n1 2\n1 2", "output": "1" }, { "input": "2 1\n2 1\n1 2", "output": "1" }, { "input": "3 1\n2 1\n1 2\n2 3", "output": "1" }, { "input": "4 1\n3 2\n1 2\n2 3\n2 4", "output": "1" }, { "input": "4 2\n1 3 2 4\n1 2\n4 3\n1 4", "output": "4" }, { "input": "5 1\n2 3\n1 2\n5 3\n1 4\n4 5", "output": "4" }, { "input": "5 2\n1 2 3 4\n1 2\n2 3\n2 4\n1 5", "output": "3" }, { "input": "6 1\n4 6\n5 2\n1 3\n1 4\n4 5\n3 6", "output": "3" }, { "input": "6 2\n6 5 4 1\n3 2\n1 3\n5 4\n3 5\n1 6", "output": "6" }, { "input": "6 3\n4 5 2 3 6 1\n4 2\n2 3\n1 4\n4 5\n5 6", "output": "7" }, { "input": "6 1\n4 5\n1 2\n1 3\n1 4\n1 5\n1 6", "output": "2" }, { "input": "6 2\n4 5 3 2\n1 2\n1 3\n6 4\n1 5\n1 6", "output": "5" }, { "input": "6 3\n4 5 2 6 3 1\n6 2\n1 3\n1 4\n1 5\n1 6", "output": "6" }, { "input": "6 1\n4 1\n5 2\n1 3\n3 4\n4 5\n5 6", "output": "2" }, { "input": "6 2\n6 4 2 5\n3 2\n1 3\n2 4\n1 5\n5 6", "output": "8" }, { "input": "6 3\n3 4 2 6 1 5\n3 2\n6 3\n3 4\n2 5\n1 6", "output": "7" }, { "input": "30 6\n15 17 2 14 6 30 13 8 10 24 1 19\n23 2\n26 3\n22 4\n7 5\n1 6\n17 7\n29 8\n30 9\n4 10\n28 11\n13 12\n6 13\n23 14\n23 15\n5 16\n30 17\n2 18\n11 19\n19 20\n4 21\n3 22\n16 23\n11 24\n29 25\n27 26\n13 27\n5 28\n23 29\n4 30", "output": "59" }, { "input": "35 15\n6 12 32 18 11 10 29 9 30 27 31 14 8 24 28 25 19 15 21 3 4 1 33 22 23 17 16 13 7 2\n1 2\n20 3\n1 4\n20 5\n20 6\n1 7\n13 8\n4 9\n1 10\n1 11\n1 12\n1 13\n18 14\n10 15\n1 16\n16 17\n1 18\n1 19\n1 20\n20 21\n1 22\n27 23\n25 24\n1 25\n20 26\n20 27\n18 28\n4 29\n13 30\n4 31\n1 32\n20 33\n1 34\n4 35", "output": "46" }, { "input": "5 1\n1 2\n1 2\n2 3\n3 4\n4 5", "output": "1" } ]

1,598,878,491

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

77

0

a = input() if a[0] == 7: print(6) else: print(9)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Treeland is a country in which there are *n* towns connected by *n*<=-<=1 two-way road such that it's possible to get from any town to any other town. In Treeland there are 2*k* universities which are located in different towns. Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done! To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in *k* pairs should be as large as possible. Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1. Input Specification: The first line of the input contains two integers *n* and *k* (2<=≤<=*n*<=≤<=200<=000, 1<=≤<=*k*<=≤<=*n*<=/<=2) — the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to *n*. The second line contains 2*k* distinct integers *u*1,<=*u*2,<=...,<=*u*2*k* (1<=≤<=*u**i*<=≤<=*n*) — indices of towns in which universities are located. The next *n*<=-<=1 line contains the description of roads. Each line contains the pair of integers *x**j* and *y**j* (1<=≤<=*x**j*,<=*y**j*<=≤<=*n*), which means that the *j*-th road connects towns *x**j* and *y**j*. All of them are two-way roads. You can move from any town to any other using only these roads. Output Specification: Print the maximum possible sum of distances in the division of universities into *k* pairs. Demo Input: ['7 2\n1 5 6 2\n1 3\n3 2\n4 5\n3 7\n4 3\n4 6\n', '9 3\n3 2 1 6 5 9\n8 9\n3 2\n2 7\n3 4\n7 6\n4 5\n2 1\n2 8\n'] Demo Output: ['6\n', '9\n'] Note: The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.

```python a = input() if a[0] == 7: print(6) else: print(9) ```

0

555

A

Case of Matryoshkas

PROGRAMMING

1,500

[ "implementation" ]

null

Andrewid the Android is a galaxy-famous detective. He is now investigating the case of vandalism at the exhibition of contemporary art. The main exhibit is a construction of *n* matryoshka dolls that can be nested one into another. The matryoshka dolls are numbered from 1 to *n*. A matryoshka with a smaller number can be nested in a matryoshka with a higher number, two matryoshkas can not be directly nested in the same doll, but there may be chain nestings, for example, 1<=→<=2<=→<=4<=→<=5. In one second, you can perform one of the two following operations: - Having a matryoshka *a* that isn't nested in any other matryoshka and a matryoshka *b*, such that *b* doesn't contain any other matryoshka and is not nested in any other matryoshka, you may put *a* in *b*; - Having a matryoshka *a* directly contained in matryoshka *b*, such that *b* is not nested in any other matryoshka, you may get *a* out of *b*. According to the modern aesthetic norms the matryoshka dolls on display were assembled in a specific configuration, i.e. as several separate chains of nested matryoshkas, but the criminal, following the mysterious plan, took out all the dolls and assembled them into a single large chain (1<=→<=2<=→<=...<=→<=*n*). In order to continue the investigation Andrewid needs to know in what minimum time it is possible to perform this action.

The first line contains integers *n* (1<=≤<=*n*<=≤<=105) and *k* (1<=≤<=*k*<=≤<=105) — the number of matryoshkas and matryoshka chains in the initial configuration. The next *k* lines contain the descriptions of the chains: the *i*-th line first contains number *m**i* (1<=≤<=*m**i*<=≤<=*n*), and then *m**i* numbers *a**i*1,<=*a**i*2,<=...,<=*a**im**i* — the numbers of matryoshkas in the chain (matryoshka *a**i*1 is nested into matryoshka *a**i*2, that is nested into matryoshka *a**i*3, and so on till the matryoshka *a**im**i* that isn't nested into any other matryoshka). It is guaranteed that *m*1<=+<=*m*2<=+<=...<=+<=*m**k*<==<=*n*, the numbers of matryoshkas in all the chains are distinct, in each chain the numbers of matryoshkas follow in the ascending order.

In the single line print the minimum number of seconds needed to assemble one large chain from the initial configuration.

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

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

In the first sample test there are two chains: 1 → 2 and 3. In one second you can nest the first chain into the second one and get 1 → 2 → 3. In the second sample test you need to disassemble all the three chains into individual matryoshkas in 2 + 1 + 1 = 4 seconds and then assemble one big chain in 6 seconds.

250

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

1,440,425,899

2,147,483,647

Python 3

OK

TESTS

47

343

7,168,000

def main(): n, k = map(int, input().split()) res = 0 for _ in range(k): tmp = list(map(int, input().split())) if tmp[1] == 1: tmp[0] = 0 for i, x in enumerate(tmp): if i != x: res += (len(tmp) - i) * 2 break else: res += len(tmp) * 2 - 3 print(res) if __name__ == '__main__': main()

Title: Case of Matryoshkas Time Limit: None seconds Memory Limit: None megabytes Problem Description: Andrewid the Android is a galaxy-famous detective. He is now investigating the case of vandalism at the exhibition of contemporary art. The main exhibit is a construction of *n* matryoshka dolls that can be nested one into another. The matryoshka dolls are numbered from 1 to *n*. A matryoshka with a smaller number can be nested in a matryoshka with a higher number, two matryoshkas can not be directly nested in the same doll, but there may be chain nestings, for example, 1<=→<=2<=→<=4<=→<=5. In one second, you can perform one of the two following operations: - Having a matryoshka *a* that isn't nested in any other matryoshka and a matryoshka *b*, such that *b* doesn't contain any other matryoshka and is not nested in any other matryoshka, you may put *a* in *b*; - Having a matryoshka *a* directly contained in matryoshka *b*, such that *b* is not nested in any other matryoshka, you may get *a* out of *b*. According to the modern aesthetic norms the matryoshka dolls on display were assembled in a specific configuration, i.e. as several separate chains of nested matryoshkas, but the criminal, following the mysterious plan, took out all the dolls and assembled them into a single large chain (1<=→<=2<=→<=...<=→<=*n*). In order to continue the investigation Andrewid needs to know in what minimum time it is possible to perform this action. Input Specification: The first line contains integers *n* (1<=≤<=*n*<=≤<=105) and *k* (1<=≤<=*k*<=≤<=105) — the number of matryoshkas and matryoshka chains in the initial configuration. The next *k* lines contain the descriptions of the chains: the *i*-th line first contains number *m**i* (1<=≤<=*m**i*<=≤<=*n*), and then *m**i* numbers *a**i*1,<=*a**i*2,<=...,<=*a**im**i* — the numbers of matryoshkas in the chain (matryoshka *a**i*1 is nested into matryoshka *a**i*2, that is nested into matryoshka *a**i*3, and so on till the matryoshka *a**im**i* that isn't nested into any other matryoshka). It is guaranteed that *m*1<=+<=*m*2<=+<=...<=+<=*m**k*<==<=*n*, the numbers of matryoshkas in all the chains are distinct, in each chain the numbers of matryoshkas follow in the ascending order. Output Specification: In the single line print the minimum number of seconds needed to assemble one large chain from the initial configuration. Demo Input: ['3 2\n2 1 2\n1 3\n', '7 3\n3 1 3 7\n2 2 5\n2 4 6\n'] Demo Output: ['1\n', '10\n'] Note: In the first sample test there are two chains: 1 → 2 and 3. In one second you can nest the first chain into the second one and get 1 → 2 → 3. In the second sample test you need to disassemble all the three chains into individual matryoshkas in 2 + 1 + 1 = 4 seconds and then assemble one big chain in 6 seconds.

```python def main(): n, k = map(int, input().split()) res = 0 for _ in range(k): tmp = list(map(int, input().split())) if tmp[1] == 1: tmp[0] = 0 for i, x in enumerate(tmp): if i != x: res += (len(tmp) - i) * 2 break else: res += len(tmp) * 2 - 3 print(res) if __name__ == '__main__': main() ```

3

262

A

Roma and Lucky Numbers

PROGRAMMING

800

[ "implementation" ]

null

Roma (a popular Russian name that means 'Roman') loves the Little Lvov Elephant's lucky numbers. Let us remind you that lucky numbers are positive integers whose decimal representation only contains lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Roma's got *n* positive integers. He wonders, how many of those integers have not more than *k* lucky digits? Help him, write the program that solves the problem.

The first line contains two integers *n*, *k* (1<=≤<=*n*,<=*k*<=≤<=100). The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — the numbers that Roma has. The numbers in the lines are separated by single spaces.

In a single line print a single integer — the answer to the problem.

[ "3 4\n1 2 4\n", "3 2\n447 44 77\n" ]

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

In the first sample all numbers contain at most four lucky digits, so the answer is 3. In the second sample number 447 doesn't fit in, as it contains more than two lucky digits. All other numbers are fine, so the answer is 2.

500

[ { "input": "3 4\n1 2 4", "output": "3" }, { "input": "3 2\n447 44 77", "output": "2" }, { "input": "2 2\n507978501 180480073", "output": "2" }, { "input": "9 6\n655243746 167613748 1470546 57644035 176077477 56984809 44677 215706823 369042089", "output": "9" }, { "input": "6 100\n170427799 37215529 675016434 168544291 683447134 950090227", "output": "6" }, { "input": "4 2\n194041605 706221269 69909135 257655784", "output": "3" }, { "input": "4 2\n9581849 67346651 530497 272158241", "output": "4" }, { "input": "3 47\n378261451 163985731 230342101", "output": "3" }, { "input": "2 3\n247776868 480572137", "output": "1" }, { "input": "7 77\n366496749 549646417 278840199 119255907 33557677 379268590 150378796", "output": "7" }, { "input": "40 31\n32230963 709031779 144328646 513494529 36547831 416998222 84161665 318773941 170724397 553666286 368402971 48581613 31452501 368026285 47903381 939151438 204145360 189920160 288159400 133145006 314295423 450219949 160203213 358403181 478734385 29331901 31051111 110710191 567314089 139695685 111511396 87708701 317333277 103301481 110400517 634446253 481551313 39202255 105948 738066085", "output": "40" }, { "input": "1 8\n55521105", "output": "1" }, { "input": "49 3\n34644511 150953622 136135827 144208961 359490601 86708232 719413689 188605873 64330753 488776302 104482891 63360106 437791390 46521319 70778345 339141601 136198441 292941209 299339510 582531183 555958105 437904637 74219097 439816011 236010407 122674666 438442529 186501223 63932449 407678041 596993853 92223251 849265278 480265849 30983497 330283357 186901672 20271344 794252593 123774176 27851201 52717531 479907210 196833889 149331196 82147847 255966471 278600081 899317843", "output": "44" }, { "input": "26 2\n330381357 185218042 850474297 483015466 296129476 1205865 538807493 103205601 160403321 694220263 416255901 7245756 507755361 88187633 91426751 1917161 58276681 59540376 576539745 595950717 390256887 105690055 607818885 28976353 488947089 50643601", "output": "22" }, { "input": "38 1\n194481717 126247087 815196361 106258801 381703249 283859137 15290101 40086151 213688513 577996947 513899717 371428417 107799271 11136651 5615081 323386401 381128815 34217126 17709913 520702093 201694245 570931849 169037023 417019726 282437316 7417126 271667553 11375851 185087449 410130883 383045677 5764771 905017051 328584026 215330671 299553233 15838255 234532105", "output": "20" }, { "input": "44 9\n683216389 250581469 130029957 467020047 188395565 206237982 63257361 68314981 732878407 563579660 199133851 53045209 665723851 16273169 10806790 556633156 350593410 474645249 478790761 708234243 71841230 18090541 19836685 146373571 17947452 534010506 46933264 377035021 311636557 75193963 54321761 12759959 71120181 548816939 23608621 31876417 107672995 72575155 369667956 20574379 210596751 532163173 75726739 853719629", "output": "44" }, { "input": "8 6\n204157376 10514197 65483881 347219841 263304577 296402721 11739011 229776191", "output": "8" }, { "input": "38 29\n333702889 680931737 61137217 203030505 68728281 11414209 642645708 590904616 3042901 607198177 189041074 700764043 813035201 198341461 126403544 401436841 420826465 45046581 20249976 46978855 46397957 706610773 24701041 57954481 51603266 593109701 385569073 178982291 582152863 287317968 1474090 34825141 432421977 130257781 151516903 540852403 548392 117246529", "output": "38" }, { "input": "19 3\n562569697 549131571 50676718 84501863 74567295 702372009 365895280 451459937 40378543 167666701 158635641 53639293 442332661 825055617 100109161 326616021 862332843 533271196 4791547", "output": "18" }, { "input": "1 1\n44", "output": "0" }, { "input": "1 1\n4", "output": "1" }, { "input": "10 3\n444 447 774 777 7777 4447 4 7 7 4", "output": "8" } ]

1,619,192,059

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

124

0

# # RED CODER # # n, k = map(int, input().split()) x = list(map(int, input().split()))[:n] count = 0 for i in x: if len(str(i)) > k: count += 1 print(len(x)-count)

Title: Roma and Lucky Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: Roma (a popular Russian name that means 'Roman') loves the Little Lvov Elephant's lucky numbers. Let us remind you that lucky numbers are positive integers whose decimal representation only contains lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not. Roma's got *n* positive integers. He wonders, how many of those integers have not more than *k* lucky digits? Help him, write the program that solves the problem. Input Specification: The first line contains two integers *n*, *k* (1<=≤<=*n*,<=*k*<=≤<=100). The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — the numbers that Roma has. The numbers in the lines are separated by single spaces. Output Specification: In a single line print a single integer — the answer to the problem. Demo Input: ['3 4\n1 2 4\n', '3 2\n447 44 77\n'] Demo Output: ['3\n', '2\n'] Note: In the first sample all numbers contain at most four lucky digits, so the answer is 3. In the second sample number 447 doesn't fit in, as it contains more than two lucky digits. All other numbers are fine, so the answer is 2.

```python # # RED CODER # # n, k = map(int, input().split()) x = list(map(int, input().split()))[:n] count = 0 for i in x: if len(str(i)) > k: count += 1 print(len(x)-count) ```

0

925

C

Big Secret

PROGRAMMING

2,200

[ "constructive algorithms", "math" ]

null

Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence $a_1, \ldots, a_n$. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence $b_1, \ldots, b_n$ using the following rules: - $b_1 = a_1$;- $b_i = a_i \oplus a_{i - 1}$ for all $i$ from 2 to $n$, where $x \oplus y$ is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of $x$ and $y$. It is easy to see that the original sequence can be obtained using the rule $a_i = b_1 \oplus \ldots \oplus b_i$. However, some time later Vitya discovered that the integers $b_i$ in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers $b_i$ so that the sequence $a_i = b_1 \oplus \ldots \oplus b_i$ is strictly increasing. Help him find such a permutation or determine that it is impossible.

The first line contains a single integer $n$ ($1 \leq n \leq 10^5$). The second line contains $n$ integers $b_1, \ldots, b_n$ ($1 \leq b_i < 2^{60}$).

If there are no valid permutations, print a single line containing "No". Otherwise in the first line print the word "Yes", and in the second line print integers $b'_1, \ldots, b'_n$ — a valid permutation of integers $b_i$. The unordered multisets $\{b_1, \ldots, b_n\}$ and $\{b'_1, \ldots, b'_n\}$ should be equal, i. e. for each integer $x$ the number of occurrences of $x$ in the first multiset should be equal to the number of occurrences of $x$ in the second multiset. Apart from this, the sequence $a_i = b'_1 \oplus \ldots \oplus b'_i$ should be strictly increasing. If there are multiple answers, print any of them.

[ "3\n1 2 3\n", "6\n4 7 7 12 31 61\n" ]

[ "No\n", "Yes\n4 12 7 31 7 61 \n" ]

In the first example no permutation is valid. In the second example the given answer lead to the sequence $a_1 = 4$, $a_2 = 8$, $a_3 = 15$, $a_4 = 16$, $a_5 = 23$, $a_6 = 42$.

1,500

[ { "input": "3\n1 2 3", "output": "No" }, { "input": "6\n4 7 7 12 31 61", "output": "Yes\n4 12 7 31 7 61 " }, { "input": "1\n4", "output": "Yes\n4 " }, { "input": "2\n531 108", "output": "Yes\n108 531 " }, { "input": "5\n3 1 1 7 1", "output": "Yes\n1 3 1 7 1 " }, { "input": "10\n10 1 1 1 1 1 3 6 7 3", "output": "No" }, { "input": "31\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3 7 7 7 7 15 15 31", "output": "Yes\n1 3 1 7 1 3 1 15 1 3 1 7 1 3 1 31 1 3 1 7 1 3 1 15 1 3 1 7 1 3 1 " } ]

1,526,615,499

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

61

0

from itertools import permutations def check(l): arr = [l[0]] for i in range(1,len(l)): a = arr[-1] ^ l[i] if(a <= arr[-1]): return False else: arr.append(a) return l n = int(input()) b = [int(i) for i in input().split()] L = list(permutations(b)) for l in L: if(check(l)!=False): print("YES") [print(i,end=" ") for i in l] exit() print("NO")

Title: Big Secret Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence $a_1, \ldots, a_n$. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence $b_1, \ldots, b_n$ using the following rules: - $b_1 = a_1$;- $b_i = a_i \oplus a_{i - 1}$ for all $i$ from 2 to $n$, where $x \oplus y$ is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of $x$ and $y$. It is easy to see that the original sequence can be obtained using the rule $a_i = b_1 \oplus \ldots \oplus b_i$. However, some time later Vitya discovered that the integers $b_i$ in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers $b_i$ so that the sequence $a_i = b_1 \oplus \ldots \oplus b_i$ is strictly increasing. Help him find such a permutation or determine that it is impossible. Input Specification: The first line contains a single integer $n$ ($1 \leq n \leq 10^5$). The second line contains $n$ integers $b_1, \ldots, b_n$ ($1 \leq b_i < 2^{60}$). Output Specification: If there are no valid permutations, print a single line containing "No". Otherwise in the first line print the word "Yes", and in the second line print integers $b'_1, \ldots, b'_n$ — a valid permutation of integers $b_i$. The unordered multisets $\{b_1, \ldots, b_n\}$ and $\{b'_1, \ldots, b'_n\}$ should be equal, i. e. for each integer $x$ the number of occurrences of $x$ in the first multiset should be equal to the number of occurrences of $x$ in the second multiset. Apart from this, the sequence $a_i = b'_1 \oplus \ldots \oplus b'_i$ should be strictly increasing. If there are multiple answers, print any of them. Demo Input: ['3\n1 2 3\n', '6\n4 7 7 12 31 61\n'] Demo Output: ['No\n', 'Yes\n4 12 7 31 7 61 \n'] Note: In the first example no permutation is valid. In the second example the given answer lead to the sequence $a_1 = 4$, $a_2 = 8$, $a_3 = 15$, $a_4 = 16$, $a_5 = 23$, $a_6 = 42$.

```python from itertools import permutations def check(l): arr = [l[0]] for i in range(1,len(l)): a = arr[-1] ^ l[i] if(a <= arr[-1]): return False else: arr.append(a) return l n = int(input()) b = [int(i) for i in input().split()] L = list(permutations(b)) for l in L: if(check(l)!=False): print("YES") [print(i,end=" ") for i in l] exit() print("NO") ```

0

161

A

Dress'em in Vests!

PROGRAMMING

1,300

[ "binary search", "brute force", "greedy", "two pointers" ]

null

The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line. The Two-dimensional kingdom has a regular army of *n* people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the *i*-th soldier indicated size *a**i*. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from *a**i*<=-<=*x* to *a**i*<=+<=*y*, inclusive (numbers *x*,<=*y*<=≥<=0 are specified). The Two-dimensional kingdom has *m* vests at its disposal, the *j*-th vest's size equals *b**j*. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The *i*-th soldier can put on the *j*-th vest, if *a**i*<=-<=*x*<=≤<=*b**j*<=≤<=*a**i*<=+<=*y*.

The first input line contains four integers *n*, *m*, *x* and *y* (1<=≤<=*n*,<=*m*<=≤<=105, 0<=≤<=*x*,<=*y*<=≤<=109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) in non-decreasing order, separated by single spaces — the desired sizes of vests. The third line contains *m* integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**j*<=≤<=109) in non-decreasing order, separated by single spaces — the sizes of the available vests.

In the first line print a single integer *k* — the maximum number of soldiers equipped with bulletproof vests. In the next *k* lines print *k* pairs, one pair per line, as "*u**i* *v**i*" (without the quotes). Pair (*u**i*, *v**i*) means that soldier number *u**i* must wear vest number *v**i*. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order. If there are multiple optimal answers, you are allowed to print any of them.

[ "5 3 0 0\n1 2 3 3 4\n1 3 5\n", "3 3 2 2\n1 5 9\n3 5 7\n" ]

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

In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one. In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.

1,000

[ { "input": "5 3 0 0\n1 2 3 3 4\n1 3 5", "output": "2\n1 1\n3 2" }, { "input": "3 3 2 2\n1 5 9\n3 5 7", "output": "3\n1 1\n2 2\n3 3" }, { "input": "1 1 0 0\n1\n1", "output": "1\n1 1" }, { "input": "1 1 0 0\n1\n2", "output": "0" }, { "input": "2 3 1 4\n1 5\n1 2 2", "output": "1\n1 1" }, { "input": "20 30 1 4\n1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 4 4 4 5\n1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4 4 4 5 5", "output": "20\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n10 10\n11 11\n12 12\n13 15\n14 16\n15 17\n16 18\n17 19\n18 20\n19 21\n20 22" }, { "input": "33 23 17 2\n1 1 2 2 2 3 3 3 3 3 3 4 4 4 4 4 5 5 5 6 6 7 7 7 8 8 8 8 8 9 9 10 10\n1 1 3 3 4 4 4 5 5 6 6 6 7 8 8 8 8 8 8 9 9 10 10", "output": "23\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n12 10\n13 11\n14 12\n17 13\n20 14\n21 15\n22 16\n23 17\n24 18\n25 19\n26 20\n27 21\n28 22\n29 23" }, { "input": "2 2 1 4\n1 4\n3 6", "output": "2\n1 1\n2 2" }, { "input": "20 20 1 4\n1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 4 4 5 5\n3 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 6 6 7 7", "output": "20\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n10 10\n11 11\n12 12\n13 13\n14 14\n15 15\n16 16\n17 17\n18 18\n19 19\n20 20" }, { "input": "33 23 17 2\n1 1 1 2 3 3 3 3 3 4 4 4 4 5 6 6 6 6 6 6 7 7 7 7 7 8 8 8 8 8 8 10 10\n10 10 10 11 12 12 12 12 12 13 13 13 13 14 15 15 15 15 15 15 16 16 16", "output": "5\n26 1\n27 2\n28 3\n32 4\n33 5" }, { "input": "1 1 1 2\n783266931\n783266932", "output": "1\n1 1" }, { "input": "2 3 1 4\n1 1\n3 3 4", "output": "2\n1 1\n2 2" }, { "input": "20 30 1 4\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2\n3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4", "output": "20\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n10 10\n11 11\n12 12\n13 13\n14 14\n15 15\n16 16\n17 17\n18 18\n19 19\n20 20" }, { "input": "33 23 17 2\n1 1 1 1 1 1 1 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4 4 5 5 5 5 5 5\n10 10 10 10 10 10 10 11 11 11 11 11 11 11 12 12 12 12 12 12 13 13 13", "output": "0" }, { "input": "10 1 1 1\n1 1 1 5 5 7 7 8 8 8\n3", "output": "0" }, { "input": "10 1 2 1\n1 2 5 8 9 9 9 10 10 10\n7", "output": "1\n4 1" }, { "input": "1 1 2 1\n7\n8", "output": "1\n1 1" }, { "input": "1 1 0 2\n9\n7", "output": "0" }, { "input": "2 2 0 2\n2 8\n3 5", "output": "1\n1 1" }, { "input": "2 2 1 0\n5 5\n6 7", "output": "0" }, { "input": "2 2 3 0\n8 9\n1 5", "output": "1\n1 2" } ]

1,637,251,269

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

124

0

n,m,x,y=map(int, input().split()) a=list(map(int,input().split())) b=list(map(int,input().split())) i=0 j=0 lis=[] while(i<n and j<m): if(b[j]<a[i]-x): j+=1 elif(b[j]>a[i]+x): i+=1 else: lis.append([i+1, j+1]) i+=1 j+=1 print(len(lis)) for i in lis: print(*i)

Title: Dress'em in Vests! Time Limit: None seconds Memory Limit: None megabytes Problem Description: The Two-dimensional kingdom is going through hard times... This morning the Three-Dimensional kingdom declared war on the Two-dimensional one. This (possibly armed) conflict will determine the ultimate owner of the straight line. The Two-dimensional kingdom has a regular army of *n* people. Each soldier registered himself and indicated the desired size of the bulletproof vest: the *i*-th soldier indicated size *a**i*. The soldiers are known to be unpretentious, so the command staff assumes that the soldiers are comfortable in any vests with sizes from *a**i*<=-<=*x* to *a**i*<=+<=*y*, inclusive (numbers *x*,<=*y*<=≥<=0 are specified). The Two-dimensional kingdom has *m* vests at its disposal, the *j*-th vest's size equals *b**j*. Help mobilize the Two-dimensional kingdom's army: equip with vests as many soldiers as possible. Each vest can be used only once. The *i*-th soldier can put on the *j*-th vest, if *a**i*<=-<=*x*<=≤<=*b**j*<=≤<=*a**i*<=+<=*y*. Input Specification: The first input line contains four integers *n*, *m*, *x* and *y* (1<=≤<=*n*,<=*m*<=≤<=105, 0<=≤<=*x*,<=*y*<=≤<=109) — the number of soldiers, the number of vests and two numbers that specify the soldiers' unpretentiousness, correspondingly. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) in non-decreasing order, separated by single spaces — the desired sizes of vests. The third line contains *m* integers *b*1,<=*b*2,<=...,<=*b**m* (1<=≤<=*b**j*<=≤<=109) in non-decreasing order, separated by single spaces — the sizes of the available vests. Output Specification: In the first line print a single integer *k* — the maximum number of soldiers equipped with bulletproof vests. In the next *k* lines print *k* pairs, one pair per line, as "*u**i* *v**i*" (without the quotes). Pair (*u**i*, *v**i*) means that soldier number *u**i* must wear vest number *v**i*. Soldiers and vests are numbered starting from one in the order in which they are specified in the input. All numbers of soldiers in the pairs should be pairwise different, all numbers of vests in the pairs also should be pairwise different. You can print the pairs in any order. If there are multiple optimal answers, you are allowed to print any of them. Demo Input: ['5 3 0 0\n1 2 3 3 4\n1 3 5\n', '3 3 2 2\n1 5 9\n3 5 7\n'] Demo Output: ['2\n1 1\n3 2\n', '3\n1 1\n2 2\n3 3\n'] Note: In the first sample you need the vests' sizes to match perfectly: the first soldier gets the first vest (size 1), the third soldier gets the second vest (size 3). This sample allows another answer, which gives the second vest to the fourth soldier instead of the third one. In the second sample the vest size can differ from the desired size by at most 2 sizes, so all soldiers can be equipped.

```python n,m,x,y=map(int, input().split()) a=list(map(int,input().split())) b=list(map(int,input().split())) i=0 j=0 lis=[] while(i<n and j<m): if(b[j]<a[i]-x): j+=1 elif(b[j]>a[i]+x): i+=1 else: lis.append([i+1, j+1]) i+=1 j+=1 print(len(lis)) for i in lis: print(*i) ```

0

570

B

Simple Game

PROGRAMMING

1,300

[ "constructive algorithms", "games", "greedy", "implementation", "math" ]

null

One day Misha and Andrew were playing a very simple game. First, each player chooses an integer in the range from 1 to *n*. Let's assume that Misha chose number *m*, and Andrew chose number *a*. Then, by using a random generator they choose a random integer *c* in the range between 1 and *n* (any integer from 1 to *n* is chosen with the same probability), after which the winner is the player, whose number was closer to *c*. The boys agreed that if *m* and *a* are located on the same distance from *c*, Misha wins. Andrew wants to win very much, so he asks you to help him. You know the number selected by Misha, and number *n*. You need to determine which value of *a* Andrew must choose, so that the probability of his victory is the highest possible. More formally, you need to find such integer *a* (1<=≤<=*a*<=≤<=*n*), that the probability that is maximal, where *c* is the equiprobably chosen integer from 1 to *n* (inclusive).

The first line contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=109) — the range of numbers in the game, and the number selected by Misha respectively.

Print a single number — such value *a*, that probability that Andrew wins is the highest. If there are multiple such values, print the minimum of them.

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

[ "2", "2" ]

In the first sample test: Andrew wins if *c* is equal to 2 or 3. The probability that Andrew wins is 2 / 3. If Andrew chooses *a* = 3, the probability of winning will be 1 / 3. If *a* = 1, the probability of winning is 0. In the second sample test: Andrew wins if *c* is equal to 1 and 2. The probability that Andrew wins is 1 / 2. For other choices of *a* the probability of winning is less.

1,000

[ { "input": "3 1", "output": "2" }, { "input": "4 3", "output": "2" }, { "input": "5 5", "output": "4" }, { "input": "10 5", "output": "6" }, { "input": "20 13", "output": "12" }, { "input": "51 1", "output": "2" }, { "input": "100 50", "output": "51" }, { "input": "100 51", "output": "50" }, { "input": "100 49", "output": "50" }, { "input": "1000000000 1000000000", "output": "999999999" }, { "input": "1000000000 1", "output": "2" }, { "input": "1000000000 100000000", "output": "100000001" }, { "input": "1000000000 500000000", "output": "500000001" }, { "input": "1000000000 123124", "output": "123125" }, { "input": "12412523 125123", "output": "125124" }, { "input": "54645723 432423", "output": "432424" }, { "input": "1 1", "output": "1" }, { "input": "262833325 131416663", "output": "131416662" }, { "input": "477667530 238833766", "output": "238833765" }, { "input": "692501734 346250868", "output": "346250867" }, { "input": "907335939 453667970", "output": "453667969" }, { "input": "746085224 373042613", "output": "373042612" }, { "input": "189520699 94760350", "output": "94760349" }, { "input": "404354904 202177453", "output": "202177452" }, { "input": "619189108 309594555", "output": "309594554" }, { "input": "81813292 40906647", "output": "40906646" }, { "input": "296647497 148323750", "output": "148323749" }, { "input": "511481701 255740851", "output": "255740850" }, { "input": "726315905 363157953", "output": "363157952" }, { "input": "496110970 201868357", "output": "201868358" }, { "input": "710945175 173165570", "output": "173165571" }, { "input": "925779379 720443954", "output": "720443953" }, { "input": "140613583 93171580", "output": "93171579" }, { "input": "355447788 85890184", "output": "85890185" }, { "input": "570281992 291648263", "output": "291648262" }, { "input": "541904957 459371829", "output": "459371828" }, { "input": "756739161 125332525", "output": "125332526" }, { "input": "971573366 216791157", "output": "216791158" }, { "input": "186407570 160453970", "output": "160453969" }, { "input": "401241775 170032078", "output": "170032079" }, { "input": "616075979 207073797", "output": "207073798" }, { "input": "1 1", "output": "1" }, { "input": "2 1", "output": "2" }, { "input": "2 2", "output": "1" }, { "input": "3 1", "output": "2" }, { "input": "3 2", "output": "1" }, { "input": "3 3", "output": "2" }, { "input": "4 1", "output": "2" }, { "input": "4 2", "output": "3" }, { "input": "4 3", "output": "2" }, { "input": "4 4", "output": "3" }, { "input": "5 1", "output": "2" }, { "input": "5 2", "output": "3" }, { "input": "5 3", "output": "2" }, { "input": "5 4", "output": "3" }, { "input": "5 5", "output": "4" }, { "input": "3 2", "output": "1" }, { "input": "7 4", "output": "3" }, { "input": "2 2", "output": "1" }, { "input": "7 3", "output": "4" } ]

1,602,737,210

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

17

93

0

n, m = map (int, input ().split ()) if abs (m - n) > abs (m - 1) : print (m + 1) elif abs (m - n) < abs (m - 1) : print (m - 1) else : print (m)

Title: Simple Game Time Limit: None seconds Memory Limit: None megabytes Problem Description: One day Misha and Andrew were playing a very simple game. First, each player chooses an integer in the range from 1 to *n*. Let's assume that Misha chose number *m*, and Andrew chose number *a*. Then, by using a random generator they choose a random integer *c* in the range between 1 and *n* (any integer from 1 to *n* is chosen with the same probability), after which the winner is the player, whose number was closer to *c*. The boys agreed that if *m* and *a* are located on the same distance from *c*, Misha wins. Andrew wants to win very much, so he asks you to help him. You know the number selected by Misha, and number *n*. You need to determine which value of *a* Andrew must choose, so that the probability of his victory is the highest possible. More formally, you need to find such integer *a* (1<=≤<=*a*<=≤<=*n*), that the probability that is maximal, where *c* is the equiprobably chosen integer from 1 to *n* (inclusive). Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=109) — the range of numbers in the game, and the number selected by Misha respectively. Output Specification: Print a single number — such value *a*, that probability that Andrew wins is the highest. If there are multiple such values, print the minimum of them. Demo Input: ['3 1\n', '4 3\n'] Demo Output: ['2', '2'] Note: In the first sample test: Andrew wins if *c* is equal to 2 or 3. The probability that Andrew wins is 2 / 3. If Andrew chooses *a* = 3, the probability of winning will be 1 / 3. If *a* = 1, the probability of winning is 0. In the second sample test: Andrew wins if *c* is equal to 1 and 2. The probability that Andrew wins is 1 / 2. For other choices of *a* the probability of winning is less.

```python n, m = map (int, input ().split ()) if abs (m - n) > abs (m - 1) : print (m + 1) elif abs (m - n) < abs (m - 1) : print (m - 1) else : print (m) ```

0

515

C

Drazil and Factorial

PROGRAMMING

1,400

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

null

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

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

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

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

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

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

1,000

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

1,674,673,440

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

2

2,000

0

import math n = int(input()) a = input() fac = 1 for i in a: fac *= math.factorial(int(i)) fac2 = fac ans = [] for i in range(2, int(fac ** 0.5) + 1): while fac % i == 0: ans.append(i) fac //= i ans.reverse() rez = 1 c = '' for i in range(len(ans)): rez *= math.factorial(ans[i]) c += str(ans[i]) if rez == fac2: break print(c)

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

```python import math n = int(input()) a = input() fac = 1 for i in a: fac *= math.factorial(int(i)) fac2 = fac ans = [] for i in range(2, int(fac ** 0.5) + 1): while fac % i == 0: ans.append(i) fac //= i ans.reverse() rez = 1 c = '' for i in range(len(ans)): rez *= math.factorial(ans[i]) c += str(ans[i]) if rez == fac2: break print(c) ```

0

1,004

B

Sonya and Exhibition

PROGRAMMING

1,300

[ "constructive algorithms", "greedy", "implementation", "math" ]

null

Sonya decided to organize an exhibition of flowers. Since the girl likes only roses and lilies, she decided that only these two kinds of flowers should be in this exhibition. There are $n$ flowers in a row in the exhibition. Sonya can put either a rose or a lily in the $i$-th position. Thus each of $n$ positions should contain exactly one flower: a rose or a lily. She knows that exactly $m$ people will visit this exhibition. The $i$-th visitor will visit all flowers from $l_i$ to $r_i$ inclusive. The girl knows that each segment has its own beauty that is equal to the product of the number of roses and the number of lilies. Sonya wants her exhibition to be liked by a lot of people. That is why she wants to put the flowers in such way that the sum of beauties of all segments would be maximum possible.

The first line contains two integers $n$ and $m$ ($1\leq n, m\leq 10^3$) — the number of flowers and visitors respectively. Each of the next $m$ lines contains two integers $l_i$ and $r_i$ ($1\leq l_i\leq r_i\leq n$), meaning that $i$-th visitor will visit all flowers from $l_i$ to $r_i$ inclusive.

Print the string of $n$ characters. The $i$-th symbol should be «0» if you want to put a rose in the $i$-th position, otherwise «1» if you want to put a lily. If there are multiple answers, print any.

[ "5 3\n1 3\n2 4\n2 5\n", "6 3\n5 6\n1 4\n4 6\n" ]

[ "01100", "110010" ]

In the first example, Sonya can put roses in the first, fourth, and fifth positions, and lilies in the second and third positions; - in the segment $[1\ldots3]$, there are one rose and two lilies, so the beauty is equal to $1\cdot 2=2$; - in the segment $[2\ldots4]$, there are one rose and two lilies, so the beauty is equal to $1\cdot 2=2$; - in the segment $[2\ldots5]$, there are two roses and two lilies, so the beauty is equal to $2\cdot 2=4$. The total beauty is equal to $2+2+4=8$. In the second example, Sonya can put roses in the third, fourth, and sixth positions, and lilies in the first, second, and fifth positions; - in the segment $[5\ldots6]$, there are one rose and one lily, so the beauty is equal to $1\cdot 1=1$; - in the segment $[1\ldots4]$, there are two roses and two lilies, so the beauty is equal to $2\cdot 2=4$; - in the segment $[4\ldots6]$, there are two roses and one lily, so the beauty is equal to $2\cdot 1=2$. The total beauty is equal to $1+4+2=7$.

1,000

[ { "input": "5 3\n1 3\n2 4\n2 5", "output": "01010" }, { "input": "6 3\n5 6\n1 4\n4 6", "output": "010101" }, { "input": "10 4\n3 3\n1 6\n9 9\n10 10", "output": "0101010101" }, { "input": "1 1\n1 1", "output": "0" }, { "input": "1000 10\n3 998\n2 1000\n1 999\n2 1000\n3 998\n2 1000\n3 998\n1 1000\n2 1000\n3 999", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "1000 20\n50 109\n317 370\n710 770\n440 488\n711 757\n236 278\n314 355\n131 190\n115 162\n784 834\n16 56\n677 730\n802 844\n632 689\n23 74\n647 702\n930 986\n926 983\n769 822\n508 558", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "1000 10\n138 238\n160 260\n716 816\n504 604\n98 198\n26 126\n114 214\n217 317\n121 221\n489 589", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "1000 5\n167 296\n613 753\n650 769\n298 439\n71 209", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "1000 5\n349 415\n714 773\n125 179\n1 80\n148 242", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "914 10\n587 646\n770 843\n825 875\n439 485\n465 521\n330 387\n405 480\n477 521\n336 376\n715 771", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "571 10\n13 94\n450 510\n230 293\n302 375\n304 354\n421 504\n24 87\n122 181\n221 296\n257 307", "output": "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010..." }, { "input": "6 2\n1 6\n1 4", "output": "010101" }, { "input": "2 1\n1 2", "output": "01" } ]

1,530,809,794

1,294

Python 3

OK

TESTS

27

109

0

a=[int(q) for q in input().strip().split()] b=[] for k in range(a[1]): t=input() for k in range(int(a[0]/2)): b.append('10') if int(a[0])%2==1: b.append('1') print(''.join(b))

Title: Sonya and Exhibition Time Limit: None seconds Memory Limit: None megabytes Problem Description: Sonya decided to organize an exhibition of flowers. Since the girl likes only roses and lilies, she decided that only these two kinds of flowers should be in this exhibition. There are $n$ flowers in a row in the exhibition. Sonya can put either a rose or a lily in the $i$-th position. Thus each of $n$ positions should contain exactly one flower: a rose or a lily. She knows that exactly $m$ people will visit this exhibition. The $i$-th visitor will visit all flowers from $l_i$ to $r_i$ inclusive. The girl knows that each segment has its own beauty that is equal to the product of the number of roses and the number of lilies. Sonya wants her exhibition to be liked by a lot of people. That is why she wants to put the flowers in such way that the sum of beauties of all segments would be maximum possible. Input Specification: The first line contains two integers $n$ and $m$ ($1\leq n, m\leq 10^3$) — the number of flowers and visitors respectively. Each of the next $m$ lines contains two integers $l_i$ and $r_i$ ($1\leq l_i\leq r_i\leq n$), meaning that $i$-th visitor will visit all flowers from $l_i$ to $r_i$ inclusive. Output Specification: Print the string of $n$ characters. The $i$-th symbol should be «0» if you want to put a rose in the $i$-th position, otherwise «1» if you want to put a lily. If there are multiple answers, print any. Demo Input: ['5 3\n1 3\n2 4\n2 5\n', '6 3\n5 6\n1 4\n4 6\n'] Demo Output: ['01100', '110010'] Note: In the first example, Sonya can put roses in the first, fourth, and fifth positions, and lilies in the second and third positions; - in the segment $[1\ldots3]$, there are one rose and two lilies, so the beauty is equal to $1\cdot 2=2$; - in the segment $[2\ldots4]$, there are one rose and two lilies, so the beauty is equal to $1\cdot 2=2$; - in the segment $[2\ldots5]$, there are two roses and two lilies, so the beauty is equal to $2\cdot 2=4$. The total beauty is equal to $2+2+4=8$. In the second example, Sonya can put roses in the third, fourth, and sixth positions, and lilies in the first, second, and fifth positions; - in the segment $[5\ldots6]$, there are one rose and one lily, so the beauty is equal to $1\cdot 1=1$; - in the segment $[1\ldots4]$, there are two roses and two lilies, so the beauty is equal to $2\cdot 2=4$; - in the segment $[4\ldots6]$, there are two roses and one lily, so the beauty is equal to $2\cdot 1=2$. The total beauty is equal to $1+4+2=7$.

```python a=[int(q) for q in input().strip().split()] b=[] for k in range(a[1]): t=input() for k in range(int(a[0]/2)): b.append('10') if int(a[0])%2==1: b.append('1') print(''.join(b)) ```

3

955

B

Not simply beatiful strings

PROGRAMMING

1,400

[ "implementation" ]

null

Let's call a string adorable if its letters can be realigned in such a way that they form two consequent groups of equal symbols (note that different groups must contain different symbols). For example, ababa is adorable (you can transform it to aaabb, where the first three letters form a group of *a*-s and others — a group of *b*-s), but cccc is not since in each possible consequent partition letters in these two groups coincide. You're given a string *s*. Check whether it can be split into two non-empty subsequences such that the strings formed by these subsequences are adorable. Here a subsequence is an arbitrary set of indexes of the string.

The only line contains *s* (1<=≤<=|*s*|<=≤<=105) consisting of lowercase latin letters.

Print «Yes» if the string can be split according to the criteria above or «No» otherwise. Each letter can be printed in arbitrary case.

[ "ababa\n", "zzcxx\n", "yeee\n" ]

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

In sample case two zzcxx can be split into subsequences zc and zxx each of which is adorable. There's no suitable partition in sample case three.

1,000

[ { "input": "ababa", "output": "Yes" }, { "input": "zzcxx", "output": "Yes" }, { "input": "yeee", "output": "No" }, { "input": "a", "output": "No" }, { "input": "bbab", "output": "No" }, { "input": "abcd", "output": "Yes" }, { "input": "abc", "output": "No" }, { "input": "abcdaaaa", "output": "Yes" }, { "input": "aaaaaaaaaaaaaaa", "output": "No" }, { "input": "adb", "output": "No" }, { "input": "dcccbad", "output": "Yes" }, { "input": "bcbccccccca", "output": "Yes" }, { "input": "abcdefgh", "output": "No" }, { "input": "aabcdef", "output": "No" }, { "input": "aabc", "output": "Yes" }, { "input": "ssab", "output": "Yes" }, { "input": "ccdd", "output": "Yes" }, { "input": "abcc", "output": "Yes" }, { "input": "ab", "output": "No" }, { "input": "abcde", "output": "No" }, { "input": "aa", "output": "No" }, { "input": "aaabbb", "output": "Yes" }, { "input": "bbbba", "output": "No" }, { "input": "abbbc", "output": "Yes" }, { "input": "baabaa", "output": "Yes" }, { "input": "abacabadde", "output": "No" }, { "input": "aabbcc", "output": "Yes" }, { "input": "abbc", "output": "Yes" }, { "input": "aaaaaaabbbbbbcder", "output": "No" }, { "input": "aabb", "output": "Yes" }, { "input": "aabbccddee", "output": "No" }, { "input": "abca", "output": "Yes" }, { "input": "aaabbbccc", "output": "Yes" } ]

1,521,827,189

4,289

Python 3

WRONG_ANSWER

TESTS

8

93

7,270,400

s = input() if len(set(s)) == 1: print('No') elif len(set(s)) == 2: if(s.count(list(set(s))[0]) > 1 and s.count(list(set(s))[1]) > 1): print('Yes') else: print('No') elif len(set(s)) == 3: if any(s.count(x) > 1 for x in set(s)): print('Yes') elif len(set(s)) == 4: print('Yes') else: print('No')

Title: Not simply beatiful strings Time Limit: None seconds Memory Limit: None megabytes Problem Description: Let's call a string adorable if its letters can be realigned in such a way that they form two consequent groups of equal symbols (note that different groups must contain different symbols). For example, ababa is adorable (you can transform it to aaabb, where the first three letters form a group of *a*-s and others — a group of *b*-s), but cccc is not since in each possible consequent partition letters in these two groups coincide. You're given a string *s*. Check whether it can be split into two non-empty subsequences such that the strings formed by these subsequences are adorable. Here a subsequence is an arbitrary set of indexes of the string. Input Specification: The only line contains *s* (1<=≤<=|*s*|<=≤<=105) consisting of lowercase latin letters. Output Specification: Print «Yes» if the string can be split according to the criteria above or «No» otherwise. Each letter can be printed in arbitrary case. Demo Input: ['ababa\n', 'zzcxx\n', 'yeee\n'] Demo Output: ['Yes\n', 'Yes\n', 'No\n'] Note: In sample case two zzcxx can be split into subsequences zc and zxx each of which is adorable. There's no suitable partition in sample case three.

```python s = input() if len(set(s)) == 1: print('No') elif len(set(s)) == 2: if(s.count(list(set(s))[0]) > 1 and s.count(list(set(s))[1]) > 1): print('Yes') else: print('No') elif len(set(s)) == 3: if any(s.count(x) > 1 for x in set(s)): print('Yes') elif len(set(s)) == 4: print('Yes') else: print('No') ```

0

144

A

Arrival of the General

PROGRAMMING

800

[ "implementation" ]

null

A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all *n* squad soldiers to line up on the parade ground. By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important. For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong. Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct.

The first input line contains the only integer *n* (2<=≤<=*n*<=≤<=100) which represents the number of soldiers in the line. The second line contains integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers *a*1,<=*a*2,<=...,<=*a**n* are not necessarily different.

Print the only integer — the minimum number of seconds the colonel will need to form a line-up the general will like.

[ "4\n33 44 11 22\n", "7\n10 10 58 31 63 40 76\n" ]

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

In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11). In the second sample the colonel may swap the soldiers in the following sequence: 1. (10, 10, 58, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 76, 40) 1. (10, 58, 10, 31, 76, 63, 40) 1. (10, 58, 31, 10, 76, 63, 40) 1. (10, 58, 31, 76, 10, 63, 40) 1. (10, 58, 31, 76, 63, 10, 40) 1. (10, 58, 76, 31, 63, 10, 40) 1. (10, 76, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 40, 10)

500

[ { "input": "4\n33 44 11 22", "output": "2" }, { "input": "7\n10 10 58 31 63 40 76", "output": "10" }, { "input": "2\n88 89", "output": "1" }, { "input": "5\n100 95 100 100 88", "output": "0" }, { "input": "7\n48 48 48 48 45 45 45", "output": "0" }, { "input": "10\n68 47 67 29 63 71 71 65 54 56", "output": "10" }, { "input": "15\n77 68 96 60 92 75 61 60 66 79 80 65 60 95 92", "output": "4" }, { "input": "3\n1 2 1", "output": "1" }, { "input": "20\n30 30 30 14 30 14 30 30 30 14 30 14 14 30 14 14 30 14 14 14", "output": "0" }, { "input": "35\n37 41 46 39 47 39 44 47 44 42 44 43 47 39 46 39 38 42 39 37 40 44 41 42 41 42 39 42 36 36 42 36 42 42 42", "output": "7" }, { "input": "40\n99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 98 99 99 99 99 99 99 99 99 100 99 99 99 99 99 99", "output": "47" }, { "input": "50\n48 52 44 54 53 56 62 49 39 41 53 39 40 64 53 50 62 48 40 52 51 48 40 52 61 62 62 61 48 64 55 57 56 40 48 58 41 60 60 56 64 50 64 45 48 45 46 63 59 57", "output": "50" }, { "input": "57\n7 24 17 19 6 19 10 11 12 22 14 5 5 11 13 10 24 19 24 24 24 11 21 20 4 14 24 24 18 13 24 3 20 3 3 3 3 9 3 9 22 22 16 3 3 3 15 11 3 3 8 17 10 13 3 14 13", "output": "3" }, { "input": "65\n58 50 35 44 35 37 36 58 38 36 58 56 56 49 48 56 58 43 40 44 52 44 58 58 57 50 43 35 55 39 38 49 53 56 50 42 41 56 34 57 49 38 34 51 56 38 58 40 53 46 48 34 38 43 49 49 58 56 41 43 44 34 38 48 36", "output": "3" }, { "input": "69\n70 48 49 48 49 71 48 53 55 69 48 53 54 58 53 63 48 48 69 67 72 75 71 75 74 74 57 63 65 60 48 48 65 48 48 51 50 49 62 53 76 68 76 56 76 76 64 76 76 57 61 76 73 51 59 76 65 50 69 50 76 67 76 63 62 74 74 58 73", "output": "73" }, { "input": "75\n70 65 64 71 71 64 71 64 68 71 65 64 65 68 71 66 66 69 68 63 69 65 71 69 68 68 71 67 71 65 65 65 71 71 65 69 63 66 62 67 64 63 62 64 67 65 62 69 62 64 69 62 67 64 67 70 64 63 64 64 69 62 62 64 70 62 62 68 67 69 62 64 66 70 68", "output": "7" }, { "input": "84\n92 95 84 85 94 80 90 86 80 92 95 84 86 83 86 83 93 91 95 92 84 88 82 84 84 84 80 94 93 80 94 80 95 83 85 80 95 95 80 84 86 92 83 81 90 87 81 89 92 93 80 87 90 85 93 85 93 94 93 89 94 83 93 91 80 83 90 94 95 80 95 92 85 84 93 94 94 82 91 95 95 89 85 94", "output": "15" }, { "input": "90\n86 87 72 77 82 71 75 78 61 67 79 90 64 94 94 74 85 87 73 76 71 71 60 69 77 73 76 80 82 57 62 57 57 83 76 72 75 87 72 94 77 85 59 82 86 69 62 80 95 73 83 94 79 85 91 68 85 74 93 95 68 75 89 93 83 78 95 78 83 77 81 85 66 92 63 65 75 78 67 91 77 74 59 86 77 76 90 67 70 64", "output": "104" }, { "input": "91\n94 98 96 94 95 98 98 95 98 94 94 98 95 95 99 97 97 94 95 98 94 98 96 98 96 98 97 95 94 94 94 97 94 96 98 98 98 94 96 95 94 95 97 97 97 98 94 98 96 95 98 96 96 98 94 97 96 98 97 95 97 98 94 95 94 94 97 94 96 97 97 93 94 95 95 94 96 98 97 96 94 98 98 96 96 96 96 96 94 96 97", "output": "33" }, { "input": "92\n44 28 32 29 41 41 36 39 40 39 41 35 41 28 35 27 41 34 28 38 43 43 41 38 27 26 28 36 30 29 39 32 35 35 32 30 39 30 37 27 41 41 28 30 43 31 35 33 36 28 44 40 41 35 31 42 37 38 37 34 39 40 27 40 33 33 44 43 34 33 34 34 35 38 38 37 30 39 35 41 45 42 41 32 33 33 31 30 43 41 43 43", "output": "145" }, { "input": "93\n46 32 52 36 39 30 57 63 63 30 32 44 27 59 46 38 40 45 44 62 35 36 51 48 39 58 36 51 51 51 48 58 59 36 29 35 31 49 64 60 34 38 42 56 33 42 52 31 63 34 45 51 35 45 33 53 33 62 31 38 66 29 51 54 28 61 32 45 57 41 36 34 47 36 31 28 67 48 52 46 32 40 64 58 27 53 43 57 34 66 43 39 26", "output": "76" }, { "input": "94\n56 55 54 31 32 42 46 29 24 54 40 40 20 45 35 56 32 33 51 39 26 56 21 56 51 27 29 39 56 52 54 43 43 55 48 51 44 49 52 49 23 19 19 28 20 26 45 33 35 51 42 36 25 25 38 23 21 35 54 50 41 20 37 28 42 20 22 43 37 34 55 21 24 38 19 41 45 34 19 33 44 54 38 31 23 53 35 32 47 40 39 31 20 34", "output": "15" }, { "input": "95\n57 71 70 77 64 64 76 81 81 58 63 75 81 77 71 71 71 60 70 70 69 67 62 64 78 64 69 62 76 76 57 70 68 77 70 68 73 77 79 73 60 57 69 60 74 65 58 75 75 74 73 73 65 75 72 57 81 62 62 70 67 58 76 57 79 81 68 64 58 77 70 59 79 64 80 58 71 59 81 71 80 64 78 80 78 65 70 68 78 80 57 63 64 76 81", "output": "11" }, { "input": "96\n96 95 95 95 96 97 95 97 96 95 98 96 97 95 98 96 98 96 98 96 98 95 96 95 95 95 97 97 95 95 98 98 95 96 96 95 97 96 98 96 95 97 97 95 97 97 95 94 96 96 97 96 97 97 96 94 94 97 95 95 95 96 95 96 95 97 97 95 97 96 95 94 97 97 97 96 97 95 96 94 94 95 97 94 94 97 97 97 95 97 97 95 94 96 95 95", "output": "13" }, { "input": "97\n14 15 12 12 13 15 12 15 12 12 12 12 12 14 15 15 13 12 15 15 12 12 12 13 14 15 15 13 14 15 14 14 14 14 12 13 12 13 13 12 15 12 13 13 15 12 15 13 12 13 13 13 14 13 12 15 14 13 14 15 13 14 14 13 14 12 15 12 14 12 13 14 15 14 13 15 13 12 15 15 15 13 15 15 13 14 16 16 16 13 15 13 15 14 15 15 15", "output": "104" }, { "input": "98\n37 69 35 70 58 69 36 47 41 63 60 54 49 35 55 50 35 53 52 43 35 41 40 49 38 35 48 70 42 35 35 65 56 54 44 59 59 48 51 49 59 67 35 60 69 35 58 50 35 44 48 69 41 58 44 45 35 47 70 61 49 47 37 39 35 51 44 70 72 65 36 41 63 63 48 66 45 50 50 71 37 52 72 67 72 39 72 39 36 64 48 72 69 49 45 72 72 67", "output": "100" }, { "input": "99\n31 31 16 15 19 31 19 22 29 27 12 22 28 30 25 33 26 25 19 22 34 21 17 33 31 22 16 26 22 30 31 17 13 33 13 17 28 25 18 33 27 22 31 22 13 27 20 22 23 15 24 32 29 13 16 20 32 33 14 33 19 27 16 28 25 17 17 28 18 26 32 33 19 23 30 13 14 23 24 28 14 28 22 20 30 14 24 23 17 29 18 28 29 21 28 18 16 24 32", "output": "107" }, { "input": "100\n37 54 39 29 32 49 21 13 34 21 16 42 34 27 16 26 7 34 51 9 11 27 16 40 36 7 48 52 30 42 42 52 51 11 32 26 6 7 28 54 48 51 6 54 42 20 51 48 46 4 4 31 47 6 9 16 8 23 36 50 49 30 47 37 45 24 48 26 8 50 18 24 27 13 39 7 37 34 5 43 42 19 34 23 52 38 35 6 29 11 53 49 21 29 36 22 45 33 51 22", "output": "50" }, { "input": "100\n41 5 20 23 5 47 28 28 64 5 12 14 34 56 22 48 6 52 39 55 62 40 24 54 39 28 56 27 35 51 14 24 38 10 55 20 39 62 52 2 30 55 49 48 15 23 59 44 31 28 66 29 62 59 31 13 28 12 50 45 41 47 29 27 64 66 14 39 62 22 44 63 24 5 63 17 42 7 25 41 49 33 31 51 63 3 37 66 19 9 2 40 16 45 56 21 34 29 39 61", "output": "59" }, { "input": "100\n66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95", "output": "99" }, { "input": "100\n81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10", "output": "0" }, { "input": "3\n2 1 2", "output": "1" }, { "input": "2\n100 99", "output": "0" }, { "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": "197" }, { "input": "100\n87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87", "output": "0" }, { "input": "100\n100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1", "output": "0" }, { "input": "2\n1 1", "output": "0" }, { "input": "3\n2 2 2", "output": "0" }, { "input": "3\n1 3 2", "output": "2" } ]

1,689,160,035

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

60

0

n = int(input()) a = list(map(int, input().split())) min_val = a[0] min_index = 0 max_val = a[0] max_index = 0 for i in range(n): if min_val >= a[i]: min_val = a[i] min_index = i if max_val < a[i]: max_val = a[i] max_index = i if min_index < max_index: min_index = (n - 1) - min_index print(min_index + max_index - 1) else: min_index = (n - 1) - min_index

Title: Arrival of the General Time Limit: None seconds Memory Limit: None megabytes Problem Description: A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all *n* squad soldiers to line up on the parade ground. By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important. For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong. Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct. Input Specification: The first input line contains the only integer *n* (2<=≤<=*n*<=≤<=100) which represents the number of soldiers in the line. The second line contains integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers *a*1,<=*a*2,<=...,<=*a**n* are not necessarily different. Output Specification: Print the only integer — the minimum number of seconds the colonel will need to form a line-up the general will like. Demo Input: ['4\n33 44 11 22\n', '7\n10 10 58 31 63 40 76\n'] Demo Output: ['2\n', '10\n'] Note: In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11). In the second sample the colonel may swap the soldiers in the following sequence: 1. (10, 10, 58, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 76, 40) 1. (10, 58, 10, 31, 76, 63, 40) 1. (10, 58, 31, 10, 76, 63, 40) 1. (10, 58, 31, 76, 10, 63, 40) 1. (10, 58, 31, 76, 63, 10, 40) 1. (10, 58, 76, 31, 63, 10, 40) 1. (10, 76, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 40, 10)

```python n = int(input()) a = list(map(int, input().split())) min_val = a[0] min_index = 0 max_val = a[0] max_index = 0 for i in range(n): if min_val >= a[i]: min_val = a[i] min_index = i if max_val < a[i]: max_val = a[i] max_index = i if min_index < max_index: min_index = (n - 1) - min_index print(min_index + max_index - 1) else: min_index = (n - 1) - min_index ```

0

409

H

A + B Strikes Back

PROGRAMMING

1,500

[ "*special", "brute force", "constructive algorithms", "dsu", "implementation" ]

null

A + B is often used as an example of the easiest problem possible to show some contest platform. However, some scientists have observed that sometimes this problem is not so easy to get accepted. Want to try?

The input contains two integers *a* and *b* (0<=≤<=*a*,<=*b*<=≤<=103), separated by a single space.

Output the sum of the given integers.

[ "5 14\n", "381 492\n" ]

[ "19\n", "873\n" ]

none

0

[ { "input": "5 14", "output": "19" }, { "input": "381 492", "output": "873" }, { "input": "536 298", "output": "834" }, { "input": "143 522", "output": "665" }, { "input": "433 126", "output": "559" }, { "input": "723 350", "output": "1073" }, { "input": "632 264", "output": "896" }, { "input": "923 488", "output": "1411" }, { "input": "522 92", "output": "614" }, { "input": "953 553", "output": "1506" }, { "input": "242 86", "output": "328" }, { "input": "151 691", "output": "842" }, { "input": "441 915", "output": "1356" }, { "input": "740 519", "output": "1259" }, { "input": "339 433", "output": "772" }, { "input": "629 657", "output": "1286" }, { "input": "538 261", "output": "799" }, { "input": "828 485", "output": "1313" }, { "input": "117 399", "output": "516" }, { "input": "399 280", "output": "679" } ]

1,666,008,229

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

0

a = int(input()) b = int(input()) for i in range(a): b+=1 print(b)

Title: A + B Strikes Back Time Limit: None seconds Memory Limit: None megabytes Problem Description: A + B is often used as an example of the easiest problem possible to show some contest platform. However, some scientists have observed that sometimes this problem is not so easy to get accepted. Want to try? Input Specification: The input contains two integers *a* and *b* (0<=≤<=*a*,<=*b*<=≤<=103), separated by a single space. Output Specification: Output the sum of the given integers. Demo Input: ['5 14\n', '381 492\n'] Demo Output: ['19\n', '873\n'] Note: none

```python a = int(input()) b = int(input()) for i in range(a): b+=1 print(b) ```

0

832

A

Sasha and Sticks

PROGRAMMING

800

[ "games", "math" ]

null

It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends. Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws *n* sticks in a row. After that the players take turns crossing out exactly *k* sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than *k* sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.

The first line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1018, *k*<=≤<=*n*) — the number of sticks drawn by Sasha and the number *k* — the number of sticks to be crossed out on each turn.

If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes). You can print each letter in arbitrary case (upper of lower).

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

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

In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins. In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.

500

[ { "input": "1 1", "output": "YES" }, { "input": "10 4", "output": "NO" }, { "input": "251656215122324104 164397544865601257", "output": "YES" }, { "input": "963577813436662285 206326039287271924", "output": "NO" }, { "input": "1000000000000000000 1", "output": "NO" }, { "input": "253308697183523656 25332878317796706", "output": "YES" }, { "input": "669038685745448997 501718093668307460", "output": "YES" }, { "input": "116453141993601660 87060381463547965", "output": "YES" }, { "input": "766959657 370931668", "output": "NO" }, { "input": "255787422422806632 146884995820359999", "output": "YES" }, { "input": "502007866464507926 71266379084204128", "output": "YES" }, { "input": "257439908778973480 64157133126869976", "output": "NO" }, { "input": "232709385 91708542", "output": "NO" }, { "input": "252482458300407528 89907711721009125", "output": "NO" }, { "input": "6 2", "output": "YES" }, { "input": "6 3", "output": "NO" }, { "input": "6 4", "output": "YES" }, { "input": "6 5", "output": "YES" }, { "input": "6 6", "output": "YES" }, { "input": "258266151957056904 30153168463725364", "output": "NO" }, { "input": "83504367885565783 52285355047292458", "output": "YES" }, { "input": "545668929424440387 508692735816921376", "output": "YES" }, { "input": "547321411485639939 36665750286082900", "output": "NO" }, { "input": "548973893546839491 183137237979822911", "output": "NO" }, { "input": "544068082 193116851", "output": "NO" }, { "input": "871412474 749817171", "output": "YES" }, { "input": "999999999 1247", "output": "NO" }, { "input": "851941088 712987048", "output": "YES" }, { "input": "559922900 418944886", "output": "YES" }, { "input": "293908937 37520518", "output": "YES" }, { "input": "650075786 130049650", "output": "NO" }, { "input": "1000000000 1000000000", "output": "YES" }, { "input": "548147654663723363 107422751713800746", "output": "YES" }, { "input": "828159210 131819483", "output": "NO" }, { "input": "6242634 4110365", "output": "YES" }, { "input": "458601973 245084155", "output": "YES" }, { "input": "349593257 18089089", "output": "YES" }, { "input": "814768821 312514745", "output": "NO" }, { "input": "697884949 626323363", "output": "YES" }, { "input": "667011589 54866795", "output": "NO" }, { "input": "1000000000000000000 2", "output": "NO" }, { "input": "1000000000000000000 3", "output": "YES" }, { "input": "1000000000000000000 4", "output": "NO" }, { "input": "999999999999999 1", "output": "YES" }, { "input": "17 4", "output": "NO" }, { "input": "2 2", "output": "YES" }, { "input": "1000000000000000 2", "output": "NO" }, { "input": "12 4", "output": "YES" }, { "input": "6 1", "output": "NO" }, { "input": "2 1", "output": "NO" }, { "input": "10000000005 1", "output": "YES" }, { "input": "10000000000000009 2", "output": "NO" }, { "input": "12457895452123 1", "output": "YES" }, { "input": "999999999999999999 9", "output": "YES" }, { "input": "1000000000000 3", "output": "YES" }, { "input": "13099714659575475 6549849616514894", "output": "NO" }, { "input": "100000000000000001 1", "output": "YES" }, { "input": "825175814723458 324", "output": "YES" }, { "input": "20 4", "output": "YES" }, { "input": "100000176877 4", "output": "YES" }, { "input": "100000 3", "output": "YES" }, { "input": "946744073709551614 10", "output": "YES" } ]

1,571,478,849

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

93

0

s,l=map(int, input() .split()) P=s//l if P%2 == 0: print("YES") else: print("NO")

Title: Sasha and Sticks Time Limit: None seconds Memory Limit: None megabytes Problem Description: It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends. Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws *n* sticks in a row. After that the players take turns crossing out exactly *k* sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than *k* sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him. Input Specification: The first line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1018, *k*<=≤<=*n*) — the number of sticks drawn by Sasha and the number *k* — the number of sticks to be crossed out on each turn. Output Specification: If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes). You can print each letter in arbitrary case (upper of lower). Demo Input: ['1 1\n', '10 4\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins. In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.

```python s,l=map(int, input() .split()) P=s//l if P%2 == 0: print("YES") else: print("NO") ```

0

721

B

Passwords

PROGRAMMING

1,100

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

null

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

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

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

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

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

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

1,000

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

1,604,295,739

2,147,483,647

PyPy 3

OK

TESTS

66

140

0

n, k = map(int, input().split()) a = [0] * n for i in range(n): a[i] = len(input()) rp = len(input()) a = sorted(a) c = a.index(rp) + 1 b = n - a[::-1].index(rp) minatemps = c + (c - 1) // k * 5 maxatemps = b + (b - 1) // k * 5 print(minatemps, maxatemps)

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

```python n, k = map(int, input().split()) a = [0] * n for i in range(n): a[i] = len(input()) rp = len(input()) a = sorted(a) c = a.index(rp) + 1 b = n - a[::-1].index(rp) minatemps = c + (c - 1) // k * 5 maxatemps = b + (b - 1) // k * 5 print(minatemps, maxatemps) ```

3

285

C

Building Permutation

PROGRAMMING

1,200

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

null

Permutation *p* is an ordered set of integers *p*1,<=<=*p*2,<=<=...,<=<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. We'll denote the *i*-th element of permutation *p* as *p**i*. We'll call number *n* the size or the length of permutation *p*1,<=<=*p*2,<=<=...,<=<=*p**n*. You have a sequence of integers *a*1,<=*a*2,<=...,<=*a**n*. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.

The first line contains integer *n* (1<=≤<=*n*<=≤<=3·105) — the size of the sought permutation. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109).

Print a single number — the minimum number of moves. Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

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

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

In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1). In the second sample you need 6 moves to build permutation (1, 3, 2).

1,500

[ { "input": "2\n3 0", "output": "2" }, { "input": "3\n-1 -1 2", "output": "6" }, { "input": "5\n-3 5 -3 3 3", "output": "10" }, { "input": "10\n9 6 -2 4 1 1 1 9 6 2", "output": "18" }, { "input": "9\n2 0 0 6 5 4 1 9 3", "output": "15" }, { "input": "100\n-77 57 -95 -23 53 -28 82 -83 38 -73 85 28 25 6 -43 4 -10 -30 -9 -92 14 34 -93 61 36 -100 90 -68 28 16 100 -3 97 30 36 -55 62 -62 53 74 -50 -23 67 11 22 -30 -19 83 7 84 43 90 -65 -75 -15 97 90 15 66 2 13 -91 91 -44 46 51 51 -58 95 77 20 30 76 79 91 60 76 2 82 42 -93 94 -57 88 65 -95 -66 100 -9 33 -67 54 -99 97 53 13 54 66 60 -48", "output": "3459" } ]

1,588,264,039

2,147,483,647

Python 3

OK

TESTS

33

592

24,883,200

n=int(input()) a=list(map(int,input().split())) a.sort() c=0 for i in range(n): c+=max(a[i],i+1)-min(a[i],i+1) print(c) a.clear()

Title: Building Permutation Time Limit: None seconds Memory Limit: None megabytes Problem Description: Permutation *p* is an ordered set of integers *p*1,<=<=*p*2,<=<=...,<=<=*p**n*, consisting of *n* distinct positive integers, each of them doesn't exceed *n*. We'll denote the *i*-th element of permutation *p* as *p**i*. We'll call number *n* the size or the length of permutation *p*1,<=<=*p*2,<=<=...,<=<=*p**n*. You have a sequence of integers *a*1,<=*a*2,<=...,<=*a**n*. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=3·105) — the size of the sought permutation. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109). Output Specification: Print a single number — the minimum number of moves. Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. Demo Input: ['2\n3 0\n', '3\n-1 -1 2\n'] Demo Output: ['2\n', '6\n'] Note: In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1). In the second sample you need 6 moves to build permutation (1, 3, 2).

```python n=int(input()) a=list(map(int,input().split())) a.sort() c=0 for i in range(n): c+=max(a[i],i+1)-min(a[i],i+1) print(c) a.clear() ```

3

828

A

Restaurant Tables

PROGRAMMING

1,200

[ "implementation" ]

null

In a small restaurant there are *a* tables for one person and *b* tables for two persons. It it known that *n* groups of people come today, each consisting of one or two people. If a group consist of one person, it is seated at a vacant one-seater table. If there are none of them, it is seated at a vacant two-seater table. If there are none of them, it is seated at a two-seater table occupied by single person. If there are still none of them, the restaurant denies service to this group. If a group consist of two people, it is seated at a vacant two-seater table. If there are none of them, the restaurant denies service to this group. You are given a chronological order of groups coming. You are to determine the total number of people the restaurant denies service to.

The first line contains three integers *n*, *a* and *b* (1<=≤<=*n*<=≤<=2·105, 1<=≤<=*a*,<=*b*<=≤<=2·105) — the number of groups coming to the restaurant, the number of one-seater and the number of two-seater tables. The second line contains a sequence of integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=2) — the description of clients in chronological order. If *t**i* is equal to one, then the *i*-th group consists of one person, otherwise the *i*-th group consists of two people.

Print the total number of people the restaurant denies service to.

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

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

In the first example the first group consists of one person, it is seated at a vacant one-seater table. The next group occupies a whole two-seater table. The third group consists of one person, it occupies one place at the remaining two-seater table. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, all clients are served. In the second example the first group consists of one person, it is seated at the vacant one-seater table. The next group consists of one person, it occupies one place at the two-seater table. It's impossible to seat the next group of two people, so the restaurant denies service to them. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, the restaurant denies service to 2 clients.

500

[ { "input": "4 1 2\n1 2 1 1", "output": "0" }, { "input": "4 1 1\n1 1 2 1", "output": "2" }, { "input": "1 1 1\n1", "output": "0" }, { "input": "2 1 2\n2 2", "output": "0" }, { "input": "5 1 3\n1 2 2 2 1", "output": "1" }, { "input": "7 6 1\n1 1 1 1 1 1 1", "output": "0" }, { "input": "10 2 1\n2 1 2 2 2 2 1 2 1 2", "output": "13" }, { "input": "20 4 3\n2 2 2 2 2 2 2 2 1 2 1 1 2 2 1 2 2 2 1 2", "output": "25" }, { "input": "1 1 1\n1", "output": "0" }, { "input": "1 1 1\n2", "output": "0" }, { "input": "1 200000 200000\n2", "output": "0" }, { "input": "30 10 10\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2", "output": "20" }, { "input": "4 1 2\n1 1 1 2", "output": "2" }, { "input": "6 2 3\n1 2 1 1 1 2", "output": "2" }, { "input": "6 1 4\n1 1 1 1 1 2", "output": "2" }, { "input": "6 1 3\n1 1 1 1 2 2", "output": "4" }, { "input": "6 1 3\n1 1 1 1 1 2", "output": "2" }, { "input": "6 4 2\n2 1 2 2 1 1", "output": "2" }, { "input": "3 10 1\n2 2 2", "output": "4" }, { "input": "5 1 3\n1 1 1 1 2", "output": "2" }, { "input": "5 2 2\n1 1 1 1 2", "output": "2" }, { "input": "15 5 5\n1 1 1 1 1 1 1 1 1 1 2 2 2 2 2", "output": "10" }, { "input": "5 1 2\n1 1 1 1 1", "output": "0" }, { "input": "3 6 1\n2 2 2", "output": "4" }, { "input": "5 3 3\n2 2 2 2 2", "output": "4" }, { "input": "8 3 3\n1 1 1 1 1 1 2 2", "output": "4" }, { "input": "5 1 2\n1 1 1 2 1", "output": "2" }, { "input": "6 1 4\n1 2 2 1 2 2", "output": "2" }, { "input": "2 1 1\n2 2", "output": "2" }, { "input": "2 2 1\n2 2", "output": "2" }, { "input": "5 8 1\n2 2 2 2 2", "output": "8" }, { "input": "3 1 4\n1 1 2", "output": "0" }, { "input": "7 1 5\n1 1 1 1 1 1 2", "output": "2" }, { "input": "6 1 3\n1 1 1 2 1 1", "output": "0" }, { "input": "6 1 2\n1 1 1 2 2 2", "output": "6" }, { "input": "8 1 4\n2 1 1 1 2 2 2 2", "output": "6" }, { "input": "4 2 3\n2 2 2 2", "output": "2" }, { "input": "3 1 1\n1 1 2", "output": "2" }, { "input": "5 1 1\n2 2 2 2 2", "output": "8" }, { "input": "10 1 5\n1 1 1 1 1 2 2 2 2 2", "output": "8" }, { "input": "5 1 2\n1 1 1 2 2", "output": "4" }, { "input": "4 1 1\n1 1 2 2", "output": "4" }, { "input": "7 1 2\n1 1 1 1 1 1 1", "output": "2" }, { "input": "5 1 4\n2 2 2 2 2", "output": "2" }, { "input": "6 2 3\n1 1 1 1 2 2", "output": "2" }, { "input": "5 2 2\n2 1 2 1 2", "output": "2" }, { "input": "4 6 1\n2 2 2 2", "output": "6" }, { "input": "6 1 4\n1 1 2 1 1 2", "output": "2" }, { "input": "7 1 3\n1 1 1 1 2 2 2", "output": "6" }, { "input": "4 1 2\n1 1 2 2", "output": "2" }, { "input": "3 1 2\n1 1 2", "output": "0" }, { "input": "6 1 3\n1 2 1 1 2 1", "output": "2" }, { "input": "6 1 3\n1 1 1 2 2 2", "output": "4" }, { "input": "10 2 2\n1 1 1 1 2 2 2 2 2 2", "output": "12" }, { "input": "10 1 4\n1 1 1 1 1 2 2 2 2 2", "output": "10" }, { "input": "3 10 2\n2 2 2", "output": "2" }, { "input": "4 3 1\n1 2 2 2", "output": "4" }, { "input": "7 1 4\n1 1 1 1 1 2 2", "output": "4" }, { "input": "3 4 1\n2 2 2", "output": "4" }, { "input": "4 1 2\n2 1 1 2", "output": "2" }, { "input": "10 1 2\n1 1 1 1 1 1 1 1 1 2", "output": "6" }, { "input": "5 1 3\n1 1 2 1 2", "output": "2" }, { "input": "6 1 3\n1 1 1 1 2 1", "output": "2" }, { "input": "6 1 4\n1 1 1 2 2 2", "output": "2" }, { "input": "7 1 2\n1 2 1 1 1 1 1", "output": "3" }, { "input": "6 2 2\n1 1 1 1 1 1", "output": "0" }, { "input": "6 1 2\n1 1 2 1 1 1", "output": "2" }, { "input": "3 3 1\n2 2 1", "output": "2" }, { "input": "8 4 2\n1 1 1 1 1 1 1 2", "output": "2" }, { "input": "9 1 4\n1 1 1 1 1 2 2 2 2", "output": "8" }, { "input": "5 10 1\n2 2 2 2 2", "output": "8" }, { "input": "3 5 1\n2 2 2", "output": "4" }, { "input": "5 100 1\n2 2 2 2 2", "output": "8" }, { "input": "4 1 2\n1 1 1 1", "output": "0" }, { "input": "4 1 1\n1 1 1 1", "output": "1" }, { "input": "7 2 2\n1 1 1 1 1 1 1", "output": "1" } ]

1,621,146,609

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

46

0

n, a, b = input().split() customers = list(map(int, input().split())) a = int(a) b = int(b) denied = 0 for i in customers: if i == 1: if a > 0 and b > 0: a -= 1 elif a <= 0 and b > 0: b = (2*b) - 1 else: denied += 1 else: if b >= 1: b = ((2*b) - 2)/2 else: denied += 2 print(denied)

Title: Restaurant Tables Time Limit: None seconds Memory Limit: None megabytes Problem Description: In a small restaurant there are *a* tables for one person and *b* tables for two persons. It it known that *n* groups of people come today, each consisting of one or two people. If a group consist of one person, it is seated at a vacant one-seater table. If there are none of them, it is seated at a vacant two-seater table. If there are none of them, it is seated at a two-seater table occupied by single person. If there are still none of them, the restaurant denies service to this group. If a group consist of two people, it is seated at a vacant two-seater table. If there are none of them, the restaurant denies service to this group. You are given a chronological order of groups coming. You are to determine the total number of people the restaurant denies service to. Input Specification: The first line contains three integers *n*, *a* and *b* (1<=≤<=*n*<=≤<=2·105, 1<=≤<=*a*,<=*b*<=≤<=2·105) — the number of groups coming to the restaurant, the number of one-seater and the number of two-seater tables. The second line contains a sequence of integers *t*1,<=*t*2,<=...,<=*t**n* (1<=≤<=*t**i*<=≤<=2) — the description of clients in chronological order. If *t**i* is equal to one, then the *i*-th group consists of one person, otherwise the *i*-th group consists of two people. Output Specification: Print the total number of people the restaurant denies service to. Demo Input: ['4 1 2\n1 2 1 1\n', '4 1 1\n1 1 2 1\n'] Demo Output: ['0\n', '2\n'] Note: In the first example the first group consists of one person, it is seated at a vacant one-seater table. The next group occupies a whole two-seater table. The third group consists of one person, it occupies one place at the remaining two-seater table. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, all clients are served. In the second example the first group consists of one person, it is seated at the vacant one-seater table. The next group consists of one person, it occupies one place at the two-seater table. It's impossible to seat the next group of two people, so the restaurant denies service to them. The fourth group consists of one person, he is seated at the remaining seat at the two-seater table. Thus, the restaurant denies service to 2 clients.

```python n, a, b = input().split() customers = list(map(int, input().split())) a = int(a) b = int(b) denied = 0 for i in customers: if i == 1: if a > 0 and b > 0: a -= 1 elif a <= 0 and b > 0: b = (2*b) - 1 else: denied += 1 else: if b >= 1: b = ((2*b) - 2)/2 else: denied += 2 print(denied) ```

0

358

A

Dima and Continuous Line

PROGRAMMING

1,400

[ "brute force", "implementation" ]

null

Dima and Seryozha live in an ordinary dormitory room for two. One day Dima had a date with his girl and he asked Seryozha to leave the room. As a compensation, Seryozha made Dima do his homework. The teacher gave Seryozha the coordinates of *n* distinct points on the abscissa axis and asked to consecutively connect them by semi-circus in a certain order: first connect the first point with the second one, then connect the second point with the third one, then the third one with the fourth one and so on to the *n*-th point. Two points with coordinates (*x*1,<=0) and (*x*2,<=0) should be connected by a semi-circle that passes above the abscissa axis with the diameter that coincides with the segment between points. Seryozha needs to find out if the line on the picture intersects itself. For clarifications, see the picture Seryozha showed to Dima (the left picture has self-intersections, the right picture doesn't have any). Seryozha is not a small boy, so the coordinates of the points can be rather large. Help Dima cope with the problem.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=103). The second line contains *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=106<=≤<=*x**i*<=≤<=106) — the *i*-th point has coordinates (*x**i*,<=0). The points are not necessarily sorted by their *x* coordinate.

In the single line print "yes" (without the quotes), if the line has self-intersections. Otherwise, print "no" (without the quotes).

[ "4\n0 10 5 15\n", "4\n0 15 5 10\n" ]

[ "yes\n", "no\n" ]

The first test from the statement is on the picture to the left, the second test is on the picture to the right.

500

[ { "input": "4\n0 10 5 15", "output": "yes" }, { "input": "4\n0 15 5 10", "output": "no" }, { "input": "5\n0 1000 2000 3000 1500", "output": "yes" }, { "input": "5\n-724093 710736 -383722 -359011 439613", "output": "no" }, { "input": "50\n384672 661179 -775591 -989608 611120 442691 601796 502406 384323 -315945 -934146 873993 -156910 -94123 -930137 208544 816236 466922 473696 463604 794454 -872433 -149791 -858684 -467655 -555239 623978 -217138 -408658 493342 -733576 -350871 711210 884148 -426172 519986 -356885 527171 661680 977247 141654 906254 -961045 -759474 -48634 891473 -606365 -513781 -966166 27696", "output": "yes" }, { "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": "no" }, { "input": "11\n1 11 10 2 3 9 8 4 5 7 6", "output": "no" }, { "input": "10\n3 2 4 5 1 6 9 7 8 10", "output": "yes" }, { "input": "11\n3 4 2 5 1 6 11 7 10 8 9", "output": "no" }, { "input": "15\n0 -1 1 2 3 13 12 4 11 10 5 6 7 9 8", "output": "no" }, { "input": "16\n6 7 8 9 5 10 11 12 13 14 15 4 16 2 1 3", "output": "yes" }, { "input": "1\n0", "output": "no" }, { "input": "4\n3 1 4 2", "output": "yes" }, { "input": "5\n0 2 4 -2 5", "output": "no" }, { "input": "5\n1 9 8 7 0", "output": "yes" }, { "input": "3\n5 10 0", "output": "no" }, { "input": "6\n1 3 -1 5 2 4", "output": "yes" }, { "input": "4\n3 2 4 1", "output": "no" }, { "input": "4\n10 5 15 0", "output": "no" }, { "input": "2\n-5 -10", "output": "no" }, { "input": "3\n1 0 3", "output": "no" }, { "input": "4\n-2 -4 1 -3", "output": "yes" }, { "input": "4\n3 6 0 2", "output": "no" }, { "input": "4\n-9 10 -10 0", "output": "yes" }, { "input": "4\n5 10 1 15", "output": "no" }, { "input": "3\n1 0 2", "output": "no" }, { "input": "4\n2 3 4 1", "output": "no" }, { "input": "4\n7 5 9 12", "output": "no" } ]

1,421,762,637

2,147,483,647

Python 3

OK

TESTS

37

155

0

def main(): n = int(input()) l = [] a = 0 for b in map(int, input().split()): if a < b: l.append((a, b)) else: l.append((b, a)) a = b l[0] = ((0, 0)) l.sort() for i, (c, d) in enumerate(l): for j in range(i): a, b = l[j] if a < c < b < d: print('yes') return print('no') if __name__ == '__main__': main()

Title: Dima and Continuous Line Time Limit: None seconds Memory Limit: None megabytes Problem Description: Dima and Seryozha live in an ordinary dormitory room for two. One day Dima had a date with his girl and he asked Seryozha to leave the room. As a compensation, Seryozha made Dima do his homework. The teacher gave Seryozha the coordinates of *n* distinct points on the abscissa axis and asked to consecutively connect them by semi-circus in a certain order: first connect the first point with the second one, then connect the second point with the third one, then the third one with the fourth one and so on to the *n*-th point. Two points with coordinates (*x*1,<=0) and (*x*2,<=0) should be connected by a semi-circle that passes above the abscissa axis with the diameter that coincides with the segment between points. Seryozha needs to find out if the line on the picture intersects itself. For clarifications, see the picture Seryozha showed to Dima (the left picture has self-intersections, the right picture doesn't have any). Seryozha is not a small boy, so the coordinates of the points can be rather large. Help Dima cope with the problem. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=103). The second line contains *n* distinct integers *x*1,<=*x*2,<=...,<=*x**n* (<=-<=106<=≤<=*x**i*<=≤<=106) — the *i*-th point has coordinates (*x**i*,<=0). The points are not necessarily sorted by their *x* coordinate. Output Specification: In the single line print "yes" (without the quotes), if the line has self-intersections. Otherwise, print "no" (without the quotes). Demo Input: ['4\n0 10 5 15\n', '4\n0 15 5 10\n'] Demo Output: ['yes\n', 'no\n'] Note: The first test from the statement is on the picture to the left, the second test is on the picture to the right.

```python def main(): n = int(input()) l = [] a = 0 for b in map(int, input().split()): if a < b: l.append((a, b)) else: l.append((b, a)) a = b l[0] = ((0, 0)) l.sort() for i, (c, d) in enumerate(l): for j in range(i): a, b = l[j] if a < c < b < d: print('yes') return print('no') if __name__ == '__main__': main() ```

3

37

A

Towers

PROGRAMMING

1,000

[ "sortings" ]

A. Towers

2

256

Little Vasya has received a young builder’s kit. The kit consists of several wooden bars, the lengths of all of them are known. The bars can be put one on the top of the other if their lengths are the same. Vasya wants to construct the minimal number of towers from the bars. Help Vasya to use the bars in the best way possible.

The first line contains an integer *N* (1<=≤<=*N*<=≤<=1000) — the number of bars at Vasya’s disposal. The second line contains *N* space-separated integers *l**i* — the lengths of the bars. All the lengths are natural numbers not exceeding 1000.

In one line output two numbers — the height of the largest tower and their total number. Remember that Vasya should use all the bars.

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

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

none

500

[ { "input": "3\n1 2 3", "output": "1 3" }, { "input": "4\n6 5 6 7", "output": "2 3" }, { "input": "4\n3 2 1 1", "output": "2 3" }, { "input": "4\n1 2 3 3", "output": "2 3" }, { "input": "3\n20 22 36", "output": "1 3" }, { "input": "25\n47 30 94 41 45 20 96 51 110 129 24 116 9 47 32 82 105 114 116 75 154 151 70 42 162", "output": "2 23" }, { "input": "45\n802 664 442 318 318 827 417 878 711 291 231 414 807 553 657 392 279 202 386 606 465 655 658 112 887 15 25 502 95 44 679 775 942 609 209 871 31 234 4 231 150 110 22 823 193", "output": "2 43" }, { "input": "63\n93 180 116 7 8 179 268 279 136 94 221 153 264 190 278 19 19 63 153 26 158 225 25 49 89 218 111 149 255 225 197 122 243 80 3 224 107 178 202 17 53 92 69 42 228 24 81 205 95 8 265 82 228 156 127 241 172 159 106 60 67 155 111", "output": "2 57" }, { "input": "83\n246 535 994 33 390 927 321 97 223 922 812 705 79 80 977 457 476 636 511 137 6 360 815 319 717 674 368 551 714 628 278 713 761 553 184 414 623 753 428 214 581 115 439 61 677 216 772 592 187 603 658 310 439 559 870 376 109 321 189 337 277 26 70 734 796 907 979 693 570 227 345 650 737 633 701 914 134 403 972 940 371 6 642", "output": "2 80" }, { "input": "105\n246 57 12 204 165 123 246 68 191 310 3 152 386 333 374 257 158 104 333 50 80 290 8 340 101 76 221 316 388 289 138 359 316 26 93 290 105 178 81 195 41 196 218 180 244 292 187 97 315 323 174 119 248 239 92 312 31 2 101 180 307 170 338 314 163 281 217 31 142 238 280 190 190 156 70 74 329 113 151 8 141 313 366 40 253 116 168 124 135 230 294 266 353 389 371 359 195 200 183 237 93 102 315 118 188", "output": "2 92" }, { "input": "123\n112 277 170 247 252 115 157 293 256 143 196 90 12 164 164 42 8 223 167 109 175 232 239 111 148 51 9 254 93 32 268 162 231 91 47 162 161 191 195 145 247 292 129 199 230 94 144 217 18 205 176 20 143 198 121 243 211 262 230 277 195 255 108 290 220 275 158 2 286 200 60 267 278 207 123 150 123 116 131 13 12 226 33 244 30 275 263 45 158 192 254 149 242 176 62 224 221 288 250 160 155 225 132 143 276 293 218 145 197 175 33 129 79 206 210 192 222 262 190 52 274 243 233", "output": "3 101" }, { "input": "5\n5 5 5 5 5", "output": "5 1" }, { "input": "3\n1000 1000 1000", "output": "3 1" }, { "input": "1\n1000", "output": "1 1" }, { "input": "1\n1", "output": "1 1" }, { "input": "5\n1 1000 1000 1000 1000", "output": "4 2" }, { "input": "5\n1000 1000 1000 8 7", "output": "3 3" } ]

1,563,320,712

2,147,483,647

Python 3

OK

TESTS

61

248

0

n = int(input()) L = [int(s) for s in input().split()] Len = {} for elem in L: if elem in Len.keys(): Len[elem] += 1 else: Len[elem] = 1 MAX = 0 for elem in Len.keys(): if MAX < Len[elem]: MAX = Len[elem] print(MAX, len(Len))

Title: Towers Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Little Vasya has received a young builder’s kit. The kit consists of several wooden bars, the lengths of all of them are known. The bars can be put one on the top of the other if their lengths are the same. Vasya wants to construct the minimal number of towers from the bars. Help Vasya to use the bars in the best way possible. Input Specification: The first line contains an integer *N* (1<=≤<=*N*<=≤<=1000) — the number of bars at Vasya’s disposal. The second line contains *N* space-separated integers *l**i* — the lengths of the bars. All the lengths are natural numbers not exceeding 1000. Output Specification: In one line output two numbers — the height of the largest tower and their total number. Remember that Vasya should use all the bars. Demo Input: ['3\n1 2 3\n', '4\n6 5 6 7\n'] Demo Output: ['1 3\n', '2 3\n'] Note: none

```python n = int(input()) L = [int(s) for s in input().split()] Len = {} for elem in L: if elem in Len.keys(): Len[elem] += 1 else: Len[elem] = 1 MAX = 0 for elem in Len.keys(): if MAX < Len[elem]: MAX = Len[elem] print(MAX, len(Len)) ```

3.938

293

C

Cube Problem

PROGRAMMING

2,400

[ "brute force", "math", "number theory" ]

null

Yaroslav, Andrey and Roman love playing cubes. Sometimes they get together and play cubes for hours and hours! Today they got together again and they are playing cubes. Yaroslav took unit cubes and composed them into an *a*<=×<=*a*<=×<=*a* cube, Andrey made a *b*<=×<=*b*<=×<=*b* cube and Roman made a *c*<=×<=*c*<=×<=*c* cube. After that the game was finished and the guys left. But later, Vitaly entered the room. He saw the cubes and wanted to make a cube as well. But what size should the cube be? Of course it should be a large cube with the side of length *a*<=+<=*b*<=+<=*c*. Besides, Vitaly decided to decompose the cubes built by Yaroslav, Andrey and Roman and compose his own large cube out of them. However, it turned out that the unit cubes he got from destroying the three cubes just weren't enough to make a large cube. We know that Vitaly was short of exactly *n* cubes. Vitaly got upset, demolished everything and left. As he was leaving, he met Petya and told him that there had been three cubes in the room and that he needed another *n* unit cubes to make his own large cube. Petya entered the room and saw the messily scattered cubes. He wanted to make it neat and orderly again. But he only knows that there had been three cubes, made of small unit cubes and that Vitaly needed *n* more unit cubes to make a large one! Help Petya understand, how many ways of sizes *a*, *b*, *c* are there to restore Yaroslav's, Andrey's and Roman's cubes.

The single line of the input contains integer *n* (1<=≤<=*n*<=≤<=1014). We know that all numbers *a*, *b*, *c* are positive integers. Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

In the single line print the required number of ways. If it turns out that there isn't a single way of suitable sizes of *a*, *b*, *c*, print 0.

[ "24\n", "648\n", "5\n", "93163582512000\n" ]

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

none

1,500

[ { "input": "24", "output": "1" }, { "input": "648", "output": "7" }, { "input": "5", "output": "0" }, { "input": "93163582512000", "output": "39090" }, { "input": "1260", "output": "0" }, { "input": "1680", "output": "0" }, { "input": "2520", "output": "6" }, { "input": "1081080", "output": "108" }, { "input": "110270160", "output": "444" }, { "input": "1102701600", "output": "1290" }, { "input": "97821761637600", "output": "38298" }, { "input": "1", "output": "0" }, { "input": "2", "output": "0" }, { "input": "4", "output": "0" }, { "input": "6", "output": "0" }, { "input": "12", "output": "0" }, { "input": "24", "output": "1" }, { "input": "36", "output": "0" }, { "input": "48", "output": "0" }, { "input": "60", "output": "0" }, { "input": "120", "output": "0" }, { "input": "180", "output": "6" }, { "input": "128501493120", "output": "5160" }, { "input": "146659312800", "output": "5796" }, { "input": "160626866400", "output": "5070" }, { "input": "240940299600", "output": "5526" }, { "input": "293318625600", "output": "8124" }, { "input": "321253732800", "output": "7158" }, { "input": "481880599200", "output": "8352" }, { "input": "642507465600", "output": "9996" }, { "input": "963761198400", "output": "11700" }, { "input": "1124388064800", "output": "9222" }, { "input": "1606268664000", "output": "11022" }, { "input": "1686582097200", "output": "9918" }, { "input": "1927522396800", "output": "15726" }, { "input": "2248776129600", "output": "13146" }, { "input": "3212537328000", "output": "15018" }, { "input": "3373164194400", "output": "14892" }, { "input": "4497552259200", "output": "17844" }, { "input": "6746328388800", "output": "21318" }, { "input": "8995104518400", "output": "23544" }, { "input": "9316358251200", "output": "18222" }, { "input": "13492656777600", "output": "29070" }, { "input": "18632716502400", "output": "24822" }, { "input": "26985313555200", "output": "37926" }, { "input": "27949074753600", "output": "29556" }, { "input": "32607253879200", "output": "23586" }, { "input": "46581791256000", "output": "28422" }, { "input": "48910880818800", "output": "25422" }, { "input": "55898149507200", "output": "40080" }, { "input": "65214507758400", "output": "34044" }, { "input": "100000000000000", "output": "0" }, { "input": "30000000000000", "output": "72" }, { "input": "90000000000000", "output": "129" }, { "input": "128397219837", "output": "0" }, { "input": "100000000000000", "output": "0" }, { "input": "99999999999999", "output": "0" }, { "input": "99999999999998", "output": "0" }, { "input": "99999999999997", "output": "0" }, { "input": "99999999999996", "output": "0" }, { "input": "12121382", "output": "0" }, { "input": "7", "output": "0" }, { "input": "1000000009", "output": "0" }, { "input": "1018081", "output": "0" } ]

1,690,949,683

2,147,483,647

PyPy 3-64

TIME_LIMIT_EXCEEDED

TESTS

3

2,000

1,945,600

import sys input = sys.stdin.buffer.readline def getabc(x, y, z): if (x+y+z)%2 != 0: return [-1, -1, -1] tong = (x+y+z)//2 return [tong-y, tong-z, tong-x] n = int(input()) if n%3 != 0: print(0); sys.exit() n, ans = n//3, 0 for x in range(2, int(n**0.3333)+2): if n%x == 0: for y in range(x, int((n//x)**0.5)+1): if (n//x)%y == 0: z = (n//x)//y; abc = getabc(x, y, z) if abc[0] > 0 and abc[1] > 0 and abc[2] > 0: ln = len(set(abc)); ans = ans+ln*(ln+1)//2 print(ans)

Title: Cube Problem Time Limit: None seconds Memory Limit: None megabytes Problem Description: Yaroslav, Andrey and Roman love playing cubes. Sometimes they get together and play cubes for hours and hours! Today they got together again and they are playing cubes. Yaroslav took unit cubes and composed them into an *a*<=×<=*a*<=×<=*a* cube, Andrey made a *b*<=×<=*b*<=×<=*b* cube and Roman made a *c*<=×<=*c*<=×<=*c* cube. After that the game was finished and the guys left. But later, Vitaly entered the room. He saw the cubes and wanted to make a cube as well. But what size should the cube be? Of course it should be a large cube with the side of length *a*<=+<=*b*<=+<=*c*. Besides, Vitaly decided to decompose the cubes built by Yaroslav, Andrey and Roman and compose his own large cube out of them. However, it turned out that the unit cubes he got from destroying the three cubes just weren't enough to make a large cube. We know that Vitaly was short of exactly *n* cubes. Vitaly got upset, demolished everything and left. As he was leaving, he met Petya and told him that there had been three cubes in the room and that he needed another *n* unit cubes to make his own large cube. Petya entered the room and saw the messily scattered cubes. He wanted to make it neat and orderly again. But he only knows that there had been three cubes, made of small unit cubes and that Vitaly needed *n* more unit cubes to make a large one! Help Petya understand, how many ways of sizes *a*, *b*, *c* are there to restore Yaroslav's, Andrey's and Roman's cubes. Input Specification: The single line of the input contains integer *n* (1<=≤<=*n*<=≤<=1014). We know that all numbers *a*, *b*, *c* are positive integers. Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Specification: In the single line print the required number of ways. If it turns out that there isn't a single way of suitable sizes of *a*, *b*, *c*, print 0. Demo Input: ['24\n', '648\n', '5\n', '93163582512000\n'] Demo Output: ['1\n', '7\n', '0\n', '39090\n'] Note: none

```python import sys input = sys.stdin.buffer.readline def getabc(x, y, z): if (x+y+z)%2 != 0: return [-1, -1, -1] tong = (x+y+z)//2 return [tong-y, tong-z, tong-x] n = int(input()) if n%3 != 0: print(0); sys.exit() n, ans = n//3, 0 for x in range(2, int(n**0.3333)+2): if n%x == 0: for y in range(x, int((n//x)**0.5)+1): if (n//x)%y == 0: z = (n//x)//y; abc = getabc(x, y, z) if abc[0] > 0 and abc[1] > 0 and abc[2] > 0: ln = len(set(abc)); ans = ans+ln*(ln+1)//2 print(ans) ```

0

78

B

Easter Eggs

PROGRAMMING

1,200

[ "constructive algorithms", "implementation" ]

B. Easter Eggs

2

256

The Easter Rabbit laid *n* eggs in a circle and is about to paint them. Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied: - Each of the seven colors should be used to paint at least one egg. - Any four eggs lying sequentially should be painted different colors. Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.

The only line contains an integer *n* — the amount of eggs (7<=≤<=*n*<=≤<=100).

Print one line consisting of *n* characters. The *i*-th character should describe the color of the *i*-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet. If there are several answers, print any of them.

[ "8\n", "13\n" ]

[ "ROYGRBIV\n", "ROYGBIVGBIVYG\n" ]

The way the eggs will be painted in the first sample is shown on the picture:

1,000

[ { "input": "8", "output": "ROYGBIVG" }, { "input": "13", "output": "ROYGBIVOYGBIV" }, { "input": "7", "output": "ROYGBIV" }, { "input": "10", "output": "ROYGBIVYGB" }, { "input": "14", "output": "ROYGBIVROYGBIV" }, { "input": "50", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVG" }, { "input": "9", "output": "ROYGBIVGB" }, { "input": "11", "output": "ROYGBIVYGBI" }, { "input": "12", "output": "ROYGBIVOYGBI" }, { "input": "15", "output": "ROYGBIVROYGBIVG" }, { "input": "16", "output": "ROYGBIVROYGBIVGB" }, { "input": "17", "output": "ROYGBIVROYGBIVYGB" }, { "input": "18", "output": "ROYGBIVROYGBIVYGBI" }, { "input": "19", "output": "ROYGBIVROYGBIVOYGBI" }, { "input": "20", "output": "ROYGBIVROYGBIVOYGBIV" }, { "input": "21", "output": "ROYGBIVROYGBIVROYGBIV" }, { "input": "22", "output": "ROYGBIVROYGBIVROYGBIVG" }, { "input": "23", "output": "ROYGBIVROYGBIVROYGBIVGB" }, { "input": "24", "output": "ROYGBIVROYGBIVROYGBIVYGB" }, { "input": "25", "output": "ROYGBIVROYGBIVROYGBIVYGBI" }, { "input": "28", "output": "ROYGBIVROYGBIVROYGBIVROYGBIV" }, { "input": "29", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVG" }, { "input": "34", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVOYGBIV" }, { "input": "43", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVG" }, { "input": "61", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVOYGBI" }, { "input": "79", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVGB" }, { "input": "81", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVYGBI" }, { "input": "92", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVG" }, { "input": "95", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVYGBI" }, { "input": "96", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVOYGBI" }, { "input": "97", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVOYGBIV" }, { "input": "98", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIV" }, { "input": "99", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVG" }, { "input": "100", "output": "ROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVROYGBIVGB" } ]

1,658,997,120

2,147,483,647

PyPy 3

OK

TESTS

34

154

0

# -*- coding: utf-8 -*- """ Created on Thu Jul 28 09:29:58 2022 @author: Conor CFSheet B Problem 8 - CF078-DIV2B """ n = int(input()) ans = "BIV" add = ["R", "O", "Y", "G"] for i in range(n-3): ans += add[i%4] print(ans)

Title: Easter Eggs Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: The Easter Rabbit laid *n* eggs in a circle and is about to paint them. Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied: - Each of the seven colors should be used to paint at least one egg. - Any four eggs lying sequentially should be painted different colors. Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible. Input Specification: The only line contains an integer *n* — the amount of eggs (7<=≤<=*n*<=≤<=100). Output Specification: Print one line consisting of *n* characters. The *i*-th character should describe the color of the *i*-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet. If there are several answers, print any of them. Demo Input: ['8\n', '13\n'] Demo Output: ['ROYGRBIV\n', 'ROYGBIVGBIVYG\n'] Note: The way the eggs will be painted in the first sample is shown on the picture:

```python # -*- coding: utf-8 -*- """ Created on Thu Jul 28 09:29:58 2022 @author: Conor CFSheet B Problem 8 - CF078-DIV2B """ n = int(input()) ans = "BIV" add = ["R", "O", "Y", "G"] for i in range(n-3): ans += add[i%4] print(ans) ```

3.9615

272

A

Dima and Friends

PROGRAMMING

1,000

[ "implementation", "math" ]

null

Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place. To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment. For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place. Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima.

The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains *n* positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show. The numbers in the lines are separated by a single space.

In a single line print the answer to the problem.

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

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

In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend. In the second sample Dima can show 2 or 4 fingers.

500

[ { "input": "1\n1", "output": "3" }, { "input": "1\n2", "output": "2" }, { "input": "2\n3 5", "output": "3" }, { "input": "2\n3 5", "output": "3" }, { "input": "1\n5", "output": "3" }, { "input": "5\n4 4 3 5 1", "output": "4" }, { "input": "6\n2 3 2 2 1 3", "output": "4" }, { "input": "8\n2 2 5 3 4 3 3 2", "output": "4" }, { "input": "7\n4 1 3 2 2 4 5", "output": "4" }, { "input": "3\n3 5 1", "output": "4" }, { "input": "95\n4 2 3 4 4 5 2 2 4 4 3 5 3 3 3 5 4 2 5 4 2 1 1 3 4 2 1 3 5 4 2 1 1 5 1 1 2 2 4 4 5 4 5 5 2 1 2 2 2 4 5 5 2 4 3 4 4 3 5 2 4 1 5 4 5 1 3 2 4 2 2 1 5 3 1 5 3 4 3 3 2 1 2 2 1 3 1 5 2 3 1 1 2 5 2", "output": "5" }, { "input": "31\n3 2 3 3 3 3 4 4 1 5 5 4 2 4 3 2 2 1 4 4 1 2 3 1 1 5 5 3 4 4 1", "output": "4" }, { "input": "42\n3 1 2 2 5 1 2 2 4 5 4 5 2 5 4 5 4 4 1 4 3 3 4 4 4 4 3 2 1 3 4 5 5 2 1 2 1 5 5 2 4 4", "output": "5" }, { "input": "25\n4 5 5 5 3 1 1 4 4 4 3 5 4 4 1 4 4 1 2 4 2 5 4 5 3", "output": "5" }, { "input": "73\n3 4 3 4 5 1 3 4 2 1 4 2 2 3 5 3 1 4 2 3 2 1 4 5 3 5 2 2 4 3 2 2 5 3 2 3 5 1 3 1 1 4 5 2 4 2 5 1 4 3 1 3 1 4 2 3 3 3 3 5 5 2 5 2 5 4 3 1 1 5 5 2 3", "output": "4" }, { "input": "46\n1 4 4 5 4 5 2 3 5 5 3 2 5 4 1 3 2 2 1 4 3 1 5 5 2 2 2 2 4 4 1 1 4 3 4 3 1 4 2 2 4 2 3 2 5 2", "output": "4" }, { "input": "23\n5 2 1 1 4 2 5 5 3 5 4 5 5 1 1 5 2 4 5 3 4 4 3", "output": "5" }, { "input": "6\n4 2 3 1 3 5", "output": "4" }, { "input": "15\n5 5 5 3 5 4 1 3 3 4 3 4 1 4 4", "output": "5" }, { "input": "93\n1 3 1 4 3 3 5 3 1 4 5 4 3 2 2 4 3 1 4 1 2 3 3 3 2 5 1 3 1 4 5 1 1 1 4 2 1 2 3 1 1 1 5 1 5 5 1 2 5 4 3 2 2 4 4 2 5 4 5 5 3 1 3 1 2 1 3 1 1 2 3 4 4 5 5 3 2 1 3 3 5 1 3 5 4 4 1 3 3 4 2 3 2", "output": "5" }, { "input": "96\n1 5 1 3 2 1 2 2 2 2 3 4 1 1 5 4 4 1 2 3 5 1 4 4 4 1 3 3 1 4 5 4 1 3 5 3 4 4 3 2 1 1 4 4 5 1 1 2 5 1 2 3 1 4 1 2 2 2 3 2 3 3 2 5 2 2 3 3 3 3 2 1 2 4 5 5 1 5 3 2 1 4 3 5 5 5 3 3 5 3 4 3 4 2 1 3", "output": "5" }, { "input": "49\n1 4 4 3 5 2 2 1 5 1 2 1 2 5 1 4 1 4 5 2 4 5 3 5 2 4 2 1 3 4 2 1 4 2 1 1 3 3 2 3 5 4 3 4 2 4 1 4 1", "output": "5" }, { "input": "73\n4 1 3 3 3 1 5 2 1 4 1 1 3 5 1 1 4 5 2 1 5 4 1 5 3 1 5 2 4 5 1 4 3 3 5 2 2 3 3 2 5 1 4 5 2 3 1 4 4 3 5 2 3 5 1 4 3 5 1 2 4 1 3 3 5 4 2 4 2 4 1 2 5", "output": "5" }, { "input": "41\n5 3 5 4 2 5 4 3 1 1 1 5 4 3 4 3 5 4 2 5 4 1 1 3 2 4 5 3 5 1 5 5 1 1 1 4 4 1 2 4 3", "output": "5" }, { "input": "100\n3 3 1 4 2 4 4 3 1 5 1 1 4 4 3 4 4 3 5 4 5 2 4 3 4 1 2 4 5 4 2 1 5 4 1 1 4 3 2 4 1 2 1 4 4 5 5 4 4 5 3 2 5 1 4 2 2 1 1 2 5 2 5 1 5 3 1 4 3 2 4 3 2 2 4 5 5 1 2 3 1 4 1 2 2 2 5 5 2 3 2 4 3 1 1 2 1 2 1 2", "output": "5" }, { "input": "100\n2 1 1 3 5 4 4 2 3 4 3 4 5 4 5 4 2 4 5 3 4 5 4 1 1 4 4 1 1 2 5 4 2 4 5 3 2 5 4 3 4 5 1 3 4 2 5 4 5 4 5 2 4 1 2 5 3 1 4 4 5 3 4 3 1 2 5 4 2 5 4 1 5 3 5 4 1 2 5 3 1 1 1 1 5 3 4 3 5 1 1 5 5 1 1 2 2 1 5 1", "output": "5" }, { "input": "100\n4 4 3 3 2 5 4 4 2 1 4 4 4 5 4 1 2 1 5 2 4 3 4 1 4 1 2 5 1 4 5 4 2 1 2 5 3 4 5 5 2 1 2 2 2 2 2 3 2 5 1 2 2 3 2 5 5 1 3 4 5 2 1 3 4 2 2 4 4 3 3 3 2 3 2 1 5 5 5 2 1 4 2 3 5 1 4 4 2 3 2 5 5 4 3 5 1 3 5 5", "output": "5" }, { "input": "100\n4 4 2 5 4 2 2 3 4 4 3 2 3 3 1 3 4 3 3 4 1 3 1 4 5 3 4 3 1 1 1 3 3 2 3 4 3 4 2 2 1 5 1 4 5 1 1 1 3 3 1 1 3 2 5 4 2 5 2 4 5 4 4 1 1 2 1 1 4 5 1 1 5 3 3 2 5 5 5 1 4 1 4 1 1 3 2 3 4 4 2 5 5 2 5 1 1 3 5 3", "output": "5" }, { "input": "100\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 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 4", "output": "4" }, { "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": "5" } ]

1,647,419,084

2,147,483,647

Python 3

OK

TESTS

30

92

0

n=int(input()) s=sum(list(map(int,input().split()))) k=0 for i in range(5): if (s+i)%(n+1)!=0: k=k+1 print(k)

Title: Dima and Friends Time Limit: None seconds Memory Limit: None megabytes Problem Description: Dima and his friends have been playing hide and seek at Dima's place all night. As a result, Dima's place got messy. In the morning they decided that they need to clean the place. To decide who exactly would clean the apartment, the friends want to play a counting-out game. First, all the guys stand in a circle, and then each of them shows some number of fingers on one hand (one to five), and then the boys count in a circle, starting from Dima, the number of people, respective to the total number of fingers shown. The person on who the countdown stops will clean the apartment. For example, if Dima and one of his friends played hide and seek, and 7 fingers were shown during the counting-out, then Dima would clean the place. If there were 2 or say, 8 fingers shown, then his friend would clean the place. Dima knows how many fingers each of his friends will show during the counting-out. Now he is interested in the number of ways to show some number of fingers on one hand (one to five), so that he did not have to clean the place. Help Dima. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of Dima's friends. Dima himself isn't considered to be his own friend. The second line contains *n* positive integers, not exceeding 5, representing, how many fingers the Dima's friends will show. The numbers in the lines are separated by a single space. Output Specification: In a single line print the answer to the problem. Demo Input: ['1\n1\n', '1\n2\n', '2\n3 5\n'] Demo Output: ['3\n', '2\n', '3\n'] Note: In the first sample Dima can show 1, 3 or 5 fingers. If Dima shows 3 fingers, then the counting-out will go like that: Dima, his friend, Dima, his friend. In the second sample Dima can show 2 or 4 fingers.

```python n=int(input()) s=sum(list(map(int,input().split()))) k=0 for i in range(5): if (s+i)%(n+1)!=0: k=k+1 print(k) ```

3

992

A

Nastya and an Array

PROGRAMMING

800

[ "implementation", "sortings" ]

null

Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties: - In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes. Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array.

Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero.

[ "5\n1 1 1 1 1\n", "3\n2 0 -1\n", "4\n5 -6 -5 1\n" ]

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

In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero. In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.

500

[ { "input": "5\n1 1 1 1 1", "output": "1" }, { "input": "3\n2 0 -1", "output": "2" }, { "input": "4\n5 -6 -5 1", "output": "4" }, { "input": "1\n0", "output": "0" }, { "input": "2\n21794 -79194", "output": "2" }, { "input": "3\n-63526 95085 -5239", "output": "3" }, { "input": "3\n0 53372 -20572", "output": "2" }, { "input": "13\n-2075 -32242 27034 -37618 -96962 82203 64846 48249 -71761 28908 -21222 -61370 46899", "output": "13" }, { "input": "5\n806 0 1308 1954 683", "output": "4" }, { "input": "8\n-26 0 -249 -289 -126 -206 288 -11", "output": "7" }, { "input": "10\n2 2 2 1 2 -1 0 2 -1 1", "output": "3" }, { "input": "1\n8", "output": "1" }, { "input": "3\n0 0 0", "output": "0" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "10" }, { "input": "5\n2 0 -1 0 0", "output": "2" }, { "input": "2\n0 0", "output": "0" }, { "input": "5\n0 0 0 0 0", "output": "0" }, { "input": "2\n1 0", "output": "1" }, { "input": "2\n-1 0", "output": "1" }, { "input": "4\n0 0 0 0", "output": "0" }, { "input": "8\n10 9 -1 0 0 3 2 3", "output": "5" }, { "input": "5\n5 0 1 2 3", "output": "4" }, { "input": "3\n1 1 0", "output": "1" }, { "input": "1\n-1", "output": "1" }, { "input": "5\n1 2 0 0 0", "output": "2" }, { "input": "5\n1 0 0 0 0", "output": "1" }, { "input": "5\n4 5 6 0 0", "output": "3" }, { "input": "4\n-1 0 0 1", "output": "2" }, { "input": "5\n3 0 0 4 5", "output": "3" }, { "input": "3\n0 0 2", "output": "1" }, { "input": "3\n1 0 0", "output": "1" }, { "input": "4\n0 0 0 4", "output": "1" }, { "input": "5\n-1 0 0 0 0", "output": "1" }, { "input": "2\n0 1", "output": "1" }, { "input": "3\n1 2 3", "output": "3" }, { "input": "1\n5", "output": "1" }, { "input": "10\n0 0 0 0 0 1 2 3 0 0", "output": "3" }, { "input": "4\n0 1 2 3", "output": "3" }, { "input": "3\n0 1 2", "output": "2" }, { "input": "4\n2 0 0 -1", "output": "2" } ]

1,619,510,085

2,147,483,647

Python 3

OK

TESTS

79

124

7,680,000

n=int(input()) arr=list(map(int,input().split())) arr1=[] for i in range(n): if arr[i]!=0: arr1.append(arr[i]) arr1=list(set(arr1)) print(len(arr1))

Title: Nastya and an Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties: - In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes. Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array. Output Specification: Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero. Demo Input: ['5\n1 1 1 1 1\n', '3\n2 0 -1\n', '4\n5 -6 -5 1\n'] Demo Output: ['1\n', '2\n', '4\n'] Note: In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero. In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.

```python n=int(input()) arr=list(map(int,input().split())) arr1=[] for i in range(n): if arr[i]!=0: arr1.append(arr[i]) arr1=list(set(arr1)) print(len(arr1)) ```

3

352

A

Jeff and Digits

PROGRAMMING

1,000

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

null

Jeff's got *n* cards, each card contains either digit 0, or digit 5. Jeff can choose several cards and put them in a line so that he gets some number. What is the largest possible number divisible by 90 Jeff can make from the cards he's got? Jeff must make the number without leading zero. At that, we assume that number 0 doesn't contain any leading zeroes. Jeff doesn't have to use all the cards.

The first line contains integer *n* (1<=≤<=*n*<=≤<=103). The next line contains *n* integers *a*1, *a*2, ..., *a**n* (*a**i*<==<=0 or *a**i*<==<=5). Number *a**i* represents the digit that is written on the *i*-th card.

In a single line print the answer to the problem — the maximum number, divisible by 90. If you can't make any divisible by 90 number from the cards, print -1.

[ "4\n5 0 5 0\n", "11\n5 5 5 5 5 5 5 5 0 5 5\n" ]

[ "0\n", "5555555550\n" ]

In the first test you can make only one number that is a multiple of 90 — 0. In the second test you can make number 5555555550, it is a multiple of 90.

500

[ { "input": "4\n5 0 5 0", "output": "0" }, { "input": "11\n5 5 5 5 5 5 5 5 0 5 5", "output": "5555555550" }, { "input": "7\n5 5 5 5 5 5 5", "output": "-1" }, { "input": "1\n5", "output": "-1" }, { "input": "1\n0", "output": "0" }, { "input": "11\n5 0 5 5 5 0 0 5 5 5 5", "output": "0" }, { "input": "23\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 0 0 0 0 0", "output": "55555555555555555500000" }, { "input": "9\n5 5 5 5 5 5 5 5 5", "output": "-1" }, { "input": "24\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 0 0 0 0 0", "output": "55555555555555555500000" }, { "input": "10\n0 0 0 0 0 0 0 0 0 0", "output": "0" }, { "input": "10\n5 5 5 5 5 0 0 5 0 5", "output": "0" }, { "input": "3\n5 5 0", "output": "0" }, { "input": "5\n5 5 0 5 5", "output": "0" }, { "input": "14\n0 5 5 0 0 0 0 0 0 5 5 5 5 5", "output": "0" }, { "input": "3\n5 5 5", "output": "-1" }, { "input": "3\n0 5 5", "output": "0" }, { "input": "13\n0 0 5 0 5 0 5 5 0 0 0 0 0", "output": "0" }, { "input": "9\n5 5 0 5 5 5 5 5 5", "output": "0" }, { "input": "8\n0 0 0 0 0 0 0 0", "output": "0" }, { "input": "101\n5 0 0 0 0 0 0 0 5 0 0 0 0 5 0 0 5 0 0 0 0 0 5 0 0 0 0 0 0 0 0 5 0 0 5 0 0 0 0 0 0 0 5 0 0 5 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 5 0 0 0 0 5 0 0 0 0 0 0 0 0 0 5 0 0 5 0 0 0 0 5 0 0", "output": "5555555550000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }, { "input": "214\n5 0 5 0 5 0 0 0 5 5 0 5 0 5 5 0 5 0 0 0 0 5 5 0 0 5 5 0 0 0 0 5 5 5 5 0 5 0 0 0 0 0 0 5 0 0 0 5 0 0 5 0 0 5 5 0 0 5 5 0 0 0 0 0 5 0 5 0 5 5 0 5 0 0 5 5 5 0 5 0 5 0 5 5 0 5 0 0 0 5 5 0 5 0 5 5 5 5 5 0 0 0 0 0 0 5 0 5 5 0 5 0 5 0 5 5 0 0 0 0 5 0 5 0 5 0 0 5 0 0 5 5 5 5 5 0 0 5 0 0 5 0 0 5 0 0 5 0 0 5 0 5 0 0 0 5 0 0 5 5 5 0 0 5 5 5 0 0 5 5 0 0 0 5 0 0 5 5 5 5 5 5 0 5 0 0 5 5 5 5 0 5 5 0 0 0 5 5 5 5 0 0 0 0 5 0 0 5 0 0 5 5 0 0", "output": "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }, { "input": "80\n0 0 0 0 5 0 5 5 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5 0 0 5 0 0 0 0 0 0 0 0 0 5 5 0 5 0 0 0 0 0 0 5 0 0 0 0 0 0 0 5 0 0 0 0 5 0 5 5 0 0 0", "output": "555555555000000000000000000000000000000000000000000000000000000000000000000" }, { "input": "2\n0 0", "output": "0" }, { "input": "3\n5 0 0", "output": "0" }, { "input": "4\n5 5 5 5", "output": "-1" }, { "input": "2\n0 5", "output": "0" }, { "input": "14\n5 5 5 5 5 5 5 5 5 5 5 5 5 0", "output": "5555555550" }, { "input": "18\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5", "output": "-1" }, { "input": "10\n5 5 5 5 5 5 5 5 5 0", "output": "5555555550" }, { "input": "10\n5 5 5 5 5 5 5 5 5 5", "output": "-1" }, { "input": "20\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5", "output": "-1" } ]

1,654,935,850

2,147,483,647

Python 3

OK

TESTS

42

92

0

n = int(input()) arr = list(map(int, input().split())) five = arr.count(5) zero = arr.count(0) if zero == 0: print(-1) elif five < 9: print(0) else: n_five = (five//9)*9 print('5'*n_five + '0'*zero)

Title: Jeff and Digits Time Limit: None seconds Memory Limit: None megabytes Problem Description: Jeff's got *n* cards, each card contains either digit 0, or digit 5. Jeff can choose several cards and put them in a line so that he gets some number. What is the largest possible number divisible by 90 Jeff can make from the cards he's got? Jeff must make the number without leading zero. At that, we assume that number 0 doesn't contain any leading zeroes. Jeff doesn't have to use all the cards. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=103). The next line contains *n* integers *a*1, *a*2, ..., *a**n* (*a**i*<==<=0 or *a**i*<==<=5). Number *a**i* represents the digit that is written on the *i*-th card. Output Specification: In a single line print the answer to the problem — the maximum number, divisible by 90. If you can't make any divisible by 90 number from the cards, print -1. Demo Input: ['4\n5 0 5 0\n', '11\n5 5 5 5 5 5 5 5 0 5 5\n'] Demo Output: ['0\n', '5555555550\n'] Note: In the first test you can make only one number that is a multiple of 90 — 0. In the second test you can make number 5555555550, it is a multiple of 90.

```python n = int(input()) arr = list(map(int, input().split())) five = arr.count(5) zero = arr.count(0) if zero == 0: print(-1) elif five < 9: print(0) else: n_five = (five//9)*9 print('5'*n_five + '0'*zero) ```

3