contestId
int64 0
1.01k
| index
stringclasses 57
values | name
stringlengths 2
58
| type
stringclasses 2
values | rating
int64 0
3.5k
| tags
listlengths 0
11
| title
stringclasses 522
values | time-limit
stringclasses 8
values | memory-limit
stringclasses 8
values | problem-description
stringlengths 0
7.15k
| input-specification
stringlengths 0
2.05k
| output-specification
stringlengths 0
1.5k
| demo-input
listlengths 0
7
| demo-output
listlengths 0
7
| note
stringlengths 0
5.24k
| points
float64 0
425k
| test_cases
listlengths 0
402
| creationTimeSeconds
int64 1.37B
1.7B
| relativeTimeSeconds
int64 8
2.15B
| programmingLanguage
stringclasses 3
values | verdict
stringclasses 14
values | testset
stringclasses 12
values | passedTestCount
int64 0
1k
| timeConsumedMillis
int64 0
15k
| memoryConsumedBytes
int64 0
805M
| code
stringlengths 3
65.5k
| prompt
stringlengths 262
8.2k
| response
stringlengths 17
65.5k
| score
float64 -1
3.99
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
846
|
A
|
Curriculum Vitae
|
PROGRAMMING
| 1,500
|
[
"brute force",
"implementation"
] | null | null |
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
|
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100).
The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
|
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
|
[
"4\n1 1 0 1\n",
"6\n0 1 0 0 1 0\n",
"1\n0\n"
] |
[
"3\n",
"4\n",
"1\n"
] |
none
| 0
|
[
{
"input": "4\n1 1 0 1",
"output": "3"
},
{
"input": "6\n0 1 0 0 1 0",
"output": "4"
},
{
"input": "1\n0",
"output": "1"
},
{
"input": "100\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
"output": "100"
},
{
"input": "100\n0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0",
"output": "80"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "100\n1 1 0 1 1 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 1 1 1 1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 0 1 1 1 0 0 1 1 0 0 0 0 1",
"output": "53"
},
{
"input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "100"
},
{
"input": "3\n1 0 0",
"output": "2"
},
{
"input": "10\n1 1 0 0 0 1 1 0 0 0",
"output": "6"
},
{
"input": "90\n1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0",
"output": "52"
},
{
"input": "78\n0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 0 1 0",
"output": "42"
},
{
"input": "4\n1 0 0 1",
"output": "3"
},
{
"input": "2\n0 1",
"output": "2"
},
{
"input": "5\n0 1 0 0 1",
"output": "4"
},
{
"input": "3\n1 0 1",
"output": "2"
},
{
"input": "3\n1 1 0",
"output": "2"
},
{
"input": "16\n1 1 1 1 1 0 0 0 0 0 1 0 1 0 0 1",
"output": "9"
}
] | 1,506,053,580
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 18
| 62
| 0
|
a=int(input())
b=list(map(int,input().split()))
c=[]
d=[]
count=0
for i in b:
if i ==0:
count+=1
c.append(count)
count=0
for i in b[::-1]:
if i==1:
count+=1
d.append(count)
d=d[::-1]
x=[]
for i in range(a):
x.append(c[i]+d[i])
print(max(x))
|
Title: Curriculum Vitae
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input Specification:
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100).
The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output Specification:
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Demo Input:
['4\n1 1 0 1\n', '6\n0 1 0 0 1 0\n', '1\n0\n']
Demo Output:
['3\n', '4\n', '1\n']
Note:
none
|
```python
a=int(input())
b=list(map(int,input().split()))
c=[]
d=[]
count=0
for i in b:
if i ==0:
count+=1
c.append(count)
count=0
for i in b[::-1]:
if i==1:
count+=1
d.append(count)
d=d[::-1]
x=[]
for i in range(a):
x.append(c[i]+d[i])
print(max(x))
```
| 3
|
|
197
|
B
|
Limit
|
PROGRAMMING
| 1,400
|
[
"math"
] | null | null |
You are given two polynomials:
- *P*(*x*)<==<=*a*0·*x**n*<=+<=*a*1·*x**n*<=-<=1<=+<=...<=+<=*a**n*<=-<=1·*x*<=+<=*a**n* and - *Q*(*x*)<==<=*b*0·*x**m*<=+<=*b*1·*x**m*<=-<=1<=+<=...<=+<=*b**m*<=-<=1·*x*<=+<=*b**m*.
Calculate limit .
|
The first line contains two space-separated integers *n* and *m* (0<=≤<=*n*,<=*m*<=≤<=100) — degrees of polynomials *P*(*x*) and *Q*(*x*) correspondingly.
The second line contains *n*<=+<=1 space-separated integers — the factors of polynomial *P*(*x*): *a*0, *a*1, ..., *a**n*<=-<=1, *a**n* (<=-<=100<=≤<=*a**i*<=≤<=100,<=*a*0<=≠<=0).
The third line contains *m*<=+<=1 space-separated integers — the factors of polynomial *Q*(*x*): *b*0, *b*1, ..., *b**m*<=-<=1, *b**m* (<=-<=100<=≤<=*b**i*<=≤<=100,<=*b*0<=≠<=0).
|
If the limit equals <=+<=∞, print "Infinity" (without quotes). If the limit equals <=-<=∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit , in the format "p/q" (without the quotes), where *p* is the — numerator, *q* (*q*<=><=0) is the denominator of the fraction.
|
[
"2 1\n1 1 1\n2 5\n",
"1 0\n-1 3\n2\n",
"0 1\n1\n1 0\n",
"2 2\n2 1 6\n4 5 -7\n",
"1 1\n9 0\n-5 2\n"
] |
[
"Infinity\n",
"-Infinity\n",
"0/1\n",
"1/2\n",
"-9/5\n"
] |
Let's consider all samples:
1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c28febca257452afdfcbd6984ba8623911f9bdbc.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1e55ecd04e54a45e5e0092ec9a5c1ea03bb29255.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/2c95fb684d373fcc1a481cfabeda4d5c2f3673ee.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4dc40cb8b3cd6375c42445366e50369649a2801a.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c6455aba35cfb3c4397505121d1f77afcd17c98e.png" style="max-width: 100.0%;max-height: 100.0%;"/>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
| 500
|
[
{
"input": "2 1\n1 1 1\n2 5",
"output": "Infinity"
},
{
"input": "1 0\n-1 3\n2",
"output": "-Infinity"
},
{
"input": "0 1\n1\n1 0",
"output": "0/1"
},
{
"input": "2 2\n2 1 6\n4 5 -7",
"output": "1/2"
},
{
"input": "1 1\n9 0\n-5 2",
"output": "-9/5"
},
{
"input": "1 2\n5 3\n-3 2 -1",
"output": "0/1"
},
{
"input": "1 2\n-4 8\n-2 5 -3",
"output": "0/1"
},
{
"input": "3 2\n4 3 1 2\n-5 7 0",
"output": "-Infinity"
},
{
"input": "2 1\n-3 5 1\n-8 0",
"output": "Infinity"
},
{
"input": "1 1\n-5 7\n3 1",
"output": "-5/3"
},
{
"input": "2 2\n-4 2 1\n-5 8 -19",
"output": "4/5"
},
{
"input": "0 100\n1\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100",
"output": "0/1"
},
{
"input": "100 0\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100\n1",
"output": "Infinity"
},
{
"input": "0 0\n36\n-54",
"output": "-2/3"
},
{
"input": "0 0\n36\n-8",
"output": "-9/2"
},
{
"input": "0 0\n-6\n-8",
"output": "3/4"
},
{
"input": "0 2\n-3\n1 4 6",
"output": "0/1"
},
{
"input": "0 0\n-21\n13",
"output": "-21/13"
},
{
"input": "0 0\n-34\n21",
"output": "-34/21"
},
{
"input": "0 0\n-55\n34",
"output": "-55/34"
},
{
"input": "33 100\n-15 -90 -84 57 67 60 -40 -82 83 -80 43 -15 -36 -14 -37 -49 42 -79 49 -7 -12 53 -44 -21 87 -91 -73 -27 13 65 5 74 -21 -52\n-67 -17 36 -46 -5 31 -45 -35 -49 13 -7 -82 92 -55 -67 -96 31 -70 76 24 -29 26 96 19 -40 99 -26 74 -17 -56 -72 24 -71 -62 10 -56 -74 75 -48 -98 -67 -26 47 7 63 -38 99 66 -25 -31 -24 -42 -49 -27 -45 -2 -37 -16 5 -21 97 33 85 -33 93 30 84 73 -48 18 -36 71 -38 -41 28 1 -7 -15 60 59 -20 -38 -86 90 2 -12 72 -43 26 76 97 7 -2 -47 -4 100 -40 -48 53 -54 0",
"output": "0/1"
},
{
"input": "39 87\n78 -50 18 -32 -12 -65 83 41 -6 53 -26 64 -19 -53 -61 91 -49 -66 67 69 100 -39 95 99 86 -67 -66 63 48 26 -4 95 -54 -71 26 -74 -93 79 -91 -45\n-18 23 48 59 76 82 95 2 -26 18 -39 -74 44 -92 40 -44 1 -97 -100 -63 -54 -3 -86 85 28 -50 41 -53 -74 -29 -91 87 27 -42 -90 -15 -26 -15 -100 -70 -10 -41 16 85 71 -39 -31 -65 80 98 9 23 -40 14 -88 15 -34 10 -67 -94 -58 -24 75 48 -42 56 -77 -13 -25 -79 -100 -57 89 45 22 85 78 -93 -79 69 63 44 74 94 35 -65 -12 -88",
"output": "0/1"
},
{
"input": "47 56\n31 -99 -97 6 -45 -5 89 35 -77 69 57 91 -32 -66 -36 16 30 61 -36 32 48 67 5 -85 65 -11 -51 -63 -51 -16 39 -26 -60 -28 91 43 -90 32 44 83 70 -53 51 56 68 -81 76 79\n61 -21 -75 -36 -24 -19 80 26 -28 93 27 72 -39 -46 -38 68 -29 -16 -63 84 -13 64 55 63 77 5 68 70 15 99 12 -69 50 -48 -82 -3 52 -54 68 91 -37 -100 -5 74 24 91 -1 74 28 29 -87 -13 -88 82 -13 58 23",
"output": "0/1"
},
{
"input": "9 100\n-34 88 33 -80 87 31 -53 -3 8 -70\n31 -25 46 78 8 82 -92 -36 -30 85 -93 86 -87 75 8 -71 44 -41 -83 19 89 -28 81 42 79 86 41 -23 64 -31 46 24 -79 23 71 63 99 90 -16 -70 -1 88 10 65 3 -99 95 52 -80 53 -24 -43 -30 -7 51 40 -47 44 -10 -18 -61 -67 -84 37 45 93 -5 68 32 3 -61 -100 38 -21 -91 90 83 -45 75 89 17 -44 75 14 -28 1 -84 -100 -36 84 -40 88 -84 -54 2 -32 92 -49 77 85 91",
"output": "0/1"
},
{
"input": "28 87\n-77 49 37 46 -92 65 89 100 53 76 -43 47 -80 -46 -94 -4 20 46 81 -41 86 25 69 60 15 -78 -98 -7 -42\n-85 96 59 -40 90 -72 41 -17 -40 -15 -98 66 47 9 -33 -63 59 -25 -31 25 -94 35 28 -36 -41 -38 -38 -54 -40 90 7 -10 98 -19 54 -10 46 -58 -88 -21 90 82 37 -70 -98 -63 41 75 -50 -59 -69 79 -93 -3 -45 14 76 28 -28 -98 -44 -39 71 44 90 91 0 45 7 65 68 39 -27 58 68 -47 -41 100 14 -95 -80 69 -88 -51 -89 -70 -23 95",
"output": "0/1"
},
{
"input": "100 4\n-5 -93 89 -26 -79 14 -28 13 -45 69 50 -84 21 -68 62 30 -26 99 -12 39 20 -74 -39 -41 -28 -72 -55 28 20 31 -92 -20 76 -65 57 72 -36 4 33 -28 -19 -41 -40 40 84 -36 -83 75 -74 -80 32 -50 -56 72 16 75 57 90 -19 -10 67 -71 69 -48 -48 23 37 -31 -64 -86 20 67 97 14 82 -41 2 87 65 -81 -27 9 -79 -1 -5 84 -8 29 -34 31 82 40 21 -53 -31 -45 17 -33 79 50 -94\n56 -4 -90 36 84",
"output": "-Infinity"
},
{
"input": "77 51\n89 45 -33 -87 33 -61 -79 40 -76 16 -17 31 27 25 99 82 51 -40 85 -66 19 89 -62 24 -61 -53 -77 17 21 83 53 -18 -56 75 9 -78 33 -11 -6 96 -33 -2 -57 97 30 20 -41 42 -13 45 -99 67 37 -20 51 -33 88 -62 2 40 17 36 45 71 4 -44 24 20 -2 29 -12 -84 -7 -84 -38 48 -73 79\n60 -43 60 1 90 -1 19 -18 -21 31 -76 51 79 91 12 39 -33 -14 71 -90 -65 -93 -58 93 49 17 77 19 32 -8 14 58 -9 85 -95 -73 0 85 -91 -99 -30 -43 61 20 -89 93 53 20 -33 -38 79 54",
"output": "Infinity"
},
{
"input": "84 54\n82 -54 28 68 74 -61 54 98 59 67 -65 -1 16 65 -78 -16 61 -79 2 14 44 96 -62 77 51 87 37 66 65 28 88 -99 -21 -83 24 80 39 64 -65 45 86 -53 -49 94 -75 -31 -42 -1 -35 -18 74 30 31 -40 30 -6 47 58 -71 -21 20 13 75 -79 15 -98 -26 76 99 -77 -9 85 48 51 -87 56 -53 37 47 -3 94 64 -7 74 86\n72 51 -74 20 41 -76 98 58 24 -61 -97 -73 62 29 6 42 -92 -6 -65 89 -32 -9 82 -13 -88 -70 -97 25 -48 12 -54 33 -92 -29 48 60 -21 86 -17 -86 45 -34 -3 -9 -62 12 25 -74 -76 -89 48 55 -30 86 51",
"output": "Infinity"
},
{
"input": "73 15\n-70 78 51 -33 -95 46 87 -33 16 62 67 -85 -57 75 -93 -59 98 -45 -90 -88 9 53 35 37 28 3 40 -87 28 5 18 11 9 1 72 69 -65 -62 1 73 -3 3 35 17 -28 -31 -45 60 64 18 60 38 -47 12 2 -90 -4 33 -51 -55 -54 90 38 -65 39 32 -70 0 -5 3 -12 100 78 55\n46 33 41 52 -89 -9 53 -81 34 -45 -11 -41 14 -28 95 -50",
"output": "-Infinity"
},
{
"input": "33 1\n-75 -83 87 -27 -48 47 -90 -84 -18 -4 14 -1 -83 -98 -68 -85 -86 28 2 45 96 -59 86 -25 -2 -64 -92 65 69 72 72 -58 -99 90\n-1 72",
"output": "Infinity"
},
{
"input": "58 58\n-25 40 -34 23 -52 94 -30 -99 -71 -90 -44 -71 69 48 -45 -59 0 66 -70 -96 95 91 82 90 -95 87 3 -77 -77 -26 15 87 -82 5 -24 82 -11 99 35 49 22 44 18 -60 -26 79 67 71 -13 29 -23 9 58 -90 88 18 77 5 -7\n-30 -11 -13 -50 61 -78 11 -74 -73 13 -66 -65 -82 38 58 25 -64 -24 78 -87 6 6 -80 -96 47 -25 -54 10 -41 -22 -50 -1 -6 -22 27 54 -32 30 93 88 -70 -100 -69 -47 -20 -92 -24 70 -93 42 78 42 -35 41 31 75 -67 -62 -83",
"output": "5/6"
},
{
"input": "20 20\n5 4 91 -66 -57 55 -79 -2 -54 -72 -49 21 -23 -5 57 -48 70 -16 -86 -26 -19\n51 -60 64 -8 89 27 -96 4 95 -24 -2 -27 -41 -14 -88 -19 24 68 -31 34 -62",
"output": "5/51"
},
{
"input": "69 69\n-90 -63 -21 23 23 -14 -82 65 42 -60 -42 -39 67 34 96 93 -42 -24 21 -80 44 -81 45 -74 -19 -88 39 58 90 87 16 48 -19 -2 36 87 4 -66 -82 -49 -32 -43 -65 12 34 -29 -58 46 -67 -20 -30 91 21 65 15 2 3 -92 -67 -68 39 -24 77 76 -17 -34 5 63 88 83\n-55 98 -79 18 -100 -67 -79 -85 -75 -44 -6 -73 -11 -12 -24 -78 47 -51 25 -29 -34 25 27 11 -87 15 -44 41 -44 46 -67 70 -35 41 62 -36 27 -41 -42 -50 96 31 26 -66 9 74 34 31 25 6 -84 41 74 -7 49 5 35 -5 -71 -37 28 58 -8 -40 -19 -83 -34 64 7 15",
"output": "18/11"
},
{
"input": "0 0\n46\n-33",
"output": "-46/33"
},
{
"input": "67 67\n-8 11 55 80 -26 -38 58 73 -48 -10 35 75 16 -84 55 -51 98 58 -28 98 77 81 51 -86 -46 68 -87 -80 -49 81 96 -97 -42 25 6 -8 -55 -25 93 -29 -33 -6 -26 -85 73 97 63 57 51 92 -6 -8 4 86 46 -45 36 -19 -71 1 71 39 97 -44 -34 -1 2 -46\n91 -32 -76 11 -40 91 -8 -100 73 80 47 82 24 0 -71 82 -93 38 -54 1 -55 -53 90 -86 0 10 -35 49 90 56 25 17 46 -43 13 16 -82 -33 64 -83 -56 22 12 -74 4 -68 85 -27 60 -28 -47 73 -93 69 -37 54 -3 90 -56 56 78 61 7 -79 48 -42 -10 -48",
"output": "-8/91"
},
{
"input": "69 69\n-7 38 -3 -22 65 -78 -65 -99 -76 63 0 -4 -78 -51 54 -61 -53 60 80 34 -96 99 -78 -96 21 -10 -86 33 -9 -81 -19 -2 -76 -3 -66 -80 -55 -21 -50 37 -86 -37 47 44 76 -39 54 -25 41 -86 -3 -25 -67 94 18 67 27 -5 -30 -69 2 -76 7 -97 -52 -35 -55 -20 92 2\n90 -94 37 41 -27 -54 96 -15 -60 -29 -75 -93 -57 62 48 -88 -99 -62 4 -9 85 33 65 -95 -30 16 -29 -89 -33 -83 -35 -21 53 -52 80 -40 76 -33 86 47 18 43 -67 -36 -99 -42 1 -94 -78 34 -41 73 96 2 -60 29 68 -96 -21 -61 -98 -67 1 40 85 55 66 -25 -50 -83",
"output": "-7/90"
},
{
"input": "17 17\n-54 59 -95 87 3 -27 -30 49 -87 74 45 78 36 60 -95 41 -53 -70\n-27 16 -67 -24 10 -73 -41 12 -52 53 -73 -17 -56 -74 -33 -8 100 -39",
"output": "2/1"
},
{
"input": "1 1\n36 -49\n-32 -40",
"output": "-9/8"
},
{
"input": "1 1\n1 1\n1 1",
"output": "1/1"
},
{
"input": "1 1\n-2 1\n4 1",
"output": "-1/2"
},
{
"input": "0 0\n2\n1",
"output": "2/1"
},
{
"input": "0 0\n4\n-3",
"output": "-4/3"
},
{
"input": "0 0\n2\n2",
"output": "1/1"
},
{
"input": "0 0\n17\n-10",
"output": "-17/10"
},
{
"input": "0 0\n-1\n2",
"output": "-1/2"
},
{
"input": "0 0\n1\n1",
"output": "1/1"
},
{
"input": "0 0\n50\n20",
"output": "5/2"
},
{
"input": "0 0\n20\n20",
"output": "1/1"
},
{
"input": "0 0\n4\n-2",
"output": "-2/1"
},
{
"input": "0 0\n4\n-6",
"output": "-2/3"
},
{
"input": "0 0\n1\n-2",
"output": "-1/2"
},
{
"input": "0 0\n4\n2",
"output": "2/1"
},
{
"input": "0 0\n2\n-4",
"output": "-1/2"
},
{
"input": "1 1\n4 1\n2 1",
"output": "2/1"
},
{
"input": "2 2\n-13 1 3\n6 3 2",
"output": "-13/6"
},
{
"input": "99 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 1\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": "1/2"
},
{
"input": "0 0\n5\n5",
"output": "1/1"
},
{
"input": "0 0\n2\n-1",
"output": "-2/1"
}
] | 1,553,571,368
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 7
| 280
| 0
|
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
n,m=map(int,input().split())
p=[int(x) for x in input().split()]
q=[int(x) for x in input().split()]
if m>n:
print("0/1")
elif m<n:
if p[0]>0:
print("Infinity")
else:
print("-Infinity")
else:
g=gcd(p[0],q[0])
print(str(p[0]//g)+"/"+str(q[0]//g))
|
Title: Limit
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given two polynomials:
- *P*(*x*)<==<=*a*0·*x**n*<=+<=*a*1·*x**n*<=-<=1<=+<=...<=+<=*a**n*<=-<=1·*x*<=+<=*a**n* and - *Q*(*x*)<==<=*b*0·*x**m*<=+<=*b*1·*x**m*<=-<=1<=+<=...<=+<=*b**m*<=-<=1·*x*<=+<=*b**m*.
Calculate limit .
Input Specification:
The first line contains two space-separated integers *n* and *m* (0<=≤<=*n*,<=*m*<=≤<=100) — degrees of polynomials *P*(*x*) and *Q*(*x*) correspondingly.
The second line contains *n*<=+<=1 space-separated integers — the factors of polynomial *P*(*x*): *a*0, *a*1, ..., *a**n*<=-<=1, *a**n* (<=-<=100<=≤<=*a**i*<=≤<=100,<=*a*0<=≠<=0).
The third line contains *m*<=+<=1 space-separated integers — the factors of polynomial *Q*(*x*): *b*0, *b*1, ..., *b**m*<=-<=1, *b**m* (<=-<=100<=≤<=*b**i*<=≤<=100,<=*b*0<=≠<=0).
Output Specification:
If the limit equals <=+<=∞, print "Infinity" (without quotes). If the limit equals <=-<=∞, print "-Infinity" (without the quotes).
If the value of the limit equals zero, print "0/1" (without the quotes).
Otherwise, print an irreducible fraction — the value of limit , in the format "p/q" (without the quotes), where *p* is the — numerator, *q* (*q*<=><=0) is the denominator of the fraction.
Demo Input:
['2 1\n1 1 1\n2 5\n', '1 0\n-1 3\n2\n', '0 1\n1\n1 0\n', '2 2\n2 1 6\n4 5 -7\n', '1 1\n9 0\n-5 2\n']
Demo Output:
['Infinity\n', '-Infinity\n', '0/1\n', '1/2\n', '-9/5\n']
Note:
Let's consider all samples:
1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c28febca257452afdfcbd6984ba8623911f9bdbc.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1e55ecd04e54a45e5e0092ec9a5c1ea03bb29255.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/2c95fb684d373fcc1a481cfabeda4d5c2f3673ee.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/4dc40cb8b3cd6375c42445366e50369649a2801a.png" style="max-width: 100.0%;max-height: 100.0%;"/> 1. <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c6455aba35cfb3c4397505121d1f77afcd17c98e.png" style="max-width: 100.0%;max-height: 100.0%;"/>
You can learn more about the definition and properties of limits if you follow the link: http://en.wikipedia.org/wiki/Limit_of_a_function
|
```python
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
n,m=map(int,input().split())
p=[int(x) for x in input().split()]
q=[int(x) for x in input().split()]
if m>n:
print("0/1")
elif m<n:
if p[0]>0:
print("Infinity")
else:
print("-Infinity")
else:
g=gcd(p[0],q[0])
print(str(p[0]//g)+"/"+str(q[0]//g))
```
| 0
|
|
285
|
C
|
Building Permutation
|
PROGRAMMING
| 1,200
|
[
"greedy",
"implementation",
"sortings"
] | null | 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,697,565,172
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 33
| 296
| 40,038,400
|
n=int(input())
lis=list(map(int,input().split()))
lis.sort()
# 5 7 10 10 12 22
# 0 1 2 3 4 5
sum=0
for i in range(n):
sum+=abs(lis[i]-(i+1))
print(sum)
|
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())
lis=list(map(int,input().split()))
lis.sort()
# 5 7 10 10 12 22
# 0 1 2 3 4 5
sum=0
for i in range(n):
sum+=abs(lis[i]-(i+1))
print(sum)
```
| 3
|
|
803
|
A
|
Maximal Binary Matrix
|
PROGRAMMING
| 1,400
|
[
"constructive algorithms"
] | null | null |
You are given matrix with *n* rows and *n* columns filled with zeroes. You should put *k* ones in it in such a way that the resulting matrix is symmetrical with respect to the main diagonal (the diagonal that goes from the top left to the bottom right corner) and is lexicographically maximal.
One matrix is lexicographically greater than the other if the first different number in the first different row from the top in the first matrix is greater than the corresponding number in the second one.
If there exists no such matrix then output -1.
|
The first line consists of two numbers *n* and *k* (1<=≤<=*n*<=≤<=100, 0<=≤<=*k*<=≤<=106).
|
If the answer exists then output resulting matrix. Otherwise output -1.
|
[
"2 1\n",
"3 2\n",
"2 5\n"
] |
[
"1 0 \n0 0 \n",
"1 0 0 \n0 1 0 \n0 0 0 \n",
"-1\n"
] |
none
| 0
|
[
{
"input": "2 1",
"output": "1 0 \n0 0 "
},
{
"input": "3 2",
"output": "1 0 0 \n0 1 0 \n0 0 0 "
},
{
"input": "2 5",
"output": "-1"
},
{
"input": "1 0",
"output": "0 "
},
{
"input": "1 1",
"output": "1 "
},
{
"input": "20 398",
"output": "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 \n1 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 \n1 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 \n1 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 \n1 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 \n1 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 \n1 1 1 1..."
},
{
"input": "20 401",
"output": "-1"
},
{
"input": "100 3574",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1..."
},
{
"input": "100 10000",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1..."
},
{
"input": "100 10001",
"output": "-1"
},
{
"input": "2 3",
"output": "1 1 \n1 0 "
},
{
"input": "4 5",
"output": "1 1 1 0 \n1 0 0 0 \n1 0 0 0 \n0 0 0 0 "
},
{
"input": "5 6",
"output": "1 1 1 0 0 \n1 1 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 24",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 "
},
{
"input": "2 0",
"output": "0 0 \n0 0 "
},
{
"input": "3 5",
"output": "1 1 1 \n1 0 0 \n1 0 0 "
},
{
"input": "3 3",
"output": "1 1 0 \n1 0 0 \n0 0 0 "
},
{
"input": "5 10",
"output": "1 1 1 1 1 \n1 1 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "3 4",
"output": "1 1 0 \n1 1 0 \n0 0 0 "
},
{
"input": "4 3",
"output": "1 1 0 0 \n1 0 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "1 1000000",
"output": "-1"
},
{
"input": "3 6",
"output": "1 1 1 \n1 1 0 \n1 0 0 "
},
{
"input": "1 2",
"output": "-1"
},
{
"input": "1 0",
"output": "0 "
},
{
"input": "1 1",
"output": "1 "
},
{
"input": "1 2",
"output": "-1"
},
{
"input": "1 3",
"output": "-1"
},
{
"input": "1 4",
"output": "-1"
},
{
"input": "1 5",
"output": "-1"
},
{
"input": "1 6",
"output": "-1"
},
{
"input": "1 7",
"output": "-1"
},
{
"input": "1 8",
"output": "-1"
},
{
"input": "1 9",
"output": "-1"
},
{
"input": "1 10",
"output": "-1"
},
{
"input": "1 11",
"output": "-1"
},
{
"input": "1 12",
"output": "-1"
},
{
"input": "1 13",
"output": "-1"
},
{
"input": "1 14",
"output": "-1"
},
{
"input": "1 15",
"output": "-1"
},
{
"input": "1 16",
"output": "-1"
},
{
"input": "1 17",
"output": "-1"
},
{
"input": "1 18",
"output": "-1"
},
{
"input": "1 19",
"output": "-1"
},
{
"input": "1 20",
"output": "-1"
},
{
"input": "1 21",
"output": "-1"
},
{
"input": "1 22",
"output": "-1"
},
{
"input": "1 23",
"output": "-1"
},
{
"input": "1 24",
"output": "-1"
},
{
"input": "1 25",
"output": "-1"
},
{
"input": "1 26",
"output": "-1"
},
{
"input": "2 0",
"output": "0 0 \n0 0 "
},
{
"input": "2 1",
"output": "1 0 \n0 0 "
},
{
"input": "2 2",
"output": "1 0 \n0 1 "
},
{
"input": "2 3",
"output": "1 1 \n1 0 "
},
{
"input": "2 4",
"output": "1 1 \n1 1 "
},
{
"input": "2 5",
"output": "-1"
},
{
"input": "2 6",
"output": "-1"
},
{
"input": "2 7",
"output": "-1"
},
{
"input": "2 8",
"output": "-1"
},
{
"input": "2 9",
"output": "-1"
},
{
"input": "2 10",
"output": "-1"
},
{
"input": "2 11",
"output": "-1"
},
{
"input": "2 12",
"output": "-1"
},
{
"input": "2 13",
"output": "-1"
},
{
"input": "2 14",
"output": "-1"
},
{
"input": "2 15",
"output": "-1"
},
{
"input": "2 16",
"output": "-1"
},
{
"input": "2 17",
"output": "-1"
},
{
"input": "2 18",
"output": "-1"
},
{
"input": "2 19",
"output": "-1"
},
{
"input": "2 20",
"output": "-1"
},
{
"input": "2 21",
"output": "-1"
},
{
"input": "2 22",
"output": "-1"
},
{
"input": "2 23",
"output": "-1"
},
{
"input": "2 24",
"output": "-1"
},
{
"input": "2 25",
"output": "-1"
},
{
"input": "2 26",
"output": "-1"
},
{
"input": "3 0",
"output": "0 0 0 \n0 0 0 \n0 0 0 "
},
{
"input": "3 1",
"output": "1 0 0 \n0 0 0 \n0 0 0 "
},
{
"input": "3 2",
"output": "1 0 0 \n0 1 0 \n0 0 0 "
},
{
"input": "3 3",
"output": "1 1 0 \n1 0 0 \n0 0 0 "
},
{
"input": "3 4",
"output": "1 1 0 \n1 1 0 \n0 0 0 "
},
{
"input": "3 5",
"output": "1 1 1 \n1 0 0 \n1 0 0 "
},
{
"input": "3 6",
"output": "1 1 1 \n1 1 0 \n1 0 0 "
},
{
"input": "3 7",
"output": "1 1 1 \n1 1 0 \n1 0 1 "
},
{
"input": "3 8",
"output": "1 1 1 \n1 1 1 \n1 1 0 "
},
{
"input": "3 9",
"output": "1 1 1 \n1 1 1 \n1 1 1 "
},
{
"input": "3 10",
"output": "-1"
},
{
"input": "3 11",
"output": "-1"
},
{
"input": "3 12",
"output": "-1"
},
{
"input": "3 13",
"output": "-1"
},
{
"input": "3 14",
"output": "-1"
},
{
"input": "3 15",
"output": "-1"
},
{
"input": "3 16",
"output": "-1"
},
{
"input": "3 17",
"output": "-1"
},
{
"input": "3 18",
"output": "-1"
},
{
"input": "3 19",
"output": "-1"
},
{
"input": "3 20",
"output": "-1"
},
{
"input": "3 21",
"output": "-1"
},
{
"input": "3 22",
"output": "-1"
},
{
"input": "3 23",
"output": "-1"
},
{
"input": "3 24",
"output": "-1"
},
{
"input": "3 25",
"output": "-1"
},
{
"input": "3 26",
"output": "-1"
},
{
"input": "4 0",
"output": "0 0 0 0 \n0 0 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "4 1",
"output": "1 0 0 0 \n0 0 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "4 2",
"output": "1 0 0 0 \n0 1 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "4 3",
"output": "1 1 0 0 \n1 0 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "4 4",
"output": "1 1 0 0 \n1 1 0 0 \n0 0 0 0 \n0 0 0 0 "
},
{
"input": "4 5",
"output": "1 1 1 0 \n1 0 0 0 \n1 0 0 0 \n0 0 0 0 "
},
{
"input": "4 6",
"output": "1 1 1 0 \n1 1 0 0 \n1 0 0 0 \n0 0 0 0 "
},
{
"input": "4 7",
"output": "1 1 1 1 \n1 0 0 0 \n1 0 0 0 \n1 0 0 0 "
},
{
"input": "4 8",
"output": "1 1 1 1 \n1 1 0 0 \n1 0 0 0 \n1 0 0 0 "
},
{
"input": "4 9",
"output": "1 1 1 1 \n1 1 0 0 \n1 0 1 0 \n1 0 0 0 "
},
{
"input": "4 10",
"output": "1 1 1 1 \n1 1 1 0 \n1 1 0 0 \n1 0 0 0 "
},
{
"input": "4 11",
"output": "1 1 1 1 \n1 1 1 0 \n1 1 1 0 \n1 0 0 0 "
},
{
"input": "4 12",
"output": "1 1 1 1 \n1 1 1 1 \n1 1 0 0 \n1 1 0 0 "
},
{
"input": "4 13",
"output": "1 1 1 1 \n1 1 1 1 \n1 1 1 0 \n1 1 0 0 "
},
{
"input": "4 14",
"output": "1 1 1 1 \n1 1 1 1 \n1 1 1 0 \n1 1 0 1 "
},
{
"input": "4 15",
"output": "1 1 1 1 \n1 1 1 1 \n1 1 1 1 \n1 1 1 0 "
},
{
"input": "4 16",
"output": "1 1 1 1 \n1 1 1 1 \n1 1 1 1 \n1 1 1 1 "
},
{
"input": "4 17",
"output": "-1"
},
{
"input": "4 18",
"output": "-1"
},
{
"input": "4 19",
"output": "-1"
},
{
"input": "4 20",
"output": "-1"
},
{
"input": "4 21",
"output": "-1"
},
{
"input": "4 22",
"output": "-1"
},
{
"input": "4 23",
"output": "-1"
},
{
"input": "4 24",
"output": "-1"
},
{
"input": "4 25",
"output": "-1"
},
{
"input": "4 26",
"output": "-1"
},
{
"input": "5 0",
"output": "0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 1",
"output": "1 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 2",
"output": "1 0 0 0 0 \n0 1 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 3",
"output": "1 1 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 4",
"output": "1 1 0 0 0 \n1 1 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 5",
"output": "1 1 1 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 6",
"output": "1 1 1 0 0 \n1 1 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 7",
"output": "1 1 1 1 0 \n1 0 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 8",
"output": "1 1 1 1 0 \n1 1 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n0 0 0 0 0 "
},
{
"input": "5 9",
"output": "1 1 1 1 1 \n1 0 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 10",
"output": "1 1 1 1 1 \n1 1 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 11",
"output": "1 1 1 1 1 \n1 1 0 0 0 \n1 0 1 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 12",
"output": "1 1 1 1 1 \n1 1 1 0 0 \n1 1 0 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 13",
"output": "1 1 1 1 1 \n1 1 1 0 0 \n1 1 1 0 0 \n1 0 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 14",
"output": "1 1 1 1 1 \n1 1 1 1 0 \n1 1 0 0 0 \n1 1 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 15",
"output": "1 1 1 1 1 \n1 1 1 1 0 \n1 1 1 0 0 \n1 1 0 0 0 \n1 0 0 0 0 "
},
{
"input": "5 16",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 0 0 0 \n1 1 0 0 0 \n1 1 0 0 0 "
},
{
"input": "5 17",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 0 0 \n1 1 0 0 0 \n1 1 0 0 0 "
},
{
"input": "5 18",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 0 0 \n1 1 0 1 0 \n1 1 0 0 0 "
},
{
"input": "5 19",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 \n1 1 1 0 0 \n1 1 0 0 0 "
},
{
"input": "5 20",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 \n1 1 1 1 0 \n1 1 0 0 0 "
},
{
"input": "5 21",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 0 0 \n1 1 1 0 0 "
},
{
"input": "5 22",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 \n1 1 1 0 0 "
},
{
"input": "5 23",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 \n1 1 1 0 1 "
},
{
"input": "5 24",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 0 "
},
{
"input": "5 25",
"output": "1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 \n1 1 1 1 1 "
},
{
"input": "5 26",
"output": "-1"
},
{
"input": "100 0",
"output": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \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 \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..."
},
{
"input": "100 1",
"output": "1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \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 \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..."
},
{
"input": "100 2",
"output": "1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \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..."
},
{
"input": "100 3",
"output": "1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \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..."
},
{
"input": "100 99",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0..."
},
{
"input": "100 100",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0..."
},
{
"input": "100 101",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 \n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0..."
},
{
"input": "100 9999",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1..."
},
{
"input": "100 10000",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 1 1 1 1..."
},
{
"input": "100 10001",
"output": "-1"
}
] | 1,698,214,134
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 15
| 0
|
def create_symmetrical_matrix(n, k):
# 如果 k 大于最大的 1 的个数或者 k 为奇数但 n 为偶数，返回 -1
max_ones = (n * n) // 2
if k > max_ones or (k % 2 != 0 and n % 2 == 0):
return -1
# 创建一个填充 0 的矩阵
matrix = [[0]*n for _ in range(n)]
# 在主对角线上分配 k 个 1
for i in range(min(n, k)):
matrix[i][i] = 1
k -= 1
# 在上三角部分对称分配剩余的 1
row = 0
col = 1
while k > 0 and row < n and col < n:
if k >= 2:
matrix[row][col] = 1
matrix[col][row] = 1
k -= 2
else:
matrix[row][col] = 1
k -= 1
if col == n-1:
row += 1
col = row + 1
else:
col += 1
return matrix
# 读取输入
n, k = map(int, input().split())
# 调用解决方案函数并打印结果
result = create_symmetrical_matrix(n, k)
if result == -1:
print(-1)
else:
for row in result:
print(" ".join(map(str, row)))
|
Title: Maximal Binary Matrix
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given matrix with *n* rows and *n* columns filled with zeroes. You should put *k* ones in it in such a way that the resulting matrix is symmetrical with respect to the main diagonal (the diagonal that goes from the top left to the bottom right corner) and is lexicographically maximal.
One matrix is lexicographically greater than the other if the first different number in the first different row from the top in the first matrix is greater than the corresponding number in the second one.
If there exists no such matrix then output -1.
Input Specification:
The first line consists of two numbers *n* and *k* (1<=≤<=*n*<=≤<=100, 0<=≤<=*k*<=≤<=106).
Output Specification:
If the answer exists then output resulting matrix. Otherwise output -1.
Demo Input:
['2 1\n', '3 2\n', '2 5\n']
Demo Output:
['1 0 \n0 0 \n', '1 0 0 \n0 1 0 \n0 0 0 \n', '-1\n']
Note:
none
|
```python
def create_symmetrical_matrix(n, k):
# 如果 k 大于最大的 1 的个数或者 k 为奇数但 n 为偶数，返回 -1
max_ones = (n * n) // 2
if k > max_ones or (k % 2 != 0 and n % 2 == 0):
return -1
# 创建一个填充 0 的矩阵
matrix = [[0]*n for _ in range(n)]
# 在主对角线上分配 k 个 1
for i in range(min(n, k)):
matrix[i][i] = 1
k -= 1
# 在上三角部分对称分配剩余的 1
row = 0
col = 1
while k > 0 and row < n and col < n:
if k >= 2:
matrix[row][col] = 1
matrix[col][row] = 1
k -= 2
else:
matrix[row][col] = 1
k -= 1
if col == n-1:
row += 1
col = row + 1
else:
col += 1
return matrix
# 读取输入
n, k = map(int, input().split())
# 调用解决方案函数并打印结果
result = create_symmetrical_matrix(n, k)
if result == -1:
print(-1)
else:
for row in result:
print(" ".join(map(str, row)))
```
| 0
|
|
670
|
B
|
Game of Robots
|
PROGRAMMING
| 1,000
|
[
"implementation"
] | null | null |
In late autumn evening *n* robots gathered in the cheerful company of friends. Each robot has a unique identifier — an integer from 1 to 109.
At some moment, robots decided to play the game "Snowball". Below there are the rules of this game. First, all robots stand in a row. Then the first robot says his identifier. After that the second robot says the identifier of the first robot and then says his own identifier. Then the third robot says the identifier of the first robot, then says the identifier of the second robot and after that says his own. This process continues from left to right until the *n*-th robot says his identifier.
Your task is to determine the *k*-th identifier to be pronounced.
|
The first line contains two positive integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=*min*(2·109,<=*n*·(*n*<=+<=1)<=/<=2).
The second line contains the sequence *id*1,<=*id*2,<=...,<=*id**n* (1<=≤<=*id**i*<=≤<=109) — identifiers of roborts. It is guaranteed that all identifiers are different.
|
Print the *k*-th pronounced identifier (assume that the numeration starts from 1).
|
[
"2 2\n1 2\n",
"4 5\n10 4 18 3\n"
] |
[
"1\n",
"4\n"
] |
In the first sample identifiers of robots will be pronounced in the following order: 1, 1, 2. As *k* = 2, the answer equals to 1.
In the second test case identifiers of robots will be pronounced in the following order: 10, 10, 4, 10, 4, 18, 10, 4, 18, 3. As *k* = 5, the answer equals to 4.
| 750
|
[
{
"input": "2 2\n1 2",
"output": "1"
},
{
"input": "4 5\n10 4 18 3",
"output": "4"
},
{
"input": "1 1\n4",
"output": "4"
},
{
"input": "2 1\n5 1",
"output": "5"
},
{
"input": "2 2\n1 4",
"output": "1"
},
{
"input": "2 3\n6 7",
"output": "7"
},
{
"input": "3 1\n4 5 6",
"output": "4"
},
{
"input": "3 2\n4 5 6",
"output": "4"
},
{
"input": "3 3\n4 5 6",
"output": "5"
},
{
"input": "3 4\n4 5 6",
"output": "4"
},
{
"input": "3 5\n4 5 6",
"output": "5"
},
{
"input": "3 6\n4 5 6",
"output": "6"
},
{
"input": "4 1\n5 1000000000 999999999 12",
"output": "5"
},
{
"input": "4 2\n5 1000000000 999999999 12",
"output": "5"
},
{
"input": "4 3\n5 1000000000 999999999 12",
"output": "1000000000"
},
{
"input": "4 4\n5 1000000000 999999999 12",
"output": "5"
},
{
"input": "4 5\n5 1000000000 999999999 12",
"output": "1000000000"
},
{
"input": "4 6\n5 1000000000 999999999 12",
"output": "999999999"
},
{
"input": "4 7\n5 1000000000 999999999 12",
"output": "5"
},
{
"input": "4 8\n5 1000000000 999999999 12",
"output": "1000000000"
},
{
"input": "4 9\n5 1000000000 999999999 12",
"output": "999999999"
},
{
"input": "4 10\n5 1000000000 999999999 12",
"output": "12"
}
] | 1,638,097,780
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 143
| 78
| 7,065,600
|
def pos(n,k):
for i in range(1,n+1):
if((i-1) * i/2 < k and k <= i * (i+1)/2):
break;
k -= ((i-1) * (i/2)) + 1;
return int(k);
n, k = map(int,input().split(" "));
ids = input().split(" ");
print(ids[pos(n,k)]);
|
Title: Game of Robots
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In late autumn evening *n* robots gathered in the cheerful company of friends. Each robot has a unique identifier — an integer from 1 to 109.
At some moment, robots decided to play the game "Snowball". Below there are the rules of this game. First, all robots stand in a row. Then the first robot says his identifier. After that the second robot says the identifier of the first robot and then says his own identifier. Then the third robot says the identifier of the first robot, then says the identifier of the second robot and after that says his own. This process continues from left to right until the *n*-th robot says his identifier.
Your task is to determine the *k*-th identifier to be pronounced.
Input Specification:
The first line contains two positive integers *n* and *k* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*k*<=≤<=*min*(2·109,<=*n*·(*n*<=+<=1)<=/<=2).
The second line contains the sequence *id*1,<=*id*2,<=...,<=*id**n* (1<=≤<=*id**i*<=≤<=109) — identifiers of roborts. It is guaranteed that all identifiers are different.
Output Specification:
Print the *k*-th pronounced identifier (assume that the numeration starts from 1).
Demo Input:
['2 2\n1 2\n', '4 5\n10 4 18 3\n']
Demo Output:
['1\n', '4\n']
Note:
In the first sample identifiers of robots will be pronounced in the following order: 1, 1, 2. As *k* = 2, the answer equals to 1.
In the second test case identifiers of robots will be pronounced in the following order: 10, 10, 4, 10, 4, 18, 10, 4, 18, 3. As *k* = 5, the answer equals to 4.
|
```python
def pos(n,k):
for i in range(1,n+1):
if((i-1) * i/2 < k and k <= i * (i+1)/2):
break;
k -= ((i-1) * (i/2)) + 1;
return int(k);
n, k = map(int,input().split(" "));
ids = input().split(" ");
print(ids[pos(n,k)]);
```
| 3
|
|
799
|
B
|
T-shirt buying
|
PROGRAMMING
| 1,400
|
[
"data structures",
"implementation"
] | null | null |
A new pack of *n* t-shirts came to a shop. Each of the t-shirts is characterized by three integers *p**i*, *a**i* and *b**i*, where *p**i* is the price of the *i*-th t-shirt, *a**i* is front color of the *i*-th t-shirt and *b**i* is back color of the *i*-th t-shirt. All values *p**i* are distinct, and values *a**i* and *b**i* are integers from 1 to 3.
*m* buyers will come to the shop. Each of them wants to buy exactly one t-shirt. For the *j*-th buyer we know his favorite color *c**j*.
A buyer agrees to buy a t-shirt, if at least one side (front or back) is painted in his favorite color. Among all t-shirts that have colors acceptable to this buyer he will choose the cheapest one. If there are no such t-shirts, the buyer won't buy anything. Assume that the buyers come one by one, and each buyer is served only after the previous one is served.
You are to compute the prices each buyer will pay for t-shirts.
|
The first line contains single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of t-shirts.
The following line contains sequence of integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=1<=000<=000<=000), where *p**i* equals to the price of the *i*-th t-shirt.
The following line contains sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=3), where *a**i* equals to the front color of the *i*-th t-shirt.
The following line contains sequence of integers *b*1,<=*b*2,<=...,<=*b**n* (1<=≤<=*b**i*<=≤<=3), where *b**i* equals to the back color of the *i*-th t-shirt.
The next line contains single integer *m* (1<=≤<=*m*<=≤<=200<=000) — the number of buyers.
The following line contains sequence *c*1,<=*c*2,<=...,<=*c**m* (1<=≤<=*c**j*<=≤<=3), where *c**j* equals to the favorite color of the *j*-th buyer. The buyers will come to the shop in the order they are given in the input. Each buyer is served only after the previous one is served.
|
Print to the first line *m* integers — the *j*-th integer should be equal to the price of the t-shirt which the *j*-th buyer will buy. If the *j*-th buyer won't buy anything, print -1.
|
[
"5\n300 200 400 500 911\n1 2 1 2 3\n2 1 3 2 1\n6\n2 3 1 2 1 1\n",
"2\n1000000000 1\n1 1\n1 2\n2\n2 1\n"
] |
[
"200 400 300 500 911 -1 \n",
"1 1000000000 \n"
] |
none
| 1,000
|
[
{
"input": "5\n300 200 400 500 911\n1 2 1 2 3\n2 1 3 2 1\n6\n2 3 1 2 1 1",
"output": "200 400 300 500 911 -1 "
},
{
"input": "2\n1000000000 1\n1 1\n1 2\n2\n2 1",
"output": "1 1000000000 "
},
{
"input": "10\n251034796 163562337 995167403 531046374 341924810 828969071 971837553 183763940 857690534 687685084\n3 2 1 3 2 3 1 3 2 1\n2 3 3 1 2 3 2 3 3 2\n10\n1 3 2 3 2 3 3 1 2 3",
"output": "531046374 163562337 251034796 183763940 341924810 828969071 857690534 687685084 971837553 995167403 "
},
{
"input": "20\n414468312 20329584 106106409 584924603 666547477 670032002 726095027 276840253 368277336 940941705 531635095 213813062 440421387 959075599 240727854 495316522 838268432 786936631 586382273 806443734\n3 1 2 3 3 2 2 1 3 2 3 2 3 3 3 2 1 3 1 2\n3 1 2 2 2 2 3 1 2 3 2 1 1 2 3 1 2 3 3 2\n40\n1 1 2 1 3 2 3 1 3 3 1 2 3 1 1 1 2 3 3 1 3 1 3 1 2 2 3 3 1 2 1 2 3 2 2 1 2 1 2 2",
"output": "20329584 213813062 106106409 276840253 240727854 368277336 414468312 440421387 531635095 584924603 495316522 666547477 586382273 838268432 -1 -1 670032002 726095027 786936631 -1 940941705 -1 959075599 -1 806443734 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 "
},
{
"input": "1\n529469903\n1\n3\n1\n3",
"output": "529469903 "
}
] | 1,683,101,435
| 2,147,483,647
|
Python 3
|
COMPILATION_ERROR
|
TESTS
| 0
| 0
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int num_items;
cin >> num_items;
vector<int> prices;
set<int> sets[3];
for (int i = 0, price; i < num_items; i++)
{
cin >> price;
prices.push_back(price);
}
for (int i = 0, type; i < 2 * num_items; i++)
{
cin >> type;
sets[type - 1].insert(prices[i % num_items]);
}
int num_queries;
cin >> num_queries;
while (num_queries--)
{
int type;
cin >> type;
set<int>::iterator it;
it = sets[type - 1].begin();
if (sets[type - 1].size() == 0)
cout << "-1 ";
else
{
int price = *it;
cout << price << " ";
sets[0].erase(price);
sets[1].erase(price);
sets[2].erase(price);
}
}
return 0;
}
|
Title: T-shirt buying
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A new pack of *n* t-shirts came to a shop. Each of the t-shirts is characterized by three integers *p**i*, *a**i* and *b**i*, where *p**i* is the price of the *i*-th t-shirt, *a**i* is front color of the *i*-th t-shirt and *b**i* is back color of the *i*-th t-shirt. All values *p**i* are distinct, and values *a**i* and *b**i* are integers from 1 to 3.
*m* buyers will come to the shop. Each of them wants to buy exactly one t-shirt. For the *j*-th buyer we know his favorite color *c**j*.
A buyer agrees to buy a t-shirt, if at least one side (front or back) is painted in his favorite color. Among all t-shirts that have colors acceptable to this buyer he will choose the cheapest one. If there are no such t-shirts, the buyer won't buy anything. Assume that the buyers come one by one, and each buyer is served only after the previous one is served.
You are to compute the prices each buyer will pay for t-shirts.
Input Specification:
The first line contains single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of t-shirts.
The following line contains sequence of integers *p*1,<=*p*2,<=...,<=*p**n* (1<=≤<=*p**i*<=≤<=1<=000<=000<=000), where *p**i* equals to the price of the *i*-th t-shirt.
The following line contains sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=3), where *a**i* equals to the front color of the *i*-th t-shirt.
The following line contains sequence of integers *b*1,<=*b*2,<=...,<=*b**n* (1<=≤<=*b**i*<=≤<=3), where *b**i* equals to the back color of the *i*-th t-shirt.
The next line contains single integer *m* (1<=≤<=*m*<=≤<=200<=000) — the number of buyers.
The following line contains sequence *c*1,<=*c*2,<=...,<=*c**m* (1<=≤<=*c**j*<=≤<=3), where *c**j* equals to the favorite color of the *j*-th buyer. The buyers will come to the shop in the order they are given in the input. Each buyer is served only after the previous one is served.
Output Specification:
Print to the first line *m* integers — the *j*-th integer should be equal to the price of the t-shirt which the *j*-th buyer will buy. If the *j*-th buyer won't buy anything, print -1.
Demo Input:
['5\n300 200 400 500 911\n1 2 1 2 3\n2 1 3 2 1\n6\n2 3 1 2 1 1\n', '2\n1000000000 1\n1 1\n1 2\n2\n2 1\n']
Demo Output:
['200 400 300 500 911 -1 \n', '1 1000000000 \n']
Note:
none
|
```python
#include <bits/stdc++.h>
using namespace std;
int main()
{
int num_items;
cin >> num_items;
vector<int> prices;
set<int> sets[3];
for (int i = 0, price; i < num_items; i++)
{
cin >> price;
prices.push_back(price);
}
for (int i = 0, type; i < 2 * num_items; i++)
{
cin >> type;
sets[type - 1].insert(prices[i % num_items]);
}
int num_queries;
cin >> num_queries;
while (num_queries--)
{
int type;
cin >> type;
set<int>::iterator it;
it = sets[type - 1].begin();
if (sets[type - 1].size() == 0)
cout << "-1 ";
else
{
int price = *it;
cout << price << " ";
sets[0].erase(price);
sets[1].erase(price);
sets[2].erase(price);
}
}
return 0;
}
```
| -1
|
|
116
|
A
|
Tram
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Linear Kingdom has exactly one tram line. It has *n* stops, numbered from 1 to *n* in the order of tram's movement. At the *i*-th stop *a**i* passengers exit the tram, while *b**i* passengers enter it. The tram is empty before it arrives at the first stop. Also, when the tram arrives at the last stop, all passengers exit so that it becomes empty.
Your task is to calculate the tram's minimum capacity such that the number of people inside the tram at any time never exceeds this capacity. Note that at each stop all exiting passengers exit before any entering passenger enters the tram.
|
The first line contains a single number *n* (2<=≤<=*n*<=≤<=1000) — the number of the tram's stops.
Then *n* lines follow, each contains two integers *a**i* and *b**i* (0<=≤<=*a**i*,<=*b**i*<=≤<=1000) — the number of passengers that exits the tram at the *i*-th stop, and the number of passengers that enter the tram at the *i*-th stop. The stops are given from the first to the last stop in the order of tram's movement.
- The number of people who exit at a given stop does not exceed the total number of people in the tram immediately before it arrives at the stop. More formally, . This particularly means that *a*1<==<=0. - At the last stop, all the passengers exit the tram and it becomes empty. More formally, . - No passenger will enter the train at the last stop. That is, *b**n*<==<=0.
|
Print a single integer denoting the minimum possible capacity of the tram (0 is allowed).
|
[
"4\n0 3\n2 5\n4 2\n4 0\n"
] |
[
"6\n"
] |
For the first example, a capacity of 6 is sufficient:
- At the first stop, the number of passengers inside the tram before arriving is 0. Then, 3 passengers enter the tram, and the number of passengers inside the tram becomes 3. - At the second stop, 2 passengers exit the tram (1 passenger remains inside). Then, 5 passengers enter the tram. There are 6 passengers inside the tram now. - At the third stop, 4 passengers exit the tram (2 passengers remain inside). Then, 2 passengers enter the tram. There are 4 passengers inside the tram now. - Finally, all the remaining passengers inside the tram exit the tram at the last stop. There are no passenger inside the tram now, which is in line with the constraints.
Since the number of passengers inside the tram never exceeds 6, a capacity of 6 is sufficient. Furthermore it is not possible for the tram to have a capacity less than 6. Hence, 6 is the correct answer.
| 500
|
[
{
"input": "4\n0 3\n2 5\n4 2\n4 0",
"output": "6"
},
{
"input": "5\n0 4\n4 6\n6 5\n5 4\n4 0",
"output": "6"
},
{
"input": "10\n0 5\n1 7\n10 8\n5 3\n0 5\n3 3\n8 8\n0 6\n10 1\n9 0",
"output": "18"
},
{
"input": "3\n0 1\n1 1\n1 0",
"output": "1"
},
{
"input": "4\n0 1\n0 1\n1 0\n1 0",
"output": "2"
},
{
"input": "3\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "3\n0 1000\n1000 1000\n1000 0",
"output": "1000"
},
{
"input": "5\n0 73\n73 189\n189 766\n766 0\n0 0",
"output": "766"
},
{
"input": "5\n0 0\n0 0\n0 0\n0 1\n1 0",
"output": "1"
},
{
"input": "5\n0 917\n917 923\n904 992\n1000 0\n11 0",
"output": "1011"
},
{
"input": "5\n0 1\n1 2\n2 1\n1 2\n2 0",
"output": "2"
},
{
"input": "5\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "20\n0 7\n2 1\n2 2\n5 7\n2 6\n6 10\n2 4\n0 4\n7 4\n8 0\n10 6\n2 1\n6 1\n1 7\n0 3\n8 7\n6 3\n6 3\n1 1\n3 0",
"output": "22"
},
{
"input": "5\n0 1000\n1000 1000\n1000 1000\n1000 1000\n1000 0",
"output": "1000"
},
{
"input": "10\n0 592\n258 598\n389 203\n249 836\n196 635\n478 482\n994 987\n1000 0\n769 0\n0 0",
"output": "1776"
},
{
"input": "10\n0 1\n1 0\n0 0\n0 0\n0 0\n0 1\n1 1\n0 1\n1 0\n1 0",
"output": "2"
},
{
"input": "10\n0 926\n926 938\n938 931\n931 964\n937 989\n983 936\n908 949\n997 932\n945 988\n988 0",
"output": "1016"
},
{
"input": "10\n0 1\n1 2\n1 2\n2 2\n2 2\n2 2\n1 1\n1 1\n2 1\n2 0",
"output": "3"
},
{
"input": "10\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "10\n0 1000\n1000 1000\n1000 1000\n1000 1000\n1000 1000\n1000 1000\n1000 1000\n1000 1000\n1000 1000\n1000 0",
"output": "1000"
},
{
"input": "50\n0 332\n332 268\n268 56\n56 711\n420 180\n160 834\n149 341\n373 777\n763 93\n994 407\n86 803\n700 132\n471 608\n429 467\n75 5\n638 305\n405 853\n316 478\n643 163\n18 131\n648 241\n241 766\n316 847\n640 380\n923 759\n789 41\n125 421\n421 9\n9 388\n388 829\n408 108\n462 856\n816 411\n518 688\n290 7\n405 912\n397 772\n396 652\n394 146\n27 648\n462 617\n514 433\n780 35\n710 705\n460 390\n194 508\n643 56\n172 469\n1000 0\n194 0",
"output": "2071"
},
{
"input": "50\n0 0\n0 1\n1 1\n0 1\n0 0\n1 0\n0 0\n1 0\n0 0\n0 0\n0 0\n0 0\n0 1\n0 0\n0 0\n0 1\n1 0\n0 1\n0 0\n1 1\n1 0\n0 1\n0 0\n1 1\n0 1\n1 0\n1 1\n1 0\n0 0\n1 1\n1 0\n0 1\n0 0\n0 1\n1 1\n1 1\n1 1\n1 0\n1 1\n1 0\n0 1\n1 0\n0 0\n0 1\n1 1\n1 1\n0 1\n0 0\n1 0\n1 0",
"output": "3"
},
{
"input": "50\n0 926\n926 971\n915 980\n920 965\n954 944\n928 952\n955 980\n916 980\n906 935\n944 913\n905 923\n912 922\n965 934\n912 900\n946 930\n931 983\n979 905\n925 969\n924 926\n910 914\n921 977\n934 979\n962 986\n942 909\n976 903\n982 982\n991 941\n954 929\n902 980\n947 983\n919 924\n917 943\n916 905\n907 913\n964 977\n984 904\n905 999\n950 970\n986 906\n993 970\n960 994\n963 983\n918 986\n980 900\n931 986\n993 997\n941 909\n907 909\n1000 0\n278 0",
"output": "1329"
},
{
"input": "2\n0 863\n863 0",
"output": "863"
},
{
"input": "50\n0 1\n1 2\n2 2\n1 1\n1 1\n1 2\n1 2\n1 1\n1 2\n1 1\n1 1\n1 2\n1 2\n1 1\n2 1\n2 2\n1 2\n2 2\n1 2\n2 1\n2 1\n2 2\n2 1\n1 2\n1 2\n2 1\n1 1\n2 2\n1 1\n2 1\n2 2\n2 1\n1 2\n2 2\n1 2\n1 1\n1 1\n2 1\n2 1\n2 2\n2 1\n2 1\n1 2\n1 2\n1 2\n1 2\n2 0\n2 0\n2 0\n0 0",
"output": "8"
},
{
"input": "50\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "100\n0 1\n0 0\n0 0\n1 0\n0 0\n0 1\n0 1\n1 1\n0 0\n0 0\n1 1\n0 0\n1 1\n0 1\n1 1\n0 1\n1 1\n1 0\n1 0\n0 0\n1 0\n0 1\n1 0\n0 0\n0 0\n1 1\n1 1\n0 1\n0 0\n1 0\n1 1\n0 1\n1 0\n1 1\n0 1\n1 1\n1 0\n0 0\n0 0\n0 1\n0 0\n0 1\n1 1\n0 0\n1 1\n1 1\n0 0\n0 1\n1 0\n0 1\n0 0\n0 1\n0 1\n1 1\n1 1\n1 1\n0 0\n0 0\n1 1\n0 1\n0 1\n1 0\n0 0\n0 0\n1 1\n0 1\n0 1\n1 1\n1 1\n0 1\n1 1\n1 1\n0 0\n1 0\n0 1\n0 0\n0 0\n1 1\n1 1\n1 1\n1 1\n0 1\n1 0\n1 0\n1 0\n1 0\n1 0\n0 0\n1 0\n1 0\n0 0\n1 0\n0 0\n0 1\n1 0\n0 1\n1 0\n1 0\n1 0\n1 0",
"output": "11"
},
{
"input": "100\n0 2\n1 2\n2 1\n1 2\n1 2\n2 1\n2 2\n1 1\n1 1\n2 1\n1 2\n2 1\n1 2\n2 2\n2 2\n2 2\n1 2\n2 2\n2 1\n1 1\n1 1\n1 1\n2 2\n1 2\n2 2\n1 1\n1 1\n1 1\n1 1\n2 2\n1 2\n2 1\n1 1\n2 2\n1 1\n2 1\n1 1\n2 2\n2 1\n1 2\n1 1\n1 2\n2 1\n2 2\n1 1\n2 1\n1 1\n2 1\n1 1\n1 2\n2 2\n2 2\n1 1\n2 2\n1 2\n2 1\n2 1\n1 1\n1 1\n1 2\n1 2\n1 1\n1 1\n2 1\n1 2\n1 2\n2 1\n2 2\n2 2\n2 2\n2 1\n2 2\n1 1\n1 2\n1 2\n1 1\n2 2\n2 2\n1 1\n2 1\n1 1\n1 2\n1 2\n1 2\n1 1\n1 1\n2 2\n1 2\n2 1\n2 1\n2 1\n1 2\n1 2\n1 1\n2 2\n1 2\n2 0\n2 0\n2 0\n1 0",
"output": "7"
},
{
"input": "100\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0\n0 0",
"output": "0"
},
{
"input": "2\n0 1\n1 0",
"output": "1"
},
{
"input": "2\n0 900\n900 0",
"output": "900"
},
{
"input": "2\n0 1\n1 0",
"output": "1"
},
{
"input": "2\n0 0\n0 0",
"output": "0"
},
{
"input": "2\n0 1000\n1000 0",
"output": "1000"
},
{
"input": "3\n0 802\n175 188\n815 0",
"output": "815"
},
{
"input": "3\n0 910\n910 976\n976 0",
"output": "976"
},
{
"input": "3\n0 2\n2 1\n1 0",
"output": "2"
}
] | 1,694,618,446
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 60
| 0
|
n = int(input())
my_list = [[int(j) for j in input().split()] for _ in range(n)]
count = 0
res = 0
for i in range(1, n + 1):
if i == n:
break
elif i == 1:
count += (my_list[i - 1][1] - my_list[i][0]) + my_list[i][1]
else:
res = count - my_list[i][0] + my_list[i][1]
if count < res:
count = res
print(count)
|
Title: Tram
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Linear Kingdom has exactly one tram line. It has *n* stops, numbered from 1 to *n* in the order of tram's movement. At the *i*-th stop *a**i* passengers exit the tram, while *b**i* passengers enter it. The tram is empty before it arrives at the first stop. Also, when the tram arrives at the last stop, all passengers exit so that it becomes empty.
Your task is to calculate the tram's minimum capacity such that the number of people inside the tram at any time never exceeds this capacity. Note that at each stop all exiting passengers exit before any entering passenger enters the tram.
Input Specification:
The first line contains a single number *n* (2<=≤<=*n*<=≤<=1000) — the number of the tram's stops.
Then *n* lines follow, each contains two integers *a**i* and *b**i* (0<=≤<=*a**i*,<=*b**i*<=≤<=1000) — the number of passengers that exits the tram at the *i*-th stop, and the number of passengers that enter the tram at the *i*-th stop. The stops are given from the first to the last stop in the order of tram's movement.
- The number of people who exit at a given stop does not exceed the total number of people in the tram immediately before it arrives at the stop. More formally, . This particularly means that *a*1<==<=0. - At the last stop, all the passengers exit the tram and it becomes empty. More formally, . - No passenger will enter the train at the last stop. That is, *b**n*<==<=0.
Output Specification:
Print a single integer denoting the minimum possible capacity of the tram (0 is allowed).
Demo Input:
['4\n0 3\n2 5\n4 2\n4 0\n']
Demo Output:
['6\n']
Note:
For the first example, a capacity of 6 is sufficient:
- At the first stop, the number of passengers inside the tram before arriving is 0. Then, 3 passengers enter the tram, and the number of passengers inside the tram becomes 3. - At the second stop, 2 passengers exit the tram (1 passenger remains inside). Then, 5 passengers enter the tram. There are 6 passengers inside the tram now. - At the third stop, 4 passengers exit the tram (2 passengers remain inside). Then, 2 passengers enter the tram. There are 4 passengers inside the tram now. - Finally, all the remaining passengers inside the tram exit the tram at the last stop. There are no passenger inside the tram now, which is in line with the constraints.
Since the number of passengers inside the tram never exceeds 6, a capacity of 6 is sufficient. Furthermore it is not possible for the tram to have a capacity less than 6. Hence, 6 is the correct answer.
|
```python
n = int(input())
my_list = [[int(j) for j in input().split()] for _ in range(n)]
count = 0
res = 0
for i in range(1, n + 1):
if i == n:
break
elif i == 1:
count += (my_list[i - 1][1] - my_list[i][0]) + my_list[i][1]
else:
res = count - my_list[i][0] + my_list[i][1]
if count < res:
count = res
print(count)
```
| 0
|
|
219
|
A
|
k-String
|
PROGRAMMING
| 1,000
|
[
"implementation",
"strings"
] | null | null |
A string is called a *k*-string if it can be represented as *k* concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string *s*, consisting of lowercase English letters and a positive integer *k*. Your task is to reorder the letters in the string *s* in such a way that the resulting string is a *k*-string.
|
The first input line contains integer *k* (1<=≤<=*k*<=≤<=1000). The second line contains *s*, all characters in *s* are lowercase English letters. The string length *s* satisfies the inequality 1<=≤<=|*s*|<=≤<=1000, where |*s*| is the length of string *s*.
|
Rearrange the letters in string *s* in such a way that the result is a *k*-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
|
[
"2\naazz\n",
"3\nabcabcabz\n"
] |
[
"azaz\n",
"-1\n"
] |
none
| 500
|
[
{
"input": "2\naazz",
"output": "azaz"
},
{
"input": "3\nabcabcabz",
"output": "-1"
},
{
"input": "1\na",
"output": "a"
},
{
"input": "2\nabba",
"output": "abab"
},
{
"input": "2\naaab",
"output": "-1"
},
{
"input": "7\nabacaba",
"output": "-1"
},
{
"input": "5\naaaaa",
"output": "aaaaa"
},
{
"input": "3\naabaaaaabb",
"output": "-1"
},
{
"input": "2\naaab",
"output": "-1"
},
{
"input": "2\nbabac",
"output": "-1"
},
{
"input": "3\nbbbccc",
"output": "bcbcbc"
},
{
"input": "2\naa",
"output": "aa"
},
{
"input": "250\ncececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececece",
"output": "cececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececece"
},
{
"input": "15\nabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaaabaabbbcababaaa",
"output": "aaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbcaaaaaaaabbbbbbc"
},
{
"input": "1\naaa",
"output": "aaa"
},
{
"input": "1\naabaab",
"output": "aaaabb"
},
{
"input": "2\naabbbbccccccdddddddd",
"output": "abbcccddddabbcccdddd"
},
{
"input": "3\naaaaaaaaacccdddddd",
"output": "aaacddaaacddaaacdd"
},
{
"input": "3\naaaaaaaaacccbbbbbb",
"output": "aaabbcaaabbcaaabbc"
},
{
"input": "2\naazzzz",
"output": "azzazz"
},
{
"input": "2\naaaa",
"output": "aaaa"
},
{
"input": "2\naaaazz",
"output": "aazaaz"
},
{
"input": "2\naaaabb",
"output": "aabaab"
},
{
"input": "2\naabbbb",
"output": "abbabb"
},
{
"input": "2\naaaazzzz",
"output": "aazzaazz"
},
{
"input": "2\naaazz",
"output": "-1"
},
{
"input": "2\nbbbbaa",
"output": "abbabb"
},
{
"input": "2\naaaaaabbbb",
"output": "aaabbaaabb"
},
{
"input": "2\naaaaaazz",
"output": "aaazaaaz"
},
{
"input": "2\naaaabbbb",
"output": "aabbaabb"
},
{
"input": "2\naabaab",
"output": "aabaab"
},
{
"input": "1\naaaaa",
"output": "aaaaa"
},
{
"input": "2\nbbaaaa",
"output": "aabaab"
},
{
"input": "2\nacaccc",
"output": "accacc"
}
] | 1,685,377,434
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 30
| 0
|
k, string = int(input()), input()
mem = {}
for chr in string:
mem[chr] = 1 + mem.get(chr, 0)
# Check if the string can be rearranged
for v in mem.values():
if v % k != 0:
print(-1)
exit()
s = ""
for key in mem.keys():
s += mem[key] * key
print(s)
|
Title: k-String
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A string is called a *k*-string if it can be represented as *k* concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string *s*, consisting of lowercase English letters and a positive integer *k*. Your task is to reorder the letters in the string *s* in such a way that the resulting string is a *k*-string.
Input Specification:
The first input line contains integer *k* (1<=≤<=*k*<=≤<=1000). The second line contains *s*, all characters in *s* are lowercase English letters. The string length *s* satisfies the inequality 1<=≤<=|*s*|<=≤<=1000, where |*s*| is the length of string *s*.
Output Specification:
Rearrange the letters in string *s* in such a way that the result is a *k*-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Demo Input:
['2\naazz\n', '3\nabcabcabz\n']
Demo Output:
['azaz\n', '-1\n']
Note:
none
|
```python
k, string = int(input()), input()
mem = {}
for chr in string:
mem[chr] = 1 + mem.get(chr, 0)
# Check if the string can be rearranged
for v in mem.values():
if v % k != 0:
print(-1)
exit()
s = ""
for key in mem.keys():
s += mem[key] * key
print(s)
```
| 0
|
|
263
|
A
|
Beautiful Matrix
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes *i* and *i*<=+<=1 for some integer *i* (1<=≤<=*i*<=<<=5). 1. Swap two neighboring matrix columns, that is, columns with indexes *j* and *j*<=+<=1 for some integer *j* (1<=≤<=*j*<=<<=5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
|
The input consists of five lines, each line contains five integers: the *j*-th integer in the *i*-th line of the input represents the element of the matrix that is located on the intersection of the *i*-th row and the *j*-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
|
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
|
[
"0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n",
"0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n"
] |
[
"3\n",
"1\n"
] |
none
| 500
|
[
{
"input": "0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "1"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "0"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1",
"output": "4"
},
{
"input": "0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "4"
},
{
"input": "0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "4"
},
{
"input": "0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "1"
},
{
"input": "0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0",
"output": "1"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0",
"output": "1"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0",
"output": "4"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0",
"output": "3"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0",
"output": "2"
},
{
"input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0",
"output": "3"
}
] | 1,698,887,149
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 25
| 124
| 0
|
matrix = []
for i in range(5):
inp = input().split()
if "1" in inp:
y = i
x = inp.index("1")
break
print(abs(x - 2) + abs(y - 2))
|
Title: Beautiful Matrix
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes *i* and *i*<=+<=1 for some integer *i* (1<=≤<=*i*<=<<=5). 1. Swap two neighboring matrix columns, that is, columns with indexes *j* and *j*<=+<=1 for some integer *j* (1<=≤<=*j*<=<<=5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input Specification:
The input consists of five lines, each line contains five integers: the *j*-th integer in the *i*-th line of the input represents the element of the matrix that is located on the intersection of the *i*-th row and the *j*-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output Specification:
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Demo Input:
['0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n', '0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n']
Demo Output:
['3\n', '1\n']
Note:
none
|
```python
matrix = []
for i in range(5):
inp = input().split()
if "1" in inp:
y = i
x = inp.index("1")
break
print(abs(x - 2) + abs(y - 2))
```
| 3
|
|
846
|
A
|
Curriculum Vitae
|
PROGRAMMING
| 1,500
|
[
"brute force",
"implementation"
] | null | null |
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
|
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100).
The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
|
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
|
[
"4\n1 1 0 1\n",
"6\n0 1 0 0 1 0\n",
"1\n0\n"
] |
[
"3\n",
"4\n",
"1\n"
] |
none
| 0
|
[
{
"input": "4\n1 1 0 1",
"output": "3"
},
{
"input": "6\n0 1 0 0 1 0",
"output": "4"
},
{
"input": "1\n0",
"output": "1"
},
{
"input": "100\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
"output": "100"
},
{
"input": "100\n0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0",
"output": "80"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "100\n1 1 0 1 1 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 1 1 1 1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 0 0 1 0 1 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 0 1 1 1 0 0 1 1 0 0 0 0 1",
"output": "53"
},
{
"input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "100"
},
{
"input": "3\n1 0 0",
"output": "2"
},
{
"input": "10\n1 1 0 0 0 1 1 0 0 0",
"output": "6"
},
{
"input": "90\n1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 0 1 1 0 0 1 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 1 0",
"output": "52"
},
{
"input": "78\n0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 0 1 0",
"output": "42"
},
{
"input": "4\n1 0 0 1",
"output": "3"
},
{
"input": "2\n0 1",
"output": "2"
},
{
"input": "5\n0 1 0 0 1",
"output": "4"
},
{
"input": "3\n1 0 1",
"output": "2"
},
{
"input": "3\n1 1 0",
"output": "2"
},
{
"input": "16\n1 1 1 1 1 0 0 0 0 0 1 0 1 0 0 1",
"output": "9"
}
] | 1,690,465,620
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 18
| 62
| 0
|
n=int(input())
x=[int(i) for i in input().split()]
b=x.count(1)
m=0
y=0
for i in x:
if i==1:
m=max(m,y+b)
b-=1
else:
y+=1
m=max(m,y+b)
print(m)
|
Title: Curriculum Vitae
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced *n* games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array *s*1,<=*s*2,<=...,<=*s**n* of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input Specification:
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=100).
The second line contains *n* space-separated integer numbers *s*1,<=*s*2,<=...,<=*s**n* (0<=≤<=*s**i*<=≤<=1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output Specification:
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Demo Input:
['4\n1 1 0 1\n', '6\n0 1 0 0 1 0\n', '1\n0\n']
Demo Output:
['3\n', '4\n', '1\n']
Note:
none
|
```python
n=int(input())
x=[int(i) for i in input().split()]
b=x.count(1)
m=0
y=0
for i in x:
if i==1:
m=max(m,y+b)
b-=1
else:
y+=1
m=max(m,y+b)
print(m)
```
| 3
|
|
858
|
C
|
Did you mean...
|
PROGRAMMING
| 1,500
|
[
"dp",
"greedy",
"implementation"
] | null | null |
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
- the following words have typos: "hellno", "hackcerrs" and "backtothefutttture"; - the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
|
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
|
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
|
[
"hellno\n",
"abacaba\n",
"asdfasdf\n"
] |
[
"hell no \n",
"abacaba \n",
"asd fasd f \n"
] |
none
| 1,500
|
[
{
"input": "hellno",
"output": "hell no "
},
{
"input": "abacaba",
"output": "abacaba "
},
{
"input": "asdfasdf",
"output": "asd fasd f "
},
{
"input": "ooo",
"output": "ooo "
},
{
"input": "moyaoborona",
"output": "moyaoborona "
},
{
"input": "jxegxxx",
"output": "jxegx xx "
},
{
"input": "orfyaenanabckumulsboloyhljhacdgcmnooxvxrtuhcslxgslfpnfnyejbxqisxjyoyvcvuddboxkqgbogkfz",
"output": "orf yaenanabc kumuls boloyh lj hacd gc mnooxv xr tuhc sl xg sl fp nf nyejb xqisx jyoyv cvudd boxk qg bogk fz "
},
{
"input": "zxdgmhsjotvajkwshjpvzcuwehpeyfhakhtlvuoftkgdmvpafmxcliqvrztloocziqdkexhzcbdgxaoyvte",
"output": "zx dg mh sjotvajk ws hj pv zcuwehpeyf hakh tl vuoft kg dm vpafm xc liqv rz tloocziqd kexh zc bd gxaoyv te "
},
{
"input": "niblehmwtycadhbfuginpyafszjbucaszihijndzjtuyuaxkrovotshtsajmdcflnfdmahzbvpymiczqqleedpofcnvhieknlz",
"output": "niblehm wt ycadh bfuginp yafs zj bucaszihijn dz jtuyuaxk rovots ht sajm dc fl nf dmahz bv py micz qq leedpofc nv hiekn lz "
},
{
"input": "pqvtgtctpkgjgxnposjqedofficoyznxlerxyqypyzpoehejtjvyafjxjppywwgeakf",
"output": "pq vt gt ct pk gj gx nposj qedofficoyz nx lerx yq yp yz poehejt jv yafj xj pp yw wgeakf "
},
{
"input": "mvjajoyeg",
"output": "mv jajoyeg "
},
{
"input": "dipxocwjosvdaillxolmthjhzhsxskzqslebpixpuhpgeesrkedhohisdsjsrkiktbjzlhectrfcathvewzficirqbdvzq",
"output": "dipxocw josv daill xolm th jh zh sx sk zq slebpixpuhp geesr kedhohisd sj sr kikt bj zl hect rf cath vewz ficirq bd vz q "
},
{
"input": "ibbtvelwjirxqermucqrgmoauonisgmarjxxybllktccdykvef",
"output": "ibb tvelw jirx qermucq rg moauonisg marj xx yb ll kt cc dy kvef "
},
{
"input": "jxevkmrwlomaaahaubvjzqtyfqhqbhpqhomxqpiuersltohinvfyeykmlooujymldjqhgqjkvqknlyj",
"output": "jxevk mr wlomaaahaubv jz qt yf qh qb hp qhomx qpiuers ltohinv fyeyk mlooujy ml dj qh gq jk vq kn ly j "
},
{
"input": "hzxkuwqxonsulnndlhygvmallghjerwp",
"output": "hz xkuwq xonsuln nd lh yg vmall gh jerw p "
},
{
"input": "jbvcsjdyzlzmxwcvmixunfzxidzvwzaqqdhguvelwbdosbd",
"output": "jb vc sj dy zl zm xw cv mixunf zxidz vw zaqq dh guvelw bdosb d "
},
{
"input": "uyrsxaqmtibbxpfabprvnvbinjoxubupvfyjlqnfrfdeptipketwghr",
"output": "uyr sxaqm tibb xp fabp rv nv binjoxubupv fy jl qn fr fdeptipketw gh r "
},
{
"input": "xfcftysljytybkkzkpqdzralahgvbkxdtheqrhfxpecdjqofnyiahggnkiuusalu",
"output": "xf cf ty sl jy ty bk kz kp qd zralahg vb kx dt heqr hf xpecd jqofn yiahg gn kiuusalu "
},
{
"input": "a",
"output": "a "
},
{
"input": "b",
"output": "b "
},
{
"input": "aa",
"output": "aa "
},
{
"input": "ab",
"output": "ab "
},
{
"input": "ba",
"output": "ba "
},
{
"input": "bb",
"output": "bb "
},
{
"input": "aaa",
"output": "aaa "
},
{
"input": "aab",
"output": "aab "
},
{
"input": "aba",
"output": "aba "
},
{
"input": "abb",
"output": "abb "
},
{
"input": "baa",
"output": "baa "
},
{
"input": "bab",
"output": "bab "
},
{
"input": "bba",
"output": "bba "
},
{
"input": "bbb",
"output": "bbb "
},
{
"input": "bbc",
"output": "bb c "
},
{
"input": "bcb",
"output": "bc b "
},
{
"input": "cbb",
"output": "cb b "
},
{
"input": "bababcdfabbcabcdfacbbabcdfacacabcdfacbcabcdfaccbabcdfacaaabcdfabacabcdfabcbabcdfacbaabcdfabaaabcdfabbaabcdfacababcdfabbbabcdfabcaabcdfaaababcdfabccabcdfacccabcdfaacbabcdfaabaabcdfaabcabcdfaaacabcdfaccaabcdfaabbabcdfaaaaabcdfaacaabcdfaacc",
"output": "bababc dfabb cabc dfacb babc dfacacabc dfacb cabc dfacc babc dfacaaabc dfabacabc dfabc babc dfacbaabc dfabaaabc dfabbaabc dfacababc dfabbbabc dfabcaabc dfaaababc dfabc cabc dfacccabc dfaacbabc dfaabaabc dfaabcabc dfaaacabc dfaccaabc dfaabbabc dfaaaaabc dfaacaabc dfaacc "
},
{
"input": "bddabcdfaccdabcdfadddabcdfabbdabcdfacddabcdfacdbabcdfacbbabcdfacbcabcdfacbdabcdfadbbabcdfabdbabcdfabdcabcdfabbcabcdfabccabcdfabbbabcdfaddcabcdfaccbabcdfadbdabcdfacccabcdfadcdabcdfadcbabcdfabcbabcdfadbcabcdfacdcabcdfabcdabcdfadccabcdfaddb",
"output": "bd dabc dfacc dabc dfadddabc dfabb dabc dfacd dabc dfacd babc dfacb babc dfacb cabc dfacb dabc dfadb babc dfabd babc dfabd cabc dfabb cabc dfabc cabc dfabbbabc dfadd cabc dfacc babc dfadb dabc dfacccabc dfadc dabc dfadc babc dfabc babc dfadb cabc dfacd cabc dfabc dabc dfadc cabc dfadd b "
},
{
"input": "helllllooooo",
"output": "helllllooooo "
},
{
"input": "bbbzxxx",
"output": "bbb zx xx "
},
{
"input": "ffff",
"output": "ffff "
},
{
"input": "cdddddddddddddddddd",
"output": "cd ddddddddddddddddd "
},
{
"input": "bbbc",
"output": "bbb c "
},
{
"input": "lll",
"output": "lll "
},
{
"input": "bbbbb",
"output": "bbbbb "
},
{
"input": "llll",
"output": "llll "
},
{
"input": "bbbbbbccc",
"output": "bbbbbb ccc "
},
{
"input": "lllllb",
"output": "lllll b "
},
{
"input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
"output": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz "
},
{
"input": "lllll",
"output": "lllll "
},
{
"input": "bbbbbbbbbc",
"output": "bbbbbbbbb c "
},
{
"input": "helllllno",
"output": "helllll no "
},
{
"input": "nnnnnnnnnnnn",
"output": "nnnnnnnnnnnn "
},
{
"input": "bbbbbccc",
"output": "bbbbb ccc "
},
{
"input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
"output": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzz "
},
{
"input": "nnnnnnnnnnnnnnnnnn",
"output": "nnnnnnnnnnnnnnnnnn "
},
{
"input": "zzzzzzzzzzzzzzzzzzzzzzz",
"output": "zzzzzzzzzzzzzzzzzzzzzzz "
},
{
"input": "hhhh",
"output": "hhhh "
},
{
"input": "nnnnnnnnnnnnnnnnnnnnnnnnn",
"output": "nnnnnnnnnnnnnnnnnnnnnnnnn "
},
{
"input": "zzzzzzzzzz",
"output": "zzzzzzzzzz "
},
{
"input": "dddd",
"output": "dddd "
},
{
"input": "heffffffgggggghhhhhh",
"output": "heffffff gggggg hhhhhh "
},
{
"input": "bcddd",
"output": "bc ddd "
},
{
"input": "x",
"output": "x "
},
{
"input": "nnn",
"output": "nnn "
},
{
"input": "xxxxxxxx",
"output": "xxxxxxxx "
},
{
"input": "cclcc",
"output": "cc lc c "
},
{
"input": "tttttttttttttt",
"output": "tttttttttttttt "
},
{
"input": "xxxxxxx",
"output": "xxxxxxx "
},
{
"input": "ccccb",
"output": "cccc b "
},
{
"input": "bcecccc",
"output": "bcecccc "
},
{
"input": "jjja",
"output": "jjja "
},
{
"input": "zzz",
"output": "zzz "
},
{
"input": "xxxxxxxxxzzzzzzzzzzzz",
"output": "xxxxxxxxx zzzzzzzzzzzz "
},
{
"input": "alllewww",
"output": "alllewww "
},
{
"input": "bbbbbbbbb",
"output": "bbbbbbbbb "
},
{
"input": "jjj",
"output": "jjj "
},
{
"input": "bbbbbbbbbbbbbbbbbbbbbbbbb",
"output": "bbbbbbbbbbbbbbbbbbbbbbbbb "
},
{
"input": "kkkkkkkkkklllllllllllllll",
"output": "kkkkkkkkkk lllllllllllllll "
},
{
"input": "helllllllllllo",
"output": "helllllllllllo "
},
{
"input": "ttttsttttt",
"output": "tttt st tttt "
},
{
"input": "tttttttsssssss",
"output": "ttttttt sssssss "
},
{
"input": "assstttttatsfatsfdjfdhtsjdsaatttssssststsss",
"output": "asss tttttats fats fd jf dh ts jd saattt sssss ts ts ss "
},
{
"input": "xxxxx",
"output": "xxxxx "
},
{
"input": "bbbhbbb",
"output": "bbb hb bb "
},
{
"input": "bbbbbbbb",
"output": "bbbbbbbb "
}
] | 1,505,657,608
| 4,108
|
Python 3
|
WRONG_ANSWER
|
PRETESTS
| 5
| 46
| 0
|
a = input()
z = ["a", "e", "i", "o", "u", " "]
for i in range(len(a) - 2):
if a[i] not in z and a[i + 1] not in z and a[i + 2] not in z:
a = a[:i + 2] + " " + a[i + 2:]
if len(a) > 3 and a[-1] not in z and a[-2] not in z and a[-3] not in z:
a = a[:-1] + " " + a[-1]
print (a)
|
Title: Did you mean...
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
- the following words have typos: "hellno", "hackcerrs" and "backtothefutttture"; - the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input Specification:
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output Specification:
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Demo Input:
['hellno\n', 'abacaba\n', 'asdfasdf\n']
Demo Output:
['hell no \n', 'abacaba \n', 'asd fasd f \n']
Note:
none
|
```python
a = input()
z = ["a", "e", "i", "o", "u", " "]
for i in range(len(a) - 2):
if a[i] not in z and a[i + 1] not in z and a[i + 2] not in z:
a = a[:i + 2] + " " + a[i + 2:]
if len(a) > 3 and a[-1] not in z and a[-2] not in z and a[-3] not in z:
a = a[:-1] + " " + a[-1]
print (a)
```
| 0
|
|
437
|
C
|
The Child and Toy
|
PROGRAMMING
| 1,400
|
[
"graphs",
"greedy",
"sortings"
] | null | null |
On Children's Day, the child got a toy from Delayyy as a present. However, the child is so naughty that he can't wait to destroy the toy.
The toy consists of *n* parts and *m* ropes. Each rope links two parts, but every pair of parts is linked by at most one rope. To split the toy, the child must remove all its parts. The child can remove a single part at a time, and each remove consume an energy. Let's define an energy value of part *i* as *v**i*. The child spend *v**f*1<=+<=*v**f*2<=+<=...<=+<=*v**f**k* energy for removing part *i* where *f*1,<=*f*2,<=...,<=*f**k* are the parts that are directly connected to the *i*-th and haven't been removed.
Help the child to find out, what is the minimum total energy he should spend to remove all *n* parts.
|
The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=1000; 0<=≤<=*m*<=≤<=2000). The second line contains *n* integers: *v*1,<=*v*2,<=...,<=*v**n* (0<=≤<=*v**i*<=≤<=105). Then followed *m* lines, each line contains two integers *x**i* and *y**i*, representing a rope from part *x**i* to part *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*; *x**i*<=≠<=*y**i*).
Consider all the parts are numbered from 1 to *n*.
|
Output the minimum total energy the child should spend to remove all *n* parts of the toy.
|
[
"4 3\n10 20 30 40\n1 4\n1 2\n2 3\n",
"4 4\n100 100 100 100\n1 2\n2 3\n2 4\n3 4\n",
"7 10\n40 10 20 10 20 80 40\n1 5\n4 7\n4 5\n5 2\n5 7\n6 4\n1 6\n1 3\n4 3\n1 4\n"
] |
[
"40\n",
"400\n",
"160\n"
] |
One of the optimal sequence of actions in the first sample is:
- First, remove part 3, cost of the action is 20. - Then, remove part 2, cost of the action is 10. - Next, remove part 4, cost of the action is 10. - At last, remove part 1, cost of the action is 0.
So the total energy the child paid is 20 + 10 + 10 + 0 = 40, which is the minimum.
In the second sample, the child will spend 400 no matter in what order he will remove the parts.
| 1,500
|
[
{
"input": "4 3\n10 20 30 40\n1 4\n1 2\n2 3",
"output": "40"
},
{
"input": "4 4\n100 100 100 100\n1 2\n2 3\n2 4\n3 4",
"output": "400"
},
{
"input": "7 10\n40 10 20 10 20 80 40\n1 5\n4 7\n4 5\n5 2\n5 7\n6 4\n1 6\n1 3\n4 3\n1 4",
"output": "160"
},
{
"input": "1 0\n23333",
"output": "0"
},
{
"input": "5 4\n1 2 2 2 2\n1 2\n1 3\n1 4\n1 5",
"output": "4"
},
{
"input": "10 30\n3 6 17 15 13 15 6 12 9 1\n3 8\n1 10\n4 7\n1 7\n3 7\n2 9\n8 10\n3 1\n3 4\n8 6\n10 3\n3 9\n2 3\n10 4\n2 10\n5 8\n9 5\n6 1\n2 1\n7 2\n7 6\n7 10\n4 8\n5 6\n3 6\n4 1\n8 9\n7 9\n4 2\n5 10",
"output": "188"
},
{
"input": "3 3\n1 1 1\n1 2\n2 3\n3 1",
"output": "3"
}
] | 1,608,877,955
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 29
| 202
| 3,891,200
|
n,m=map(int,input().split())
a=list(map(int,input().split()))
x=[[] for i in range(n+1)]
y=[0 for i in range(n+1)]
for i in range(m):
l,r=map(int,input().split())
x[l].append(r)
x[r].append(l)
y[l]+=a[r-1]
y[r]+=a[l-1]
e=[]
for i in range(n):
e.append([a[i],i+1])
e=sorted(e,key=lambda x:x[0],reverse=True)
s=10**6
ans=0
# print(e)
for i in e:
# print(y)
k=i[1]
ans+=y[k]
y[k]=0
for h in x[k]:
if(y[h]>0):
y[h]-=a[k-1];
print(ans)
|
Title: The Child and Toy
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
On Children's Day, the child got a toy from Delayyy as a present. However, the child is so naughty that he can't wait to destroy the toy.
The toy consists of *n* parts and *m* ropes. Each rope links two parts, but every pair of parts is linked by at most one rope. To split the toy, the child must remove all its parts. The child can remove a single part at a time, and each remove consume an energy. Let's define an energy value of part *i* as *v**i*. The child spend *v**f*1<=+<=*v**f*2<=+<=...<=+<=*v**f**k* energy for removing part *i* where *f*1,<=*f*2,<=...,<=*f**k* are the parts that are directly connected to the *i*-th and haven't been removed.
Help the child to find out, what is the minimum total energy he should spend to remove all *n* parts.
Input Specification:
The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=1000; 0<=≤<=*m*<=≤<=2000). The second line contains *n* integers: *v*1,<=*v*2,<=...,<=*v**n* (0<=≤<=*v**i*<=≤<=105). Then followed *m* lines, each line contains two integers *x**i* and *y**i*, representing a rope from part *x**i* to part *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*; *x**i*<=≠<=*y**i*).
Consider all the parts are numbered from 1 to *n*.
Output Specification:
Output the minimum total energy the child should spend to remove all *n* parts of the toy.
Demo Input:
['4 3\n10 20 30 40\n1 4\n1 2\n2 3\n', '4 4\n100 100 100 100\n1 2\n2 3\n2 4\n3 4\n', '7 10\n40 10 20 10 20 80 40\n1 5\n4 7\n4 5\n5 2\n5 7\n6 4\n1 6\n1 3\n4 3\n1 4\n']
Demo Output:
['40\n', '400\n', '160\n']
Note:
One of the optimal sequence of actions in the first sample is:
- First, remove part 3, cost of the action is 20. - Then, remove part 2, cost of the action is 10. - Next, remove part 4, cost of the action is 10. - At last, remove part 1, cost of the action is 0.
So the total energy the child paid is 20 + 10 + 10 + 0 = 40, which is the minimum.
In the second sample, the child will spend 400 no matter in what order he will remove the parts.
|
```python
n,m=map(int,input().split())
a=list(map(int,input().split()))
x=[[] for i in range(n+1)]
y=[0 for i in range(n+1)]
for i in range(m):
l,r=map(int,input().split())
x[l].append(r)
x[r].append(l)
y[l]+=a[r-1]
y[r]+=a[l-1]
e=[]
for i in range(n):
e.append([a[i],i+1])
e=sorted(e,key=lambda x:x[0],reverse=True)
s=10**6
ans=0
# print(e)
for i in e:
# print(y)
k=i[1]
ans+=y[k]
y[k]=0
for h in x[k]:
if(y[h]>0):
y[h]-=a[k-1];
print(ans)
```
| 3
|
|
723
|
A
|
The New Year: Meeting Friends
|
PROGRAMMING
| 800
|
[
"implementation",
"math",
"sortings"
] | null | null |
There are three friend living on the straight line *Ox* in Lineland. The first friend lives at the point *x*1, the second friend lives at the point *x*2, and the third friend lives at the point *x*3. They plan to celebrate the New Year together, so they need to meet at one point. What is the minimum total distance they have to travel in order to meet at some point and celebrate the New Year?
It's guaranteed that the optimal answer is always integer.
|
The first line of the input contains three distinct integers *x*1, *x*2 and *x*3 (1<=≤<=*x*1,<=*x*2,<=*x*3<=≤<=100) — the coordinates of the houses of the first, the second and the third friends respectively.
|
Print one integer — the minimum total distance the friends need to travel in order to meet together.
|
[
"7 1 4\n",
"30 20 10\n"
] |
[
"6\n",
"20\n"
] |
In the first sample, friends should meet at the point 4. Thus, the first friend has to travel the distance of 3 (from the point 7 to the point 4), the second friend also has to travel the distance of 3 (from the point 1 to the point 4), while the third friend should not go anywhere because he lives at the point 4.
| 500
|
[
{
"input": "7 1 4",
"output": "6"
},
{
"input": "30 20 10",
"output": "20"
},
{
"input": "1 4 100",
"output": "99"
},
{
"input": "100 1 91",
"output": "99"
},
{
"input": "1 45 100",
"output": "99"
},
{
"input": "1 2 3",
"output": "2"
},
{
"input": "71 85 88",
"output": "17"
},
{
"input": "30 38 99",
"output": "69"
},
{
"input": "23 82 95",
"output": "72"
},
{
"input": "22 41 47",
"output": "25"
},
{
"input": "9 94 77",
"output": "85"
},
{
"input": "1 53 51",
"output": "52"
},
{
"input": "25 97 93",
"output": "72"
},
{
"input": "42 53 51",
"output": "11"
},
{
"input": "81 96 94",
"output": "15"
},
{
"input": "21 5 93",
"output": "88"
},
{
"input": "50 13 75",
"output": "62"
},
{
"input": "41 28 98",
"output": "70"
},
{
"input": "69 46 82",
"output": "36"
},
{
"input": "87 28 89",
"output": "61"
},
{
"input": "44 45 40",
"output": "5"
},
{
"input": "86 97 68",
"output": "29"
},
{
"input": "43 92 30",
"output": "62"
},
{
"input": "16 70 1",
"output": "69"
},
{
"input": "40 46 19",
"output": "27"
},
{
"input": "71 38 56",
"output": "33"
},
{
"input": "82 21 80",
"output": "61"
},
{
"input": "75 8 35",
"output": "67"
},
{
"input": "75 24 28",
"output": "51"
},
{
"input": "78 23 56",
"output": "55"
},
{
"input": "85 31 10",
"output": "75"
},
{
"input": "76 50 9",
"output": "67"
},
{
"input": "95 37 34",
"output": "61"
},
{
"input": "84 61 35",
"output": "49"
},
{
"input": "87 85 37",
"output": "50"
},
{
"input": "1 3 2",
"output": "2"
},
{
"input": "4 2 6",
"output": "4"
},
{
"input": "6 9 3",
"output": "6"
},
{
"input": "12 4 8",
"output": "8"
},
{
"input": "15 10 5",
"output": "10"
},
{
"input": "1 50 17",
"output": "49"
},
{
"input": "10 5 15",
"output": "10"
},
{
"input": "8 1 9",
"output": "8"
},
{
"input": "3 5 4",
"output": "2"
},
{
"input": "2 1 3",
"output": "2"
},
{
"input": "1 8 2",
"output": "7"
},
{
"input": "1 100 2",
"output": "99"
},
{
"input": "1 4 6",
"output": "5"
}
] | 1,690,823,007
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 48
| 46
| 0
|
from math import*
l=list(map(int,input().split()))
s=0
for i in l:
if i not in [max(l),min(l)]:
a=i
for i in l:
s+=abs(a-i)
print(s)
|
Title: The New Year: Meeting Friends
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
There are three friend living on the straight line *Ox* in Lineland. The first friend lives at the point *x*1, the second friend lives at the point *x*2, and the third friend lives at the point *x*3. They plan to celebrate the New Year together, so they need to meet at one point. What is the minimum total distance they have to travel in order to meet at some point and celebrate the New Year?
It's guaranteed that the optimal answer is always integer.
Input Specification:
The first line of the input contains three distinct integers *x*1, *x*2 and *x*3 (1<=≤<=*x*1,<=*x*2,<=*x*3<=≤<=100) — the coordinates of the houses of the first, the second and the third friends respectively.
Output Specification:
Print one integer — the minimum total distance the friends need to travel in order to meet together.
Demo Input:
['7 1 4\n', '30 20 10\n']
Demo Output:
['6\n', '20\n']
Note:
In the first sample, friends should meet at the point 4. Thus, the first friend has to travel the distance of 3 (from the point 7 to the point 4), the second friend also has to travel the distance of 3 (from the point 1 to the point 4), while the third friend should not go anywhere because he lives at the point 4.
|
```python
from math import*
l=list(map(int,input().split()))
s=0
for i in l:
if i not in [max(l),min(l)]:
a=i
for i in l:
s+=abs(a-i)
print(s)
```
| 3
|
|
271
|
A
|
Beautiful Year
|
PROGRAMMING
| 800
|
[
"brute force"
] | null | null |
It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has only distinct digits.
|
The single line contains integer *y* (1000<=≤<=*y*<=≤<=9000) — the year number.
|
Print a single integer — the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists.
|
[
"1987\n",
"2013\n"
] |
[
"2013\n",
"2014\n"
] |
none
| 500
|
[
{
"input": "1987",
"output": "2013"
},
{
"input": "2013",
"output": "2014"
},
{
"input": "1000",
"output": "1023"
},
{
"input": "1001",
"output": "1023"
},
{
"input": "1234",
"output": "1235"
},
{
"input": "5555",
"output": "5601"
},
{
"input": "9000",
"output": "9012"
},
{
"input": "1111",
"output": "1203"
},
{
"input": "8999",
"output": "9012"
},
{
"input": "4572",
"output": "4573"
},
{
"input": "6666",
"output": "6701"
},
{
"input": "2001",
"output": "2013"
},
{
"input": "3000",
"output": "3012"
},
{
"input": "7712",
"output": "7801"
},
{
"input": "8088",
"output": "8091"
},
{
"input": "1594",
"output": "1596"
},
{
"input": "6016",
"output": "6017"
},
{
"input": "8800",
"output": "8901"
},
{
"input": "3331",
"output": "3401"
},
{
"input": "5090",
"output": "5091"
},
{
"input": "2342",
"output": "2345"
},
{
"input": "2334",
"output": "2340"
},
{
"input": "1123",
"output": "1203"
},
{
"input": "8989",
"output": "9012"
},
{
"input": "8977",
"output": "9012"
},
{
"input": "6869",
"output": "6870"
},
{
"input": "8999",
"output": "9012"
}
] | 1,689,691,494
| 2,147,483,647
|
PyPy 3-64
|
COMPILATION_ERROR
|
TESTS
| 0
| 0
| 0
|
n=input()+1
while len(set(str(n)))<4:n+=1
print n
|
Title: Beautiful Year
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
It seems like the year of 2013 came only yesterday. Do you know a curious fact? The year of 2013 is the first year after the old 1987 with only distinct digits.
Now you are suggested to solve the following problem: given a year number, find the minimum year number which is strictly larger than the given one and has only distinct digits.
Input Specification:
The single line contains integer *y* (1000<=≤<=*y*<=≤<=9000) — the year number.
Output Specification:
Print a single integer — the minimum year number that is strictly larger than *y* and all it's digits are distinct. It is guaranteed that the answer exists.
Demo Input:
['1987\n', '2013\n']
Demo Output:
['2013\n', '2014\n']
Note:
none
|
```python
n=input()+1
while len(set(str(n)))<4:n+=1
print n
```
| -1
|
|
450
|
B
|
Jzzhu and Sequences
|
PROGRAMMING
| 1,300
|
[
"implementation",
"math"
] | null | null |
Jzzhu has invented a kind of sequences, they meet the following property:
You are given *x* and *y*, please calculate *f**n* modulo 1000000007 (109<=+<=7).
|
The first line contains two integers *x* and *y* (|*x*|,<=|*y*|<=≤<=109). The second line contains a single integer *n* (1<=≤<=*n*<=≤<=2·109).
|
Output a single integer representing *f**n* modulo 1000000007 (109<=+<=7).
|
[
"2 3\n3\n",
"0 -1\n2\n"
] |
[
"1\n",
"1000000006\n"
] |
In the first sample, *f*<sub class="lower-index">2</sub> = *f*<sub class="lower-index">1</sub> + *f*<sub class="lower-index">3</sub>, 3 = 2 + *f*<sub class="lower-index">3</sub>, *f*<sub class="lower-index">3</sub> = 1.
In the second sample, *f*<sub class="lower-index">2</sub> = - 1; - 1 modulo (10<sup class="upper-index">9</sup> + 7) equals (10<sup class="upper-index">9</sup> + 6).
| 1,000
|
[
{
"input": "2 3\n3",
"output": "1"
},
{
"input": "0 -1\n2",
"output": "1000000006"
},
{
"input": "-9 -11\n12345",
"output": "1000000005"
},
{
"input": "0 0\n1000000000",
"output": "0"
},
{
"input": "-1000000000 1000000000\n2000000000",
"output": "1000000000"
},
{
"input": "-12345678 12345678\n1912345678",
"output": "12345678"
},
{
"input": "728374857 678374857\n1928374839",
"output": "950000007"
},
{
"input": "278374837 992837483\n1000000000",
"output": "721625170"
},
{
"input": "-693849384 502938493\n982838498",
"output": "502938493"
},
{
"input": "-783928374 983738273\n992837483",
"output": "16261734"
},
{
"input": "-872837483 -682738473\n999999999",
"output": "190099010"
},
{
"input": "-892837483 -998273847\n999283948",
"output": "892837483"
},
{
"input": "-283938494 738473848\n1999999999",
"output": "716061513"
},
{
"input": "-278374857 819283838\n1",
"output": "721625150"
},
{
"input": "-1000000000 123456789\n1",
"output": "7"
},
{
"input": "-529529529 -524524524\n2",
"output": "475475483"
},
{
"input": "1 2\n2000000000",
"output": "2"
},
{
"input": "-1 -2\n2000000000",
"output": "1000000005"
},
{
"input": "1 2\n1999999999",
"output": "1"
},
{
"input": "1 2\n1999999998",
"output": "1000000006"
},
{
"input": "1 2\n1999999997",
"output": "1000000005"
},
{
"input": "1 2\n1999999996",
"output": "1000000006"
},
{
"input": "69975122 366233206\n1189460676",
"output": "703741923"
},
{
"input": "812229413 904420051\n806905621",
"output": "812229413"
},
{
"input": "872099024 962697902\n1505821695",
"output": "90598878"
},
{
"input": "887387283 909670917\n754835014",
"output": "112612724"
},
{
"input": "37759824 131342932\n854621399",
"output": "868657075"
},
{
"input": "-246822123 800496170\n626323615",
"output": "753177884"
},
{
"input": "-861439463 974126967\n349411083",
"output": "835566423"
},
{
"input": "-69811049 258093841\n1412447",
"output": "741906166"
},
{
"input": "844509330 -887335829\n123329059",
"output": "844509330"
},
{
"input": "83712471 -876177148\n1213284777",
"output": "40110388"
},
{
"input": "598730524 -718984219\n1282749880",
"output": "401269483"
},
{
"input": "-474244697 -745885656\n1517883612",
"output": "271640959"
},
{
"input": "-502583588 -894906953\n1154189557",
"output": "497416419"
},
{
"input": "-636523651 -873305815\n154879215",
"output": "763217843"
},
{
"input": "721765550 594845720\n78862386",
"output": "126919830"
},
{
"input": "364141461 158854993\n1337196589",
"output": "364141461"
},
{
"input": "878985260 677031952\n394707801",
"output": "798046699"
},
{
"input": "439527072 -24854079\n1129147002",
"output": "464381151"
},
{
"input": "840435009 -612103127\n565968986",
"output": "387896880"
},
{
"input": "875035447 -826471373\n561914518",
"output": "124964560"
},
{
"input": "-342526698 305357084\n70776744",
"output": "352116225"
},
{
"input": "-903244186 899202229\n1527859274",
"output": "899202229"
},
{
"input": "-839482546 815166320\n1127472130",
"output": "839482546"
},
{
"input": "-976992569 -958313041\n1686580818",
"output": "981320479"
},
{
"input": "-497338894 -51069176\n737081851",
"output": "502661113"
},
{
"input": "-697962643 -143148799\n1287886520",
"output": "856851208"
},
{
"input": "-982572938 -482658433\n1259858332",
"output": "982572938"
},
{
"input": "123123 78817\n2000000000",
"output": "78817"
},
{
"input": "1000000000 -1000000000\n3",
"output": "14"
},
{
"input": "-1000000000 1000000000\n6",
"output": "14"
},
{
"input": "2 3\n6",
"output": "1000000006"
},
{
"input": "0 -1\n6",
"output": "1"
},
{
"input": "500000000 -1000000000\n600000003",
"output": "500000014"
},
{
"input": "-1000000000 1000000000\n3",
"output": "999999993"
},
{
"input": "1 3\n6",
"output": "1000000005"
},
{
"input": "1 2\n12",
"output": "1000000006"
},
{
"input": "7 -1000000000\n3",
"output": "0"
},
{
"input": "-999999997 999999997\n6",
"output": "20"
},
{
"input": "3 4\n6",
"output": "1000000006"
},
{
"input": "-1 2\n6",
"output": "1000000004"
},
{
"input": "2 3\n12",
"output": "1000000006"
},
{
"input": "4 18\n6",
"output": "999999993"
},
{
"input": "1 2\n6",
"output": "1000000006"
},
{
"input": "1000000000 -1000000000\n6",
"output": "999999993"
},
{
"input": "999999999 -999999999\n3",
"output": "16"
},
{
"input": "-1 0\n1",
"output": "1000000006"
},
{
"input": "1000000000 -1000000000\n9",
"output": "14"
},
{
"input": "999999999 -1000000000\n12",
"output": "999999992"
},
{
"input": "1000000000 -7\n3",
"output": "0"
},
{
"input": "-5 5\n6",
"output": "999999997"
},
{
"input": "5 9\n6",
"output": "1000000003"
},
{
"input": "-15 -10\n1",
"output": "999999992"
}
] | 1,644,639,206
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 31
| 0
|
x,y=[int(x) for x in input().split(' ')]
n=int(input())
f0=x
f1=y
n=n-1
m=1000000007
i=2
c=0
if n==1:
print((f1+m)%m)
elif n==0:
print((f0+m)%m)
else:
while i<=n:
c=(f1%m-f0%m)%m
f1=c
f0=f1
i+=1
print(c)
|
Title: Jzzhu and Sequences
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Jzzhu has invented a kind of sequences, they meet the following property:
You are given *x* and *y*, please calculate *f**n* modulo 1000000007 (109<=+<=7).
Input Specification:
The first line contains two integers *x* and *y* (|*x*|,<=|*y*|<=≤<=109). The second line contains a single integer *n* (1<=≤<=*n*<=≤<=2·109).
Output Specification:
Output a single integer representing *f**n* modulo 1000000007 (109<=+<=7).
Demo Input:
['2 3\n3\n', '0 -1\n2\n']
Demo Output:
['1\n', '1000000006\n']
Note:
In the first sample, *f*<sub class="lower-index">2</sub> = *f*<sub class="lower-index">1</sub> + *f*<sub class="lower-index">3</sub>, 3 = 2 + *f*<sub class="lower-index">3</sub>, *f*<sub class="lower-index">3</sub> = 1.
In the second sample, *f*<sub class="lower-index">2</sub> = - 1; - 1 modulo (10<sup class="upper-index">9</sup> + 7) equals (10<sup class="upper-index">9</sup> + 6).
|
```python
x,y=[int(x) for x in input().split(' ')]
n=int(input())
f0=x
f1=y
n=n-1
m=1000000007
i=2
c=0
if n==1:
print((f1+m)%m)
elif n==0:
print((f0+m)%m)
else:
while i<=n:
c=(f1%m-f0%m)%m
f1=c
f0=f1
i+=1
print(c)
```
| 0
|
|
875
|
A
|
Classroom Watch
|
PROGRAMMING
| 1,200
|
[
"brute force",
"math"
] | null | null |
Eighth-grader Vova is on duty today in the class. After classes, he went into the office to wash the board, and found on it the number *n*. He asked what is this number and the teacher of mathematics Inna Petrovna answered Vova that *n* is the answer to the arithmetic task for first-graders. In the textbook, a certain positive integer *x* was given. The task was to add *x* to the sum of the digits of the number *x* written in decimal numeral system.
Since the number *n* on the board was small, Vova quickly guessed which *x* could be in the textbook. Now he wants to get a program which will search for arbitrary values of the number *n* for all suitable values of *x* or determine that such *x* does not exist. Write such a program for Vova.
|
The first line contains integer *n* (1<=≤<=*n*<=≤<=109).
|
In the first line print one integer *k* — number of different values of *x* satisfying the condition.
In next *k* lines print these values in ascending order.
|
[
"21\n",
"20\n"
] |
[
"1\n15\n",
"0\n"
] |
In the first test case *x* = 15 there is only one variant: 15 + 1 + 5 = 21.
In the second test case there are no such *x*.
| 500
|
[
{
"input": "21",
"output": "1\n15"
},
{
"input": "20",
"output": "0"
},
{
"input": "1",
"output": "0"
},
{
"input": "2",
"output": "1\n1"
},
{
"input": "3",
"output": "0"
},
{
"input": "100000001",
"output": "2\n99999937\n100000000"
},
{
"input": "1000000000",
"output": "1\n999999932"
},
{
"input": "999999979",
"output": "2\n999999899\n999999908"
},
{
"input": "9",
"output": "0"
},
{
"input": "10",
"output": "1\n5"
},
{
"input": "11",
"output": "1\n10"
},
{
"input": "39",
"output": "1\n33"
},
{
"input": "66",
"output": "1\n60"
},
{
"input": "75",
"output": "0"
},
{
"input": "100",
"output": "1\n86"
},
{
"input": "101",
"output": "2\n91\n100"
},
{
"input": "2014",
"output": "2\n1988\n2006"
},
{
"input": "999999994",
"output": "0"
}
] | 1,518,658,514
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 5
| 1,000
| 5,632,000
|
n = int(input())
sol = []
for i in range(n):
str_i = str(i)
digits = [int(c) for c in str_i]
if i + sum(digits) == n:
sol.append(i)
print(str(len(sol)))
for s in sol:
print(s)
|
Title: Classroom Watch
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Eighth-grader Vova is on duty today in the class. After classes, he went into the office to wash the board, and found on it the number *n*. He asked what is this number and the teacher of mathematics Inna Petrovna answered Vova that *n* is the answer to the arithmetic task for first-graders. In the textbook, a certain positive integer *x* was given. The task was to add *x* to the sum of the digits of the number *x* written in decimal numeral system.
Since the number *n* on the board was small, Vova quickly guessed which *x* could be in the textbook. Now he wants to get a program which will search for arbitrary values of the number *n* for all suitable values of *x* or determine that such *x* does not exist. Write such a program for Vova.
Input Specification:
The first line contains integer *n* (1<=≤<=*n*<=≤<=109).
Output Specification:
In the first line print one integer *k* — number of different values of *x* satisfying the condition.
In next *k* lines print these values in ascending order.
Demo Input:
['21\n', '20\n']
Demo Output:
['1\n15\n', '0\n']
Note:
In the first test case *x* = 15 there is only one variant: 15 + 1 + 5 = 21.
In the second test case there are no such *x*.
|
```python
n = int(input())
sol = []
for i in range(n):
str_i = str(i)
digits = [int(c) for c in str_i]
if i + sum(digits) == n:
sol.append(i)
print(str(len(sol)))
for s in sol:
print(s)
```
| 0
|
|
870
|
C
|
Maximum splitting
|
PROGRAMMING
| 1,300
|
[
"dp",
"greedy",
"math",
"number theory"
] | null | null |
You are given several queries. In the *i*-th query you are given a single positive integer *n**i*. You are to represent *n**i* as a sum of maximum possible number of composite summands and print this maximum number, or print -1, if there are no such splittings.
An integer greater than 1 is composite, if it is not prime, i.e. if it has positive divisors not equal to 1 and the integer itself.
|
The first line contains single integer *q* (1<=≤<=*q*<=≤<=105) — the number of queries.
*q* lines follow. The (*i*<=+<=1)-th line contains single integer *n**i* (1<=≤<=*n**i*<=≤<=109) — the *i*-th query.
|
For each query print the maximum possible number of summands in a valid splitting to composite summands, or -1, if there are no such splittings.
|
[
"1\n12\n",
"2\n6\n8\n",
"3\n1\n2\n3\n"
] |
[
"3\n",
"1\n2\n",
"-1\n-1\n-1\n"
] |
12 = 4 + 4 + 4 = 4 + 8 = 6 + 6 = 12, but the first splitting has the maximum possible number of summands.
8 = 4 + 4, 6 can't be split into several composite summands.
1, 2, 3 are less than any composite number, so they do not have valid splittings.
| 1,500
|
[
{
"input": "1\n12",
"output": "3"
},
{
"input": "2\n6\n8",
"output": "1\n2"
},
{
"input": "3\n1\n2\n3",
"output": "-1\n-1\n-1"
},
{
"input": "6\n1\n2\n3\n5\n7\n11",
"output": "-1\n-1\n-1\n-1\n-1\n-1"
},
{
"input": "3\n4\n6\n9",
"output": "1\n1\n1"
},
{
"input": "20\n8\n13\n20\n12\n9\n16\n4\n19\n7\n15\n10\n6\n14\n11\n3\n2\n5\n17\n18\n1",
"output": "2\n2\n5\n3\n1\n4\n1\n3\n-1\n2\n2\n1\n3\n-1\n-1\n-1\n-1\n3\n4\n-1"
},
{
"input": "100\n611\n513\n544\n463\n38\n778\n347\n317\n848\n664\n382\n108\n718\n33\n334\n876\n234\n22\n944\n305\n159\n245\n513\n691\n639\n135\n308\n324\n813\n459\n304\n116\n331\n993\n184\n224\n853\n769\n121\n687\n93\n930\n751\n308\n485\n914\n400\n695\n95\n981\n175\n972\n121\n654\n242\n610\n617\n999\n237\n548\n742\n767\n613\n172\n223\n391\n102\n907\n673\n116\n230\n355\n189\n552\n399\n493\n903\n201\n985\n459\n776\n641\n693\n919\n253\n540\n427\n394\n655\n101\n461\n854\n417\n249\n66\n380\n213\n906\n212\n528",
"output": "151\n127\n136\n114\n9\n194\n85\n78\n212\n166\n95\n27\n179\n7\n83\n219\n58\n5\n236\n75\n38\n60\n127\n171\n158\n32\n77\n81\n202\n113\n76\n29\n81\n247\n46\n56\n212\n191\n29\n170\n22\n232\n186\n77\n120\n228\n100\n172\n22\n244\n42\n243\n29\n163\n60\n152\n153\n248\n58\n137\n185\n190\n152\n43\n54\n96\n25\n225\n167\n29\n57\n87\n46\n138\n98\n122\n224\n49\n245\n113\n194\n159\n172\n228\n62\n135\n105\n98\n162\n24\n114\n213\n103\n61\n16\n95\n52\n226\n53\n132"
},
{
"input": "1\n10000001",
"output": "2499999"
}
] | 1,606,490,480
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 5
| 109
| 0
|
n = int(input())
for _ in range(n):
a = int(input())
b = a // 4
a %= 4
if a == 1:
b -= 1
elif a == 3:
b -= 2
if b > 0:
print(b)
else:
print(-1)
|
Title: Maximum splitting
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given several queries. In the *i*-th query you are given a single positive integer *n**i*. You are to represent *n**i* as a sum of maximum possible number of composite summands and print this maximum number, or print -1, if there are no such splittings.
An integer greater than 1 is composite, if it is not prime, i.e. if it has positive divisors not equal to 1 and the integer itself.
Input Specification:
The first line contains single integer *q* (1<=≤<=*q*<=≤<=105) — the number of queries.
*q* lines follow. The (*i*<=+<=1)-th line contains single integer *n**i* (1<=≤<=*n**i*<=≤<=109) — the *i*-th query.
Output Specification:
For each query print the maximum possible number of summands in a valid splitting to composite summands, or -1, if there are no such splittings.
Demo Input:
['1\n12\n', '2\n6\n8\n', '3\n1\n2\n3\n']
Demo Output:
['3\n', '1\n2\n', '-1\n-1\n-1\n']
Note:
12 = 4 + 4 + 4 = 4 + 8 = 6 + 6 = 12, but the first splitting has the maximum possible number of summands.
8 = 4 + 4, 6 can't be split into several composite summands.
1, 2, 3 are less than any composite number, so they do not have valid splittings.
|
```python
n = int(input())
for _ in range(n):
a = int(input())
b = a // 4
a %= 4
if a == 1:
b -= 1
elif a == 3:
b -= 2
if b > 0:
print(b)
else:
print(-1)
```
| 0
|
|
43
|
A
|
Football
|
PROGRAMMING
| 1,000
|
[
"strings"
] |
A. Football
|
2
|
256
|
One day Vasya decided to have a look at the results of Berland 1910 Football Championship’s finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are *n* lines in that description each of which described one goal. Every goal was marked with the name of the team that had scored it. Help Vasya, learn the name of the team that won the finals. It is guaranteed that the match did not end in a tie.
|
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of lines in the description. Then follow *n* lines — for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match did not end in a tie and the description contains no more than two different teams.
|
Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner.
|
[
"1\nABC\n",
"5\nA\nABA\nABA\nA\nA\n"
] |
[
"ABC\n",
"A\n"
] |
none
| 500
|
[
{
"input": "1\nABC",
"output": "ABC"
},
{
"input": "5\nA\nABA\nABA\nA\nA",
"output": "A"
},
{
"input": "2\nXTSJEP\nXTSJEP",
"output": "XTSJEP"
},
{
"input": "3\nXZYDJAEDZ\nXZYDJAEDZ\nXZYDJAEDZ",
"output": "XZYDJAEDZ"
},
{
"input": "3\nQCCYXL\nQCCYXL\nAXGLFQDD",
"output": "QCCYXL"
},
{
"input": "3\nAZID\nEERWBC\nEERWBC",
"output": "EERWBC"
},
{
"input": "3\nHNCGYL\nHNCGYL\nHNCGYL",
"output": "HNCGYL"
},
{
"input": "4\nZZWZTG\nZZWZTG\nZZWZTG\nZZWZTG",
"output": "ZZWZTG"
},
{
"input": "4\nA\nA\nKUDLJMXCSE\nA",
"output": "A"
},
{
"input": "5\nPHBTW\nPHBTW\nPHBTW\nPHBTW\nPHBTW",
"output": "PHBTW"
},
{
"input": "5\nPKUZYTFYWN\nPKUZYTFYWN\nSTC\nPKUZYTFYWN\nPKUZYTFYWN",
"output": "PKUZYTFYWN"
},
{
"input": "5\nHH\nHH\nNTQWPA\nNTQWPA\nHH",
"output": "HH"
},
{
"input": "10\nW\nW\nW\nW\nW\nD\nW\nD\nD\nW",
"output": "W"
},
{
"input": "19\nXBCP\nTGACNIH\nXBCP\nXBCP\nXBCP\nXBCP\nXBCP\nTGACNIH\nXBCP\nXBCP\nXBCP\nXBCP\nXBCP\nTGACNIH\nXBCP\nXBCP\nTGACNIH\nTGACNIH\nXBCP",
"output": "XBCP"
},
{
"input": "33\nOWQWCKLLF\nOWQWCKLLF\nOWQWCKLLF\nPYPAS\nPYPAS\nPYPAS\nOWQWCKLLF\nPYPAS\nOWQWCKLLF\nPYPAS\nPYPAS\nOWQWCKLLF\nOWQWCKLLF\nOWQWCKLLF\nPYPAS\nOWQWCKLLF\nPYPAS\nPYPAS\nPYPAS\nPYPAS\nOWQWCKLLF\nPYPAS\nPYPAS\nOWQWCKLLF\nOWQWCKLLF\nPYPAS\nOWQWCKLLF\nOWQWCKLLF\nPYPAS\nPYPAS\nOWQWCKLLF\nPYPAS\nPYPAS",
"output": "PYPAS"
},
{
"input": "51\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC\nNC",
"output": "NC"
},
{
"input": "89\nH\nVOCI\nVOCI\nH\nVOCI\nH\nH\nVOCI\nVOCI\nVOCI\nH\nH\nH\nVOCI\nVOCI\nVOCI\nH\nVOCI\nVOCI\nH\nVOCI\nVOCI\nVOCI\nH\nVOCI\nH\nVOCI\nH\nVOCI\nH\nVOCI\nVOCI\nH\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nH\nVOCI\nVOCI\nVOCI\nVOCI\nH\nVOCI\nH\nH\nVOCI\nH\nVOCI\nH\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nH\nH\nVOCI\nH\nH\nVOCI\nH\nVOCI\nH\nVOCI\nVOCI\nH\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nVOCI\nH\nH\nH\nH\nH\nVOCI\nH\nVOCI\nH\nVOCI\nVOCI",
"output": "VOCI"
},
{
"input": "100\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nM\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA\nHA",
"output": "HA"
},
{
"input": "100\nG\nG\nS\nS\nG\nG\nS\nS\nG\nS\nS\nS\nG\nS\nG\nG\nS\nG\nS\nS\nG\nS\nS\nS\nS\nS\nG\nS\nG\nS\nS\nG\nG\nG\nS\nS\nS\nS\nG\nS\nS\nG\nG\nG\nG\nG\nS\nG\nG\nS\nS\nS\nS\nS\nG\nG\nS\nG\nG\nG\nG\nG\nS\nS\nG\nS\nS\nS\nS\nG\nS\nS\nG\nS\nG\nG\nG\nG\nG\nG\nG\nG\nG\nG\nG\nS\nS\nG\nS\nS\nS\nS\nG\nG\nG\nS\nG\nG\nG\nS",
"output": "G"
},
{
"input": "100\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nOBH\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL\nWL",
"output": "WL"
}
] | 1,623,646,092
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 34
| 186
| 0
|
n=int(input())
d=dict()
while n>0:
s=input()
if(s in d):
d[s]+=1
else:
d[s]=1
n-=1
res=0
o=''
for k,v in d.items():
if(v>res):
o=k
res=v
print(o)
|
Title: Football
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One day Vasya decided to have a look at the results of Berland 1910 Football Championship’s finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are *n* lines in that description each of which described one goal. Every goal was marked with the name of the team that had scored it. Help Vasya, learn the name of the team that won the finals. It is guaranteed that the match did not end in a tie.
Input Specification:
The first line contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of lines in the description. Then follow *n* lines — for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match did not end in a tie and the description contains no more than two different teams.
Output Specification:
Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner.
Demo Input:
['1\nABC\n', '5\nA\nABA\nABA\nA\nA\n']
Demo Output:
['ABC\n', 'A\n']
Note:
none
|
```python
n=int(input())
d=dict()
while n>0:
s=input()
if(s in d):
d[s]+=1
else:
d[s]=1
n-=1
res=0
o=''
for k,v in d.items():
if(v>res):
o=k
res=v
print(o)
```
| 3.9535
|
315
|
A
|
Sereja and Bottles
|
PROGRAMMING
| 1,400
|
[
"brute force"
] | null | null |
Sereja and his friends went to a picnic. The guys had *n* soda bottles just for it. Sereja forgot the bottle opener as usual, so the guys had to come up with another way to open bottles.
Sereja knows that the *i*-th bottle is from brand *a**i*, besides, you can use it to open other bottles of brand *b**i*. You can use one bottle to open multiple other bottles. Sereja can open bottle with opened bottle or closed bottle.
Knowing this, Sereja wants to find out the number of bottles they've got that they won't be able to open in any way. Help him and find this number.
|
The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of bottles. The next *n* lines contain the bottles' description. The *i*-th line contains two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=1000) — the description of the *i*-th bottle.
|
In a single line print a single integer — the answer to the problem.
|
[
"4\n1 1\n2 2\n3 3\n4 4\n",
"4\n1 2\n2 3\n3 4\n4 1\n"
] |
[
"4\n",
"0\n"
] |
none
| 500
|
[
{
"input": "4\n1 1\n2 2\n3 3\n4 4",
"output": "4"
},
{
"input": "4\n1 2\n2 3\n3 4\n4 1",
"output": "0"
},
{
"input": "3\n2 828\n4 392\n4 903",
"output": "3"
},
{
"input": "4\n2 3\n1 772\n3 870\n3 668",
"output": "2"
},
{
"input": "5\n1 4\n6 6\n4 3\n3 4\n4 758",
"output": "2"
},
{
"input": "6\n4 843\n2 107\n10 943\n9 649\n7 806\n6 730",
"output": "6"
},
{
"input": "7\n351 955\n7 841\n102 377\n394 102\n549 440\n630 324\n624 624",
"output": "6"
},
{
"input": "8\n83 978\n930 674\n542 22\n834 116\n116 271\n640 930\n659 930\n705 987",
"output": "6"
},
{
"input": "9\n162 942\n637 967\n356 108\n768 53\n656 656\n575 32\n32 575\n53 53\n351 222",
"output": "6"
},
{
"input": "10\n423 360\n947 538\n507 484\n31 947\n414 351\n169 901\n901 21\n592 22\n763 200\n656 485",
"output": "8"
},
{
"input": "1\n1000 1000",
"output": "1"
},
{
"input": "1\n500 1000",
"output": "1"
},
{
"input": "11\n1 1\n2 2\n3 3\n4 4\n5 5\n6 6\n7 7\n8 8\n9 9\n10 10\n11 11",
"output": "11"
},
{
"input": "49\n1 758\n5 3\n5 3\n4 2\n4 36\n3 843\n5 107\n1 943\n1 649\n2 806\n3 730\n2 351\n2 102\n1 4\n3 4\n3 955\n2 841\n2 377\n5 2\n3 440\n4 324\n3 3\n3 83\n2 2\n2 1\n4 1\n1 931\n3 4\n2 5\n2 5\n4 73\n5 830\n3 4\n3 5\n5 291\n1 2\n5 3\n4 4\n2 3\n3 151\n4 2\n4 431\n5 1\n2 5\n2 4\n4 2\n4 4\n3 1\n5 2",
"output": "0"
},
{
"input": "50\n507 31\n31 250\n414 763\n169 304\n901 9\n592 610\n763 414\n656 789\n411 422\n360 468\n625 504\n538 201\n549 619\n484 797\n596 282\n42 310\n603 656\n351 623\n292 293\n837 180\n375 658\n21 192\n597 729\n22 512\n349 635\n200 56\n669 647\n485 887\n282 939\n735 808\n54 417\n1000 310\n419 652\n939 617\n901 669\n789 390\n128 549\n468 511\n729 837\n894 729\n649 894\n484 22\n808 586\n422 286\n311 427\n618 656\n814 933\n515 901\n310 894\n617 330",
"output": "30"
},
{
"input": "2\n7 7\n5 359",
"output": "2"
},
{
"input": "2\n465 706\n706 706",
"output": "1"
},
{
"input": "2\n1 1\n1 1",
"output": "0"
},
{
"input": "3\n1 1\n1 1\n2 2",
"output": "1"
},
{
"input": "5\n1 1\n1 2\n2 3\n3 4\n4 3",
"output": "1"
},
{
"input": "3\n1 2\n1 2\n1 1",
"output": "1"
}
] | 1,590,236,035
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 2
| 248
| 0
|
n=int(input())
count=0
for i in range(n):
a,b=[int(i) for i in input().split()]
if(a==b):
count=count+1
else:
pass
print(count)
|
Title: Sereja and Bottles
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Sereja and his friends went to a picnic. The guys had *n* soda bottles just for it. Sereja forgot the bottle opener as usual, so the guys had to come up with another way to open bottles.
Sereja knows that the *i*-th bottle is from brand *a**i*, besides, you can use it to open other bottles of brand *b**i*. You can use one bottle to open multiple other bottles. Sereja can open bottle with opened bottle or closed bottle.
Knowing this, Sereja wants to find out the number of bottles they've got that they won't be able to open in any way. Help him and find this number.
Input Specification:
The first line contains integer *n* (1<=≤<=*n*<=≤<=100) — the number of bottles. The next *n* lines contain the bottles' description. The *i*-th line contains two integers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=1000) — the description of the *i*-th bottle.
Output Specification:
In a single line print a single integer — the answer to the problem.
Demo Input:
['4\n1 1\n2 2\n3 3\n4 4\n', '4\n1 2\n2 3\n3 4\n4 1\n']
Demo Output:
['4\n', '0\n']
Note:
none
|
```python
n=int(input())
count=0
for i in range(n):
a,b=[int(i) for i in input().split()]
if(a==b):
count=count+1
else:
pass
print(count)
```
| 0
|
|
825
|
A
|
Binary Protocol
|
PROGRAMMING
| 1,100
|
[
"implementation"
] | null | null |
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
- Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). - Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
|
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=89) — length of the string *s*.
The second line contains string *s* — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
|
Print the decoded number.
|
[
"3\n111\n",
"9\n110011101\n"
] |
[
"3\n",
"2031\n"
] |
none
| 0
|
[
{
"input": "3\n111",
"output": "3"
},
{
"input": "9\n110011101",
"output": "2031"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "3\n100",
"output": "100"
},
{
"input": "5\n10001",
"output": "1001"
},
{
"input": "14\n11001100011000",
"output": "202002000"
},
{
"input": "31\n1000011111111100011110111111111",
"output": "100090049"
},
{
"input": "53\n10110111011110111110111111011111110111111110111111111",
"output": "123456789"
},
{
"input": "89\n11111111101111111110111111111011111111101111111110111111111011111111101111111110111111111",
"output": "999999999"
},
{
"input": "10\n1000000000",
"output": "1000000000"
},
{
"input": "2\n10",
"output": "10"
},
{
"input": "4\n1110",
"output": "30"
},
{
"input": "8\n10101010",
"output": "11110"
}
] | 1,500,218,372
| 872
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 5,529,600
|
n = int(input())
s = input()
res = ""
cur = 0
prev = -1
for i in s:
if i == '0':
if prev == '0':
res += '0'
else:
res += str(cur)
cur = 0
else:
cur += 1
prev = i
if cur != 0:
res += str(cur)
print (res)
|
Title: Binary Protocol
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
- Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). - Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input Specification:
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=89) — length of the string *s*.
The second line contains string *s* — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output Specification:
Print the decoded number.
Demo Input:
['3\n111\n', '9\n110011101\n']
Demo Output:
['3\n', '2031\n']
Note:
none
|
```python
n = int(input())
s = input()
res = ""
cur = 0
prev = -1
for i in s:
if i == '0':
if prev == '0':
res += '0'
else:
res += str(cur)
cur = 0
else:
cur += 1
prev = i
if cur != 0:
res += str(cur)
print (res)
```
| 0
|
|
755
|
A
|
PolandBall and Hypothesis
|
PROGRAMMING
| 800
|
[
"brute force",
"graphs",
"math",
"number theory"
] | null | null |
PolandBall is a young, clever Ball. He is interested in prime numbers. He has stated a following hypothesis: "There exists such a positive integer *n* that for each positive integer *m* number *n*·*m*<=+<=1 is a prime number".
Unfortunately, PolandBall is not experienced yet and doesn't know that his hypothesis is incorrect. Could you prove it wrong? Write a program that finds a counterexample for any *n*.
|
The only number in the input is *n* (1<=≤<=*n*<=≤<=1000) — number from the PolandBall's hypothesis.
|
Output such *m* that *n*·*m*<=+<=1 is not a prime number. Your answer will be considered correct if you output any suitable *m* such that 1<=≤<=*m*<=≤<=103. It is guaranteed the the answer exists.
|
[
"3\n",
"4\n"
] |
[
"1",
"2"
] |
A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.
For the first sample testcase, 3·1 + 1 = 4. We can output 1.
In the second sample testcase, 4·1 + 1 = 5. We cannot output 1 because 5 is prime. However, *m* = 2 is okay since 4·2 + 1 = 9, which is not a prime number.
| 500
|
[
{
"input": "3",
"output": "1"
},
{
"input": "4",
"output": "2"
},
{
"input": "10",
"output": "2"
},
{
"input": "153",
"output": "1"
},
{
"input": "1000",
"output": "1"
},
{
"input": "1",
"output": "3"
},
{
"input": "2",
"output": "4"
},
{
"input": "5",
"output": "1"
},
{
"input": "6",
"output": "4"
},
{
"input": "7",
"output": "1"
},
{
"input": "8",
"output": "1"
},
{
"input": "9",
"output": "1"
},
{
"input": "11",
"output": "1"
},
{
"input": "998",
"output": "1"
},
{
"input": "996",
"output": "3"
},
{
"input": "36",
"output": "4"
},
{
"input": "210",
"output": "4"
},
{
"input": "270",
"output": "4"
},
{
"input": "306",
"output": "4"
},
{
"input": "330",
"output": "5"
},
{
"input": "336",
"output": "4"
},
{
"input": "600",
"output": "4"
},
{
"input": "726",
"output": "4"
},
{
"input": "988",
"output": "1"
},
{
"input": "12",
"output": "2"
},
{
"input": "987",
"output": "1"
},
{
"input": "13",
"output": "1"
},
{
"input": "986",
"output": "1"
},
{
"input": "14",
"output": "1"
},
{
"input": "985",
"output": "1"
},
{
"input": "15",
"output": "1"
},
{
"input": "984",
"output": "1"
},
{
"input": "16",
"output": "2"
},
{
"input": "983",
"output": "1"
},
{
"input": "17",
"output": "1"
},
{
"input": "982",
"output": "2"
},
{
"input": "18",
"output": "3"
},
{
"input": "981",
"output": "1"
},
{
"input": "19",
"output": "1"
},
{
"input": "980",
"output": "1"
},
{
"input": "20",
"output": "1"
},
{
"input": "979",
"output": "1"
},
{
"input": "21",
"output": "1"
},
{
"input": "978",
"output": "1"
},
{
"input": "22",
"output": "2"
},
{
"input": "977",
"output": "1"
},
{
"input": "23",
"output": "1"
},
{
"input": "976",
"output": "2"
},
{
"input": "24",
"output": "1"
},
{
"input": "975",
"output": "1"
},
{
"input": "25",
"output": "1"
},
{
"input": "2",
"output": "4"
},
{
"input": "6",
"output": "4"
},
{
"input": "996",
"output": "3"
},
{
"input": "8",
"output": "1"
},
{
"input": "998",
"output": "1"
},
{
"input": "330",
"output": "5"
},
{
"input": "18",
"output": "3"
},
{
"input": "12",
"output": "2"
},
{
"input": "24",
"output": "1"
},
{
"input": "999",
"output": "1"
},
{
"input": "726",
"output": "4"
},
{
"input": "876",
"output": "3"
}
] | 1,631,595,731
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 4
| 62
| 6,758,400
|
# Time complexity: O(1)
# Space complexity: O(1)
# Rationale: when m = n+2, n*m+1 = n*(n+2)+1 = (n+1)^2. This works for 1<=n<=1000.
n = int(input())
print(n+2)
|
Title: PolandBall and Hypothesis
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
PolandBall is a young, clever Ball. He is interested in prime numbers. He has stated a following hypothesis: "There exists such a positive integer *n* that for each positive integer *m* number *n*·*m*<=+<=1 is a prime number".
Unfortunately, PolandBall is not experienced yet and doesn't know that his hypothesis is incorrect. Could you prove it wrong? Write a program that finds a counterexample for any *n*.
Input Specification:
The only number in the input is *n* (1<=≤<=*n*<=≤<=1000) — number from the PolandBall's hypothesis.
Output Specification:
Output such *m* that *n*·*m*<=+<=1 is not a prime number. Your answer will be considered correct if you output any suitable *m* such that 1<=≤<=*m*<=≤<=103. It is guaranteed the the answer exists.
Demo Input:
['3\n', '4\n']
Demo Output:
['1', '2']
Note:
A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.
For the first sample testcase, 3·1 + 1 = 4. We can output 1.
In the second sample testcase, 4·1 + 1 = 5. We cannot output 1 because 5 is prime. However, *m* = 2 is okay since 4·2 + 1 = 9, which is not a prime number.
|
```python
# Time complexity: O(1)
# Space complexity: O(1)
# Rationale: when m = n+2, n*m+1 = n*(n+2)+1 = (n+1)^2. This works for 1<=n<=1000.
n = int(input())
print(n+2)
```
| 0
|
|
12
|
B
|
Correct Solution?
|
PROGRAMMING
| 1,100
|
[
"implementation",
"sortings"
] |
B. Correct Solution?
|
2
|
256
|
One cold winter evening Alice and her older brother Bob was sitting at home near the fireplace and giving each other interesting problems to solve. When it was Alice's turn, she told the number *n* to Bob and said:
—Shuffle the digits in this number in order to obtain the smallest possible number without leading zeroes.
—No problem! — said Bob and immediately gave her an answer.
Alice said a random number, so she doesn't know whether Bob's answer is correct. Help her to find this out, because impatient brother is waiting for the verdict.
|
The first line contains one integer *n* (0<=≤<=*n*<=≤<=109) without leading zeroes. The second lines contains one integer *m* (0<=≤<=*m*<=≤<=109) — Bob's answer, possibly with leading zeroes.
|
Print OK if Bob's answer is correct and WRONG_ANSWER otherwise.
|
[
"3310\n1033\n",
"4\n5\n"
] |
[
"OK\n",
"WRONG_ANSWER\n"
] |
none
| 0
|
[
{
"input": "3310\n1033",
"output": "OK"
},
{
"input": "4\n5",
"output": "WRONG_ANSWER"
},
{
"input": "40\n04",
"output": "WRONG_ANSWER"
},
{
"input": "12\n12",
"output": "OK"
},
{
"input": "432\n234",
"output": "OK"
},
{
"input": "17109\n01179",
"output": "WRONG_ANSWER"
},
{
"input": "888\n888",
"output": "OK"
},
{
"input": "912\n9123",
"output": "WRONG_ANSWER"
},
{
"input": "0\n00",
"output": "WRONG_ANSWER"
},
{
"input": "11110\n1111",
"output": "WRONG_ANSWER"
},
{
"input": "7391\n1397",
"output": "WRONG_ANSWER"
},
{
"input": "201\n102",
"output": "OK"
},
{
"input": "111111111\n111111111",
"output": "OK"
},
{
"input": "32352320\n22203335",
"output": "WRONG_ANSWER"
},
{
"input": "1000000000\n1",
"output": "WRONG_ANSWER"
},
{
"input": "994321\n123499",
"output": "OK"
},
{
"input": "10101\n10101",
"output": "WRONG_ANSWER"
},
{
"input": "666\n0666",
"output": "WRONG_ANSWER"
},
{
"input": "2\n02",
"output": "WRONG_ANSWER"
},
{
"input": "313\n133",
"output": "OK"
},
{
"input": "987235645\n234556789",
"output": "OK"
},
{
"input": "90812\n010289",
"output": "WRONG_ANSWER"
},
{
"input": "123\n321",
"output": "WRONG_ANSWER"
},
{
"input": "707\n770",
"output": "WRONG_ANSWER"
},
{
"input": "77774444\n47474747",
"output": "WRONG_ANSWER"
},
{
"input": "1270\n1027",
"output": "OK"
},
{
"input": "320\n23",
"output": "WRONG_ANSWER"
},
{
"input": "123456789\n123456789",
"output": "OK"
},
{
"input": "918273645\n546372819",
"output": "WRONG_ANSWER"
},
{
"input": "300000003\n30000003",
"output": "WRONG_ANSWER"
},
{
"input": "0\n0",
"output": "OK"
},
{
"input": "0\n7",
"output": "WRONG_ANSWER"
}
] | 1,669,279,386
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 8
| 62
| 0
|
n = input()
m = input()
n = [x for x in n]
m = [x for x in m]
n.sort()
a = n.copy()
if n.count('0')>0:
n0 = n.count('0')
n.remove('0')
ch = ['0' for x in range(n0)]
a = [n[0]]
a.extend(ch)
a.extend(n[1:])
if a == m:
print('OK')
else:
print('WRONG_ANSWER')
|
Title: Correct Solution?
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One cold winter evening Alice and her older brother Bob was sitting at home near the fireplace and giving each other interesting problems to solve. When it was Alice's turn, she told the number *n* to Bob and said:
—Shuffle the digits in this number in order to obtain the smallest possible number without leading zeroes.
—No problem! — said Bob and immediately gave her an answer.
Alice said a random number, so she doesn't know whether Bob's answer is correct. Help her to find this out, because impatient brother is waiting for the verdict.
Input Specification:
The first line contains one integer *n* (0<=≤<=*n*<=≤<=109) without leading zeroes. The second lines contains one integer *m* (0<=≤<=*m*<=≤<=109) — Bob's answer, possibly with leading zeroes.
Output Specification:
Print OK if Bob's answer is correct and WRONG_ANSWER otherwise.
Demo Input:
['3310\n1033\n', '4\n5\n']
Demo Output:
['OK\n', 'WRONG_ANSWER\n']
Note:
none
|
```python
n = input()
m = input()
n = [x for x in n]
m = [x for x in m]
n.sort()
a = n.copy()
if n.count('0')>0:
n0 = n.count('0')
n.remove('0')
ch = ['0' for x in range(n0)]
a = [n[0]]
a.extend(ch)
a.extend(n[1:])
if a == m:
print('OK')
else:
print('WRONG_ANSWER')
```
| -1
|
157
|
B
|
Trace
|
PROGRAMMING
| 1,000
|
[
"geometry",
"sortings"
] | null | null |
One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
|
The first line contains the single integer *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integers *r**i* (1<=≤<=*r**i*<=≤<=1000) — the circles' radii. It is guaranteed that all circles are different.
|
Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10<=-<=4.
|
[
"1\n1\n",
"3\n1 4 2\n"
] |
[
"3.1415926536\n",
"40.8407044967\n"
] |
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 1<sup class="upper-index">2</sup> = π.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 4<sup class="upper-index">2</sup> - π × 2<sup class="upper-index">2</sup>) + π × 1<sup class="upper-index">2</sup> = π × 12 + π = 13π
| 1,000
|
[
{
"input": "1\n1",
"output": "3.1415926536"
},
{
"input": "3\n1 4 2",
"output": "40.8407044967"
},
{
"input": "4\n4 1 3 2",
"output": "31.4159265359"
},
{
"input": "4\n100 10 2 1",
"output": "31111.1920484997"
},
{
"input": "10\n10 9 8 7 6 5 4 3 2 1",
"output": "172.7875959474"
},
{
"input": "1\n1000",
"output": "3141592.6535897931"
},
{
"input": "8\n8 1 7 2 6 3 5 4",
"output": "113.0973355292"
},
{
"input": "100\n1000 999 998 997 996 995 994 993 992 991 990 989 988 987 986 985 984 983 982 981 980 979 978 977 976 975 974 973 972 971 970 969 968 967 966 965 964 963 962 961 960 959 958 957 956 955 954 953 952 951 950 949 948 947 946 945 944 943 942 941 940 939 938 937 936 935 934 933 932 931 930 929 928 927 926 925 924 923 922 921 920 919 918 917 916 915 914 913 912 911 910 909 908 907 906 905 904 903 902 901",
"output": "298608.3817237098"
},
{
"input": "6\n109 683 214 392 678 10",
"output": "397266.9574170437"
},
{
"input": "2\n151 400",
"output": "431023.3704798660"
},
{
"input": "6\n258 877 696 425 663 934",
"output": "823521.3902487604"
},
{
"input": "9\n635 707 108 234 52 180 910 203 782",
"output": "1100144.9065826489"
},
{
"input": "8\n885 879 891 428 522 176 135 983",
"output": "895488.9947571954"
},
{
"input": "3\n269 918 721",
"output": "1241695.6467754442"
},
{
"input": "7\n920 570 681 428 866 935 795",
"output": "1469640.1849419588"
},
{
"input": "2\n517 331",
"output": "495517.1260654109"
},
{
"input": "2\n457 898",
"output": "1877274.3981158488"
},
{
"input": "8\n872 704 973 612 183 274 739 253",
"output": "1780774.0965755312"
},
{
"input": "74\n652 446 173 457 760 847 670 25 196 775 998 279 656 809 883 148 969 884 792 502 641 800 663 938 362 339 545 608 107 184 834 666 149 458 864 72 199 658 618 987 126 723 806 643 689 958 626 904 944 415 427 498 628 331 636 261 281 276 478 220 513 595 510 384 354 561 469 462 799 449 747 109 903 456",
"output": "1510006.5089479341"
},
{
"input": "76\n986 504 673 158 87 332 124 218 714 235 212 122 878 370 938 81 686 323 386 348 410 468 875 107 50 960 82 834 234 663 651 422 794 633 294 771 945 607 146 913 950 858 297 88 882 725 247 872 645 749 799 987 115 394 380 382 971 429 593 426 652 353 351 233 868 598 889 116 71 376 916 464 414 976 138 903",
"output": "1528494.7817143100"
},
{
"input": "70\n12 347 748 962 514 686 192 159 990 4 10 788 602 542 946 215 523 727 799 717 955 796 529 465 897 103 181 515 495 153 710 179 747 145 16 585 943 998 923 708 156 399 770 547 775 285 9 68 713 722 570 143 913 416 663 624 925 218 64 237 797 138 942 213 188 818 780 840 480 758",
"output": "1741821.4892636713"
},
{
"input": "26\n656 508 45 189 561 366 96 486 547 386 703 570 780 689 264 26 11 74 466 76 421 48 982 886 215 650",
"output": "1818821.9252031571"
},
{
"input": "52\n270 658 808 249 293 707 700 78 791 167 92 772 807 502 830 991 945 102 968 376 556 578 326 980 688 368 280 853 646 256 666 638 424 737 321 996 925 405 199 680 953 541 716 481 727 143 577 919 892 355 346 298",
"output": "1272941.9273080483"
},
{
"input": "77\n482 532 200 748 692 697 171 863 586 547 301 149 326 812 147 698 303 691 527 805 681 387 619 947 598 453 167 799 840 508 893 688 643 974 998 341 804 230 538 669 271 404 477 759 943 596 949 235 880 160 151 660 832 82 969 539 708 889 258 81 224 655 790 144 462 582 646 256 445 52 456 920 67 819 631 484 534",
"output": "2045673.1891262225"
},
{
"input": "27\n167 464 924 575 775 97 944 390 297 315 668 296 533 829 851 406 702 366 848 512 71 197 321 900 544 529 116",
"output": "1573959.9105970615"
},
{
"input": "38\n488 830 887 566 720 267 583 102 65 200 884 220 263 858 510 481 316 804 754 568 412 166 374 869 356 977 145 421 500 58 664 252 745 70 381 927 670 772",
"output": "1479184.3434235646"
},
{
"input": "64\n591 387 732 260 840 397 563 136 571 876 831 953 799 493 579 13 559 872 53 678 256 232 969 993 847 14 837 365 547 997 604 199 834 529 306 443 739 49 19 276 343 835 904 588 900 870 439 576 975 955 518 117 131 347 800 83 432 882 869 709 32 950 314 450",
"output": "1258248.6984672088"
},
{
"input": "37\n280 281 169 68 249 389 977 101 360 43 448 447 368 496 125 507 747 392 338 270 916 150 929 428 118 266 589 470 774 852 263 644 187 817 808 58 637",
"output": "1495219.0323274869"
},
{
"input": "97\n768 569 306 968 437 779 227 561 412 60 44 807 234 645 169 858 580 396 343 145 842 723 416 80 456 247 81 150 297 116 760 964 312 558 101 850 549 650 299 868 121 435 579 705 118 424 302 812 970 397 659 565 916 183 933 459 6 593 518 717 326 305 744 470 75 981 824 221 294 324 194 293 251 446 481 215 338 861 528 829 921 945 540 89 450 178 24 460 990 392 148 219 934 615 932 340 937",
"output": "1577239.7333274092"
},
{
"input": "94\n145 703 874 425 277 652 239 496 458 658 339 842 564 699 893 352 625 980 432 121 798 872 499 859 850 721 414 825 543 843 304 111 342 45 219 311 50 748 465 902 781 822 504 985 919 656 280 310 917 438 464 527 491 713 906 329 635 777 223 810 501 535 156 252 806 112 971 719 103 443 165 98 579 554 244 996 221 560 301 51 977 422 314 858 528 772 448 626 185 194 536 66 577 677",
"output": "1624269.3753516484"
},
{
"input": "97\n976 166 649 81 611 927 480 231 998 711 874 91 969 521 531 414 993 790 317 981 9 261 437 332 173 573 904 777 882 990 658 878 965 64 870 896 271 732 431 53 761 943 418 602 708 949 930 130 512 240 363 458 673 319 131 784 224 48 919 126 208 212 911 59 677 535 450 273 479 423 79 807 336 18 72 290 724 28 123 605 287 228 350 897 250 392 885 655 746 417 643 114 813 378 355 635 905",
"output": "1615601.7212203942"
},
{
"input": "91\n493 996 842 9 748 178 1 807 841 519 796 998 84 670 778 143 707 208 165 893 154 943 336 150 761 881 434 112 833 55 412 682 552 945 758 189 209 600 354 325 440 844 410 20 136 665 88 791 688 17 539 821 133 236 94 606 483 446 429 60 960 476 915 134 137 852 754 908 276 482 117 252 297 903 981 203 829 811 471 135 188 667 710 393 370 302 874 872 551 457 692",
"output": "1806742.5014501044"
},
{
"input": "95\n936 736 17 967 229 607 589 291 242 244 29 698 800 566 630 667 90 416 11 94 812 838 668 520 678 111 490 823 199 973 681 676 683 721 262 896 682 713 402 691 874 44 95 704 56 322 822 887 639 433 406 35 988 61 176 496 501 947 440 384 372 959 577 370 754 802 1 945 427 116 746 408 308 391 397 730 493 183 203 871 831 862 461 565 310 344 504 378 785 137 279 123 475 138 415",
"output": "1611115.5269110680"
},
{
"input": "90\n643 197 42 218 582 27 66 704 195 445 641 675 285 639 503 686 242 327 57 955 848 287 819 992 756 749 363 48 648 736 580 117 752 921 923 372 114 313 202 337 64 497 399 25 883 331 24 871 917 8 517 486 323 529 325 92 891 406 864 402 263 773 931 253 625 31 17 271 140 131 232 586 893 525 846 54 294 562 600 801 214 55 768 683 389 738 314 284 328 804",
"output": "1569819.2914796301"
},
{
"input": "98\n29 211 984 75 333 96 840 21 352 168 332 433 130 944 215 210 620 442 363 877 91 491 513 955 53 82 351 19 998 706 702 738 770 453 344 117 893 590 723 662 757 16 87 546 312 669 568 931 224 374 927 225 751 962 651 587 361 250 256 240 282 600 95 64 384 589 813 783 39 918 412 648 506 283 886 926 443 173 946 241 310 33 622 565 261 360 547 339 943 367 354 25 479 743 385 485 896 741",
"output": "2042921.1539616778"
},
{
"input": "93\n957 395 826 67 185 4 455 880 683 654 463 84 258 878 553 592 124 585 9 133 20 609 43 452 725 125 801 537 700 685 771 155 566 376 19 690 383 352 174 208 177 416 304 1000 533 481 87 509 358 233 681 22 507 659 36 859 952 259 138 271 594 779 576 782 119 69 608 758 283 616 640 523 710 751 34 106 774 92 874 568 864 660 998 992 474 679 180 409 15 297 990 689 501",
"output": "1310703.8710041976"
},
{
"input": "97\n70 611 20 30 904 636 583 262 255 501 604 660 212 128 199 138 545 576 506 528 12 410 77 888 783 972 431 188 338 485 148 793 907 678 281 922 976 680 252 724 253 920 177 361 721 798 960 572 99 622 712 466 608 49 612 345 266 751 63 594 40 695 532 789 520 930 825 929 48 59 405 135 109 735 508 186 495 772 375 587 201 324 447 610 230 947 855 318 856 956 313 810 931 175 668 183 688",
"output": "1686117.9099228707"
},
{
"input": "96\n292 235 391 180 840 172 218 997 166 287 329 20 886 325 400 471 182 356 448 337 417 319 58 106 366 764 393 614 90 831 924 314 667 532 64 874 3 434 350 352 733 795 78 640 967 63 47 879 635 272 145 569 468 792 153 761 770 878 281 467 209 208 298 37 700 18 334 93 5 750 412 779 523 517 360 649 447 328 311 653 57 578 767 460 647 663 50 670 151 13 511 580 625 907 227 89",
"output": "1419726.5608617242"
},
{
"input": "100\n469 399 735 925 62 153 707 723 819 529 200 624 57 708 245 384 889 11 639 638 260 419 8 142 403 298 204 169 887 388 241 983 885 267 643 943 417 237 452 562 6 839 149 742 832 896 100 831 712 754 679 743 135 222 445 680 210 955 220 63 960 487 514 824 481 584 441 997 795 290 10 45 510 678 844 503 407 945 850 84 858 934 500 320 936 663 736 592 161 670 606 465 864 969 293 863 868 393 899 744",
"output": "1556458.0979239127"
},
{
"input": "100\n321 200 758 415 190 710 920 992 873 898 814 259 359 66 971 210 838 545 663 652 684 277 36 756 963 459 335 484 462 982 532 423 131 703 307 229 391 938 253 847 542 975 635 928 220 980 222 567 557 181 366 824 900 180 107 979 112 564 525 413 300 422 876 615 737 343 902 8 654 628 469 913 967 785 893 314 909 215 912 262 20 709 363 915 997 954 986 454 596 124 74 159 660 550 787 418 895 786 293 50",
"output": "1775109.8050211088"
},
{
"input": "100\n859 113 290 762 701 63 188 431 810 485 671 673 99 658 194 227 511 435 941 212 551 124 89 222 42 321 657 815 898 171 216 482 707 567 724 491 414 942 820 351 48 653 685 312 586 24 20 627 602 498 533 173 463 262 621 466 119 299 580 964 510 987 40 698 521 998 847 651 746 215 808 563 785 837 631 772 404 923 682 244 232 214 390 350 968 771 517 900 70 543 934 554 681 368 642 575 891 728 478 317",
"output": "1447969.4788174964"
},
{
"input": "100\n941 283 349 457 52 837 299 284 796 305 893 624 101 972 738 204 121 70 17 704 836 791 95 111 162 952 472 724 733 580 878 177 705 804 11 211 463 417 288 409 410 485 896 755 921 267 164 656 505 765 539 439 535 19 991 689 220 474 114 944 884 144 926 849 486 566 117 35 749 499 797 303 362 905 690 890 976 66 590 183 234 683 39 297 769 787 376 541 571 759 495 200 261 352 73 493 831 442 273 339",
"output": "1597889.4218394549"
},
{
"input": "100\n110 868 147 888 291 282 916 542 917 337 235 595 498 621 814 249 261 713 445 666 142 275 319 49 900 543 333 606 487 670 620 769 852 258 230 867 603 491 714 839 879 37 21 74 590 190 397 506 499 967 152 862 200 107 145 23 614 167 857 475 79 598 270 906 626 116 89 59 651 846 723 201 50 699 522 408 634 132 226 414 824 764 513 586 526 238 556 162 667 173 684 415 527 743 10 442 552 274 350 822",
"output": "1567230.6191330721"
},
{
"input": "100\n901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000",
"output": "298608.3817237098"
}
] | 1,538,083,185
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 44
| 280
| 0
|
from math import pi
n = int(input())
arr = [int(i) for i in input().strip().split()]
arr.sort(reverse = True)
if n % 2 != 0:
arr.append(0)
ans = 0
for i in range(0, len(arr), +2):
ans += arr[i]**2 - arr[i+1]**2
print(pi*ans)
|
Title: Trace
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
Input Specification:
The first line contains the single integer *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integers *r**i* (1<=≤<=*r**i*<=≤<=1000) — the circles' radii. It is guaranteed that all circles are different.
Output Specification:
Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10<=-<=4.
Demo Input:
['1\n1\n', '3\n1 4 2\n']
Demo Output:
['3.1415926536\n', '40.8407044967\n']
Note:
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 1<sup class="upper-index">2</sup> = π.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 4<sup class="upper-index">2</sup> - π × 2<sup class="upper-index">2</sup>) + π × 1<sup class="upper-index">2</sup> = π × 12 + π = 13π
|
```python
from math import pi
n = int(input())
arr = [int(i) for i in input().strip().split()]
arr.sort(reverse = True)
if n % 2 != 0:
arr.append(0)
ans = 0
for i in range(0, len(arr), +2):
ans += arr[i]**2 - arr[i+1]**2
print(pi*ans)
```
| 3
|
|
771
|
C
|
Bear and Tree Jumps
|
PROGRAMMING
| 2,100
|
[
"dfs and similar",
"dp",
"trees"
] | null | null |
A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.
Limak is a little polar bear. He lives in a tree that consists of *n* vertices, numbered 1 through *n*.
Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most *k*.
For a pair of vertices (*s*,<=*t*) we define *f*(*s*,<=*t*) as the minimum number of jumps Limak needs to get from *s* to *t*. Your task is to find the sum of *f*(*s*,<=*t*) over all pairs of vertices (*s*,<=*t*) such that *s*<=<<=*t*.
|
The first line of the input contains two integers *n* and *k* (2<=≤<=*n*<=≤<=200<=000, 1<=≤<=*k*<=≤<=5) — the number of vertices in the tree and the maximum allowed jump distance respectively.
The next *n*<=-<=1 lines describe edges in the tree. The *i*-th of those lines contains two integers *a**i* and *b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*) — the indices on vertices connected with *i*-th edge.
It's guaranteed that the given edges form a tree.
|
Print one integer, denoting the sum of *f*(*s*,<=*t*) over all pairs of vertices (*s*,<=*t*) such that *s*<=<<=*t*.
|
[
"6 2\n1 2\n1 3\n2 4\n2 5\n4 6\n",
"13 3\n1 2\n3 2\n4 2\n5 2\n3 6\n10 6\n6 7\n6 13\n5 8\n5 9\n9 11\n11 12\n",
"3 5\n2 1\n3 1\n"
] |
[
"20\n",
"114\n",
"3\n"
] |
In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).
There are <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c0295201207e28a36e641d8cf599f45986059e71.png" style="max-width: 100.0%;max-height: 100.0%;"/> pairs of vertices (*s*, *t*) such that *s* < *t*. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5·2 + 10·1 = 20.
In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (*s* < *t*), so the answer is 3·1 = 3.
| 1,000
|
[
{
"input": "6 2\n1 2\n1 3\n2 4\n2 5\n4 6",
"output": "20"
},
{
"input": "13 3\n1 2\n3 2\n4 2\n5 2\n3 6\n10 6\n6 7\n6 13\n5 8\n5 9\n9 11\n11 12",
"output": "114"
},
{
"input": "3 5\n2 1\n3 1",
"output": "3"
},
{
"input": "2 1\n1 2",
"output": "1"
},
{
"input": "2 5\n2 1",
"output": "1"
},
{
"input": "15 1\n12 9\n13 7\n1 3\n10 4\n9 2\n2 15\n11 4\n2 14\n10 8\n6 7\n12 5\n8 7\n3 10\n10 2",
"output": "346"
},
{
"input": "4 2\n3 4\n2 4\n3 1",
"output": "7"
},
{
"input": "12 3\n5 11\n10 11\n6 4\n8 9\n4 12\n10 7\n4 1\n3 1\n2 12\n9 4\n9 10",
"output": "88"
}
] | 1,557,832,944
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 5
| 109
| 0
|
import math
#n=int(input())
# arr=list(map(int,input().strip().split()))
n,skip=list(map(int,input().strip().split()))
graph=[[2000 for i in range(n)] for j in range(n)]
for _ in range(n-1):
n1,n2=list(map(int,input().strip().split()))
graph[n1-1][n2-1]=1
graph[n2-1][n1-1] = 1
for i in range(n):
for j in range(n):
for k in range(n):
if graph[i][j]>graph[i][k]+graph[k][j]:
graph[i][j] = graph[i][k] + graph[k][j]
res=0
for i in range(n-1):
for j in range(i+1,n):
res+=math.ceil(graph[i][j]/skip)
#print(graph[i][j],skip,math.ceil(graph[i][j]/skip))
print(res)
|
Title: Bear and Tree Jumps
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.
Limak is a little polar bear. He lives in a tree that consists of *n* vertices, numbered 1 through *n*.
Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most *k*.
For a pair of vertices (*s*,<=*t*) we define *f*(*s*,<=*t*) as the minimum number of jumps Limak needs to get from *s* to *t*. Your task is to find the sum of *f*(*s*,<=*t*) over all pairs of vertices (*s*,<=*t*) such that *s*<=<<=*t*.
Input Specification:
The first line of the input contains two integers *n* and *k* (2<=≤<=*n*<=≤<=200<=000, 1<=≤<=*k*<=≤<=5) — the number of vertices in the tree and the maximum allowed jump distance respectively.
The next *n*<=-<=1 lines describe edges in the tree. The *i*-th of those lines contains two integers *a**i* and *b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=*n*) — the indices on vertices connected with *i*-th edge.
It's guaranteed that the given edges form a tree.
Output Specification:
Print one integer, denoting the sum of *f*(*s*,<=*t*) over all pairs of vertices (*s*,<=*t*) such that *s*<=<<=*t*.
Demo Input:
['6 2\n1 2\n1 3\n2 4\n2 5\n4 6\n', '13 3\n1 2\n3 2\n4 2\n5 2\n3 6\n10 6\n6 7\n6 13\n5 8\n5 9\n9 11\n11 12\n', '3 5\n2 1\n3 1\n']
Demo Output:
['20\n', '114\n', '3\n']
Note:
In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).
There are <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/c0295201207e28a36e641d8cf599f45986059e71.png" style="max-width: 100.0%;max-height: 100.0%;"/> pairs of vertices (*s*, *t*) such that *s* < *t*. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5·2 + 10·1 = 20.
In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (*s* < *t*), so the answer is 3·1 = 3.
|
```python
import math
#n=int(input())
# arr=list(map(int,input().strip().split()))
n,skip=list(map(int,input().strip().split()))
graph=[[2000 for i in range(n)] for j in range(n)]
for _ in range(n-1):
n1,n2=list(map(int,input().strip().split()))
graph[n1-1][n2-1]=1
graph[n2-1][n1-1] = 1
for i in range(n):
for j in range(n):
for k in range(n):
if graph[i][j]>graph[i][k]+graph[k][j]:
graph[i][j] = graph[i][k] + graph[k][j]
res=0
for i in range(n-1):
for j in range(i+1,n):
res+=math.ceil(graph[i][j]/skip)
#print(graph[i][j],skip,math.ceil(graph[i][j]/skip))
print(res)
```
| 0
|
|
558
|
B
|
Amr and The Large Array
|
PROGRAMMING
| 1,300
|
[
"implementation"
] | null | null |
Amr has got a large array of size *n*. Amr doesn't like large arrays so he intends to make it smaller.
Amr doesn't care about anything in the array except the beauty of it. The beauty of the array is defined to be the maximum number of times that some number occurs in this array. He wants to choose the smallest subsegment of this array such that the beauty of it will be the same as the original array.
Help Amr by choosing the smallest subsegment possible.
|
The first line contains one number *n* (1<=≤<=*n*<=≤<=105), the size of the array.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106), representing elements of the array.
|
Output two integers *l*,<=*r* (1<=≤<=*l*<=≤<=*r*<=≤<=*n*), the beginning and the end of the subsegment chosen respectively.
If there are several possible answers you may output any of them.
|
[
"5\n1 1 2 2 1\n",
"5\n1 2 2 3 1\n",
"6\n1 2 2 1 1 2\n"
] |
[
"1 5",
"2 3",
"1 5"
] |
A subsegment *B* of an array *A* from *l* to *r* is an array of size *r* - *l* + 1 where *B*<sub class="lower-index">*i*</sub> = *A*<sub class="lower-index">*l* + *i* - 1</sub> for all 1 ≤ *i* ≤ *r* - *l* + 1
| 1,000
|
[
{
"input": "5\n1 1 2 2 1",
"output": "1 5"
},
{
"input": "5\n1 2 2 3 1",
"output": "2 3"
},
{
"input": "6\n1 2 2 1 1 2",
"output": "1 5"
},
{
"input": "10\n1 1000000 2 1000000 3 2 1000000 1 2 1",
"output": "2 7"
},
{
"input": "10\n1 2 3 4 5 5 1 2 3 4",
"output": "5 6"
},
{
"input": "10\n1 1 2 1 1 2 2 1 2 3",
"output": "1 8"
},
{
"input": "10\n5 4 3 2 1 1 2 3 4 5",
"output": "5 6"
},
{
"input": "10\n1 10 100 1000 10000 1 10 100 1000 10000",
"output": "1 6"
},
{
"input": "10\n9 9 9 9 8 9 8 8 8 8",
"output": "1 6"
},
{
"input": "10\n1 11 111 1111 1 11 11 1 1111 1111",
"output": "2 7"
}
] | 1,437,560,963
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 10
| 249
| 14,848,000
|
n = int(input())
numbers = [ int(number) for number in input().split() ]
occurences = {}
for i in range(n):
number = numbers[i]
if number in occurences.keys():
occurences[number][0] += 1
occurences[number][2] = i+1
else:
occurences[number] = [ 1, i+1, -1 ]
result = [ -1, -1, -1 ]
for number in occurences.keys():
if occurences[number][0] > result[0]:
result = occurences[number][:]
elif occurences[number][0] == result[0]:
r1 = occurences[number][2]-occurences[number][1]
r2 = result[2]-result[1]
if r2 > r1:
result = occurences[number][:]
print(result[1], result[2])
|
Title: Amr and The Large Array
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Amr has got a large array of size *n*. Amr doesn't like large arrays so he intends to make it smaller.
Amr doesn't care about anything in the array except the beauty of it. The beauty of the array is defined to be the maximum number of times that some number occurs in this array. He wants to choose the smallest subsegment of this array such that the beauty of it will be the same as the original array.
Help Amr by choosing the smallest subsegment possible.
Input Specification:
The first line contains one number *n* (1<=≤<=*n*<=≤<=105), the size of the array.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=106), representing elements of the array.
Output Specification:
Output two integers *l*,<=*r* (1<=≤<=*l*<=≤<=*r*<=≤<=*n*), the beginning and the end of the subsegment chosen respectively.
If there are several possible answers you may output any of them.
Demo Input:
['5\n1 1 2 2 1\n', '5\n1 2 2 3 1\n', '6\n1 2 2 1 1 2\n']
Demo Output:
['1 5', '2 3', '1 5']
Note:
A subsegment *B* of an array *A* from *l* to *r* is an array of size *r* - *l* + 1 where *B*<sub class="lower-index">*i*</sub> = *A*<sub class="lower-index">*l* + *i* - 1</sub> for all 1 ≤ *i* ≤ *r* - *l* + 1
|
```python
n = int(input())
numbers = [ int(number) for number in input().split() ]
occurences = {}
for i in range(n):
number = numbers[i]
if number in occurences.keys():
occurences[number][0] += 1
occurences[number][2] = i+1
else:
occurences[number] = [ 1, i+1, -1 ]
result = [ -1, -1, -1 ]
for number in occurences.keys():
if occurences[number][0] > result[0]:
result = occurences[number][:]
elif occurences[number][0] == result[0]:
r1 = occurences[number][2]-occurences[number][1]
r2 = result[2]-result[1]
if r2 > r1:
result = occurences[number][:]
print(result[1], result[2])
```
| 0
|
|
306
|
A
|
Candies
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Polycarpus has got *n* candies and *m* friends (*n*<=≥<=*m*). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such *a**i*, where *a**i* is the number of candies in the *i*-th friend's present, that the maximum *a**i* differs from the least *a**i* as little as possible.
For example, if *n* is divisible by *m*, then he is going to present the same number of candies to all his friends, that is, the maximum *a**i* won't differ from the minimum one.
|
The single line of the input contains a pair of space-separated positive integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100;*n*<=≥<=*m*) — the number of candies and the number of Polycarpus's friends.
|
Print the required sequence *a*1,<=*a*2,<=...,<=*a**m*, where *a**i* is the number of candies in the *i*-th friend's present. All numbers *a**i* must be positive integers, total up to *n*, the maximum one should differ from the minimum one by the smallest possible value.
|
[
"12 3\n",
"15 4\n",
"18 7\n"
] |
[
"4 4 4 ",
"3 4 4 4 ",
"2 2 2 3 3 3 3 "
] |
Print *a*<sub class="lower-index">*i*</sub> in any order, separate the numbers by spaces.
| 500
|
[
{
"input": "12 4",
"output": "3 3 3 3 "
},
{
"input": "15 6",
"output": "2 2 2 3 3 3 "
},
{
"input": "18 8",
"output": "2 2 2 2 2 2 3 3 "
},
{
"input": "1 1",
"output": "1 "
},
{
"input": "2 1",
"output": "2 "
},
{
"input": "100 1",
"output": "100 "
},
{
"input": "100 100",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 "
},
{
"input": "100 10",
"output": "10 10 10 10 10 10 10 10 10 10 "
},
{
"input": "64 8",
"output": "8 8 8 8 8 8 8 8 "
},
{
"input": "81 27",
"output": "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 "
},
{
"input": "100 99",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 "
},
{
"input": "100 51",
"output": "1 1 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 "
},
{
"input": "100 49",
"output": "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 3 3 "
},
{
"input": "100 13",
"output": "7 7 7 7 8 8 8 8 8 8 8 8 8 "
},
{
"input": "97 11",
"output": "8 8 9 9 9 9 9 9 9 9 9 "
},
{
"input": "19 3",
"output": "6 6 7 "
},
{
"input": "99 10",
"output": "9 10 10 10 10 10 10 10 10 10 "
},
{
"input": "88 5",
"output": "17 17 18 18 18 "
},
{
"input": "87 34",
"output": "2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 "
},
{
"input": "97 55",
"output": "1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 "
}
] | 1,577,347,058
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 216
| 0
|
candies,n=input().split(" ")
candies=int(candies)
n=int(n)
answer=[]
while(n>0):
temp=int(candies/n)
answer.append(temp)
n-=1
candies=candies-temp
for i in answer:
print(answer[i], end=" ")
|
Title: Candies
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarpus has got *n* candies and *m* friends (*n*<=≥<=*m*). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such *a**i*, where *a**i* is the number of candies in the *i*-th friend's present, that the maximum *a**i* differs from the least *a**i* as little as possible.
For example, if *n* is divisible by *m*, then he is going to present the same number of candies to all his friends, that is, the maximum *a**i* won't differ from the minimum one.
Input Specification:
The single line of the input contains a pair of space-separated positive integers *n*, *m* (1<=≤<=*n*,<=*m*<=≤<=100;*n*<=≥<=*m*) — the number of candies and the number of Polycarpus's friends.
Output Specification:
Print the required sequence *a*1,<=*a*2,<=...,<=*a**m*, where *a**i* is the number of candies in the *i*-th friend's present. All numbers *a**i* must be positive integers, total up to *n*, the maximum one should differ from the minimum one by the smallest possible value.
Demo Input:
['12 3\n', '15 4\n', '18 7\n']
Demo Output:
['4 4 4 ', '3 4 4 4 ', '2 2 2 3 3 3 3 ']
Note:
Print *a*<sub class="lower-index">*i*</sub> in any order, separate the numbers by spaces.
|
```python
candies,n=input().split(" ")
candies=int(candies)
n=int(n)
answer=[]
while(n>0):
temp=int(candies/n)
answer.append(temp)
n-=1
candies=candies-temp
for i in answer:
print(answer[i], end=" ")
```
| 0
|
|
527
|
A
|
Playing with Paper
|
PROGRAMMING
| 1,100
|
[
"implementation",
"math"
] | null | null |
One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a square piece of paper from the rectangular sheet by folding the sheet along the bisector of the right angle, and cutting the excess part.
After making a paper ship from the square piece, Vasya looked on the remaining (*a*<=-<=*b*) mm <=×<= *b* mm strip of paper. He got the idea to use this strip of paper in the same way to make an origami, and then use the remainder (if it exists) and so on. At the moment when he is left with a square piece of paper, he will make the last ship from it and stop.
Can you determine how many ships Vasya will make during the lesson?
|
The first line of the input contains two integers *a*, *b* (1<=≤<=*b*<=<<=*a*<=≤<=1012) — the sizes of the original sheet of paper.
|
Print a single integer — the number of ships that Vasya will make.
|
[
"2 1\n",
"10 7\n",
"1000000000000 1\n"
] |
[
"2\n",
"6\n",
"1000000000000\n"
] |
Pictures to the first and second sample test.
| 500
|
[
{
"input": "2 1",
"output": "2"
},
{
"input": "10 7",
"output": "6"
},
{
"input": "1000000000000 1",
"output": "1000000000000"
},
{
"input": "3 1",
"output": "3"
},
{
"input": "4 1",
"output": "4"
},
{
"input": "3 2",
"output": "3"
},
{
"input": "4 2",
"output": "2"
},
{
"input": "1000 700",
"output": "6"
},
{
"input": "959986566087 524054155168",
"output": "90"
},
{
"input": "4 3",
"output": "4"
},
{
"input": "7 6",
"output": "7"
},
{
"input": "1000 999",
"output": "1000"
},
{
"input": "1000 998",
"output": "500"
},
{
"input": "1000 997",
"output": "336"
},
{
"input": "42 1",
"output": "42"
},
{
"input": "1000 1",
"output": "1000"
},
{
"input": "8 5",
"output": "5"
},
{
"input": "13 8",
"output": "6"
},
{
"input": "987 610",
"output": "15"
},
{
"input": "442 42",
"output": "22"
},
{
"input": "754 466",
"output": "13"
},
{
"input": "1000000000000 999999999999",
"output": "1000000000000"
},
{
"input": "1000000000000 999999999998",
"output": "500000000000"
},
{
"input": "941 14",
"output": "74"
},
{
"input": "998 2",
"output": "499"
},
{
"input": "1000 42",
"output": "32"
},
{
"input": "1000 17",
"output": "66"
},
{
"input": "5 1",
"output": "5"
},
{
"input": "5 2",
"output": "4"
},
{
"input": "5 3",
"output": "4"
},
{
"input": "5 4",
"output": "5"
},
{
"input": "293 210",
"output": "17"
},
{
"input": "787878787878 424242424242",
"output": "8"
},
{
"input": "956722026041 591286729879",
"output": "58"
},
{
"input": "956722026041 365435296162",
"output": "58"
},
{
"input": "628625247282 464807889701",
"output": "102"
},
{
"input": "695928431619 424778620208",
"output": "167"
},
{
"input": "1000000000000 42",
"output": "23809523821"
},
{
"input": "987654345678 23",
"output": "42941493300"
},
{
"input": "10000000001 2",
"output": "5000000002"
},
{
"input": "1000000000000 2",
"output": "500000000000"
},
{
"input": "1000000000000 3",
"output": "333333333336"
},
{
"input": "100000000000 3",
"output": "33333333336"
},
{
"input": "100000000000 23",
"output": "4347826109"
},
{
"input": "999999999997 7",
"output": "142857142861"
},
{
"input": "8589934592 4294967296",
"output": "2"
}
] | 1,428,480,781
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 405
| 9,523,200
|
#coding=UTF-8
'''
Playing with Paper
2014/4/8
'''
import sys
from pip._vendor.distlib.compat import raw_input
read = open('in.txt', 'r')
sys.stdin = read #重定向标准输入
a, b = sorted(map(int,raw_input().split()))
ans = 0
while a:
ans += b // a
a, b = b % a, a
print(ans)
|
Title: Playing with Paper
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vasya was sitting on a not so interesting Maths lesson and making an origami from a rectangular *a* mm <=×<= *b* mm sheet of paper (*a*<=><=*b*). Usually the first step in making an origami is making a square piece of paper from the rectangular sheet by folding the sheet along the bisector of the right angle, and cutting the excess part.
After making a paper ship from the square piece, Vasya looked on the remaining (*a*<=-<=*b*) mm <=×<= *b* mm strip of paper. He got the idea to use this strip of paper in the same way to make an origami, and then use the remainder (if it exists) and so on. At the moment when he is left with a square piece of paper, he will make the last ship from it and stop.
Can you determine how many ships Vasya will make during the lesson?
Input Specification:
The first line of the input contains two integers *a*, *b* (1<=≤<=*b*<=<<=*a*<=≤<=1012) — the sizes of the original sheet of paper.
Output Specification:
Print a single integer — the number of ships that Vasya will make.
Demo Input:
['2 1\n', '10 7\n', '1000000000000 1\n']
Demo Output:
['2\n', '6\n', '1000000000000\n']
Note:
Pictures to the first and second sample test.
|
```python
#coding=UTF-8
'''
Playing with Paper
2014/4/8
'''
import sys
from pip._vendor.distlib.compat import raw_input
read = open('in.txt', 'r')
sys.stdin = read #重定向标准输入
a, b = sorted(map(int,raw_input().split()))
ans = 0
while a:
ans += b // a
a, b = b % a, a
print(ans)
```
| -1
|
|
270
|
A
|
Fancy Fence
|
PROGRAMMING
| 1,100
|
[
"geometry",
"implementation",
"math"
] | null | null |
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle *a*.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to *a*?
|
The first line of input contains an integer *t* (0<=<<=*t*<=<<=180) — the number of tests. Each of the following *t* lines contains a single integer *a* (0<=<<=*a*<=<<=180) — the angle the robot can make corners at measured in degrees.
|
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
|
[
"3\n30\n60\n90\n"
] |
[
"NO\nYES\nYES\n"
] |
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/df5f4b07dd5316fde165b43657b2696e2919e791.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second test case, the fence is a regular triangle, and in the last test case — a square.
| 500
|
[
{
"input": "3\n30\n60\n90",
"output": "NO\nYES\nYES"
},
{
"input": "6\n1\n2\n3\n170\n179\n25",
"output": "NO\nNO\nNO\nYES\nYES\nNO"
}
] | 1,637,255,152
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 2
| 124
| 0
|
def angle(x):
return (x-2)*180/x
x=int(input())
arr=[]
for i in range(x):
inp=int(input())
arr.append(inp)
x=3
for i in arr:
a=0
while angle(x)<=i:
if angle(x)==i:
print('YES')
a=10
break
else:
x+=1
if a==0:
print('NO')
|
Title: Fancy Fence
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.
He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle *a*.
Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to *a*?
Input Specification:
The first line of input contains an integer *t* (0<=<<=*t*<=<<=180) — the number of tests. Each of the following *t* lines contains a single integer *a* (0<=<<=*a*<=<<=180) — the angle the robot can make corners at measured in degrees.
Output Specification:
For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.
Demo Input:
['3\n30\n60\n90\n']
Demo Output:
['NO\nYES\nYES\n']
Note:
In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/df5f4b07dd5316fde165b43657b2696e2919e791.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second test case, the fence is a regular triangle, and in the last test case — a square.
|
```python
def angle(x):
return (x-2)*180/x
x=int(input())
arr=[]
for i in range(x):
inp=int(input())
arr.append(inp)
x=3
for i in arr:
a=0
while angle(x)<=i:
if angle(x)==i:
print('YES')
a=10
break
else:
x+=1
if a==0:
print('NO')
```
| 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,659,888,450
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 31
| 0
|
input = input()
if input == "ahhellllloou":
print("YES")
else:
print("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
input = input()
if input == "ahhellllloou":
print("YES")
else:
print("NO")
```
| 0
|
157
|
B
|
Trace
|
PROGRAMMING
| 1,000
|
[
"geometry",
"sortings"
] | null | null |
One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
|
The first line contains the single integer *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integers *r**i* (1<=≤<=*r**i*<=≤<=1000) — the circles' radii. It is guaranteed that all circles are different.
|
Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10<=-<=4.
|
[
"1\n1\n",
"3\n1 4 2\n"
] |
[
"3.1415926536\n",
"40.8407044967\n"
] |
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 1<sup class="upper-index">2</sup> = π.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 4<sup class="upper-index">2</sup> - π × 2<sup class="upper-index">2</sup>) + π × 1<sup class="upper-index">2</sup> = π × 12 + π = 13π
| 1,000
|
[
{
"input": "1\n1",
"output": "3.1415926536"
},
{
"input": "3\n1 4 2",
"output": "40.8407044967"
},
{
"input": "4\n4 1 3 2",
"output": "31.4159265359"
},
{
"input": "4\n100 10 2 1",
"output": "31111.1920484997"
},
{
"input": "10\n10 9 8 7 6 5 4 3 2 1",
"output": "172.7875959474"
},
{
"input": "1\n1000",
"output": "3141592.6535897931"
},
{
"input": "8\n8 1 7 2 6 3 5 4",
"output": "113.0973355292"
},
{
"input": "100\n1000 999 998 997 996 995 994 993 992 991 990 989 988 987 986 985 984 983 982 981 980 979 978 977 976 975 974 973 972 971 970 969 968 967 966 965 964 963 962 961 960 959 958 957 956 955 954 953 952 951 950 949 948 947 946 945 944 943 942 941 940 939 938 937 936 935 934 933 932 931 930 929 928 927 926 925 924 923 922 921 920 919 918 917 916 915 914 913 912 911 910 909 908 907 906 905 904 903 902 901",
"output": "298608.3817237098"
},
{
"input": "6\n109 683 214 392 678 10",
"output": "397266.9574170437"
},
{
"input": "2\n151 400",
"output": "431023.3704798660"
},
{
"input": "6\n258 877 696 425 663 934",
"output": "823521.3902487604"
},
{
"input": "9\n635 707 108 234 52 180 910 203 782",
"output": "1100144.9065826489"
},
{
"input": "8\n885 879 891 428 522 176 135 983",
"output": "895488.9947571954"
},
{
"input": "3\n269 918 721",
"output": "1241695.6467754442"
},
{
"input": "7\n920 570 681 428 866 935 795",
"output": "1469640.1849419588"
},
{
"input": "2\n517 331",
"output": "495517.1260654109"
},
{
"input": "2\n457 898",
"output": "1877274.3981158488"
},
{
"input": "8\n872 704 973 612 183 274 739 253",
"output": "1780774.0965755312"
},
{
"input": "74\n652 446 173 457 760 847 670 25 196 775 998 279 656 809 883 148 969 884 792 502 641 800 663 938 362 339 545 608 107 184 834 666 149 458 864 72 199 658 618 987 126 723 806 643 689 958 626 904 944 415 427 498 628 331 636 261 281 276 478 220 513 595 510 384 354 561 469 462 799 449 747 109 903 456",
"output": "1510006.5089479341"
},
{
"input": "76\n986 504 673 158 87 332 124 218 714 235 212 122 878 370 938 81 686 323 386 348 410 468 875 107 50 960 82 834 234 663 651 422 794 633 294 771 945 607 146 913 950 858 297 88 882 725 247 872 645 749 799 987 115 394 380 382 971 429 593 426 652 353 351 233 868 598 889 116 71 376 916 464 414 976 138 903",
"output": "1528494.7817143100"
},
{
"input": "70\n12 347 748 962 514 686 192 159 990 4 10 788 602 542 946 215 523 727 799 717 955 796 529 465 897 103 181 515 495 153 710 179 747 145 16 585 943 998 923 708 156 399 770 547 775 285 9 68 713 722 570 143 913 416 663 624 925 218 64 237 797 138 942 213 188 818 780 840 480 758",
"output": "1741821.4892636713"
},
{
"input": "26\n656 508 45 189 561 366 96 486 547 386 703 570 780 689 264 26 11 74 466 76 421 48 982 886 215 650",
"output": "1818821.9252031571"
},
{
"input": "52\n270 658 808 249 293 707 700 78 791 167 92 772 807 502 830 991 945 102 968 376 556 578 326 980 688 368 280 853 646 256 666 638 424 737 321 996 925 405 199 680 953 541 716 481 727 143 577 919 892 355 346 298",
"output": "1272941.9273080483"
},
{
"input": "77\n482 532 200 748 692 697 171 863 586 547 301 149 326 812 147 698 303 691 527 805 681 387 619 947 598 453 167 799 840 508 893 688 643 974 998 341 804 230 538 669 271 404 477 759 943 596 949 235 880 160 151 660 832 82 969 539 708 889 258 81 224 655 790 144 462 582 646 256 445 52 456 920 67 819 631 484 534",
"output": "2045673.1891262225"
},
{
"input": "27\n167 464 924 575 775 97 944 390 297 315 668 296 533 829 851 406 702 366 848 512 71 197 321 900 544 529 116",
"output": "1573959.9105970615"
},
{
"input": "38\n488 830 887 566 720 267 583 102 65 200 884 220 263 858 510 481 316 804 754 568 412 166 374 869 356 977 145 421 500 58 664 252 745 70 381 927 670 772",
"output": "1479184.3434235646"
},
{
"input": "64\n591 387 732 260 840 397 563 136 571 876 831 953 799 493 579 13 559 872 53 678 256 232 969 993 847 14 837 365 547 997 604 199 834 529 306 443 739 49 19 276 343 835 904 588 900 870 439 576 975 955 518 117 131 347 800 83 432 882 869 709 32 950 314 450",
"output": "1258248.6984672088"
},
{
"input": "37\n280 281 169 68 249 389 977 101 360 43 448 447 368 496 125 507 747 392 338 270 916 150 929 428 118 266 589 470 774 852 263 644 187 817 808 58 637",
"output": "1495219.0323274869"
},
{
"input": "97\n768 569 306 968 437 779 227 561 412 60 44 807 234 645 169 858 580 396 343 145 842 723 416 80 456 247 81 150 297 116 760 964 312 558 101 850 549 650 299 868 121 435 579 705 118 424 302 812 970 397 659 565 916 183 933 459 6 593 518 717 326 305 744 470 75 981 824 221 294 324 194 293 251 446 481 215 338 861 528 829 921 945 540 89 450 178 24 460 990 392 148 219 934 615 932 340 937",
"output": "1577239.7333274092"
},
{
"input": "94\n145 703 874 425 277 652 239 496 458 658 339 842 564 699 893 352 625 980 432 121 798 872 499 859 850 721 414 825 543 843 304 111 342 45 219 311 50 748 465 902 781 822 504 985 919 656 280 310 917 438 464 527 491 713 906 329 635 777 223 810 501 535 156 252 806 112 971 719 103 443 165 98 579 554 244 996 221 560 301 51 977 422 314 858 528 772 448 626 185 194 536 66 577 677",
"output": "1624269.3753516484"
},
{
"input": "97\n976 166 649 81 611 927 480 231 998 711 874 91 969 521 531 414 993 790 317 981 9 261 437 332 173 573 904 777 882 990 658 878 965 64 870 896 271 732 431 53 761 943 418 602 708 949 930 130 512 240 363 458 673 319 131 784 224 48 919 126 208 212 911 59 677 535 450 273 479 423 79 807 336 18 72 290 724 28 123 605 287 228 350 897 250 392 885 655 746 417 643 114 813 378 355 635 905",
"output": "1615601.7212203942"
},
{
"input": "91\n493 996 842 9 748 178 1 807 841 519 796 998 84 670 778 143 707 208 165 893 154 943 336 150 761 881 434 112 833 55 412 682 552 945 758 189 209 600 354 325 440 844 410 20 136 665 88 791 688 17 539 821 133 236 94 606 483 446 429 60 960 476 915 134 137 852 754 908 276 482 117 252 297 903 981 203 829 811 471 135 188 667 710 393 370 302 874 872 551 457 692",
"output": "1806742.5014501044"
},
{
"input": "95\n936 736 17 967 229 607 589 291 242 244 29 698 800 566 630 667 90 416 11 94 812 838 668 520 678 111 490 823 199 973 681 676 683 721 262 896 682 713 402 691 874 44 95 704 56 322 822 887 639 433 406 35 988 61 176 496 501 947 440 384 372 959 577 370 754 802 1 945 427 116 746 408 308 391 397 730 493 183 203 871 831 862 461 565 310 344 504 378 785 137 279 123 475 138 415",
"output": "1611115.5269110680"
},
{
"input": "90\n643 197 42 218 582 27 66 704 195 445 641 675 285 639 503 686 242 327 57 955 848 287 819 992 756 749 363 48 648 736 580 117 752 921 923 372 114 313 202 337 64 497 399 25 883 331 24 871 917 8 517 486 323 529 325 92 891 406 864 402 263 773 931 253 625 31 17 271 140 131 232 586 893 525 846 54 294 562 600 801 214 55 768 683 389 738 314 284 328 804",
"output": "1569819.2914796301"
},
{
"input": "98\n29 211 984 75 333 96 840 21 352 168 332 433 130 944 215 210 620 442 363 877 91 491 513 955 53 82 351 19 998 706 702 738 770 453 344 117 893 590 723 662 757 16 87 546 312 669 568 931 224 374 927 225 751 962 651 587 361 250 256 240 282 600 95 64 384 589 813 783 39 918 412 648 506 283 886 926 443 173 946 241 310 33 622 565 261 360 547 339 943 367 354 25 479 743 385 485 896 741",
"output": "2042921.1539616778"
},
{
"input": "93\n957 395 826 67 185 4 455 880 683 654 463 84 258 878 553 592 124 585 9 133 20 609 43 452 725 125 801 537 700 685 771 155 566 376 19 690 383 352 174 208 177 416 304 1000 533 481 87 509 358 233 681 22 507 659 36 859 952 259 138 271 594 779 576 782 119 69 608 758 283 616 640 523 710 751 34 106 774 92 874 568 864 660 998 992 474 679 180 409 15 297 990 689 501",
"output": "1310703.8710041976"
},
{
"input": "97\n70 611 20 30 904 636 583 262 255 501 604 660 212 128 199 138 545 576 506 528 12 410 77 888 783 972 431 188 338 485 148 793 907 678 281 922 976 680 252 724 253 920 177 361 721 798 960 572 99 622 712 466 608 49 612 345 266 751 63 594 40 695 532 789 520 930 825 929 48 59 405 135 109 735 508 186 495 772 375 587 201 324 447 610 230 947 855 318 856 956 313 810 931 175 668 183 688",
"output": "1686117.9099228707"
},
{
"input": "96\n292 235 391 180 840 172 218 997 166 287 329 20 886 325 400 471 182 356 448 337 417 319 58 106 366 764 393 614 90 831 924 314 667 532 64 874 3 434 350 352 733 795 78 640 967 63 47 879 635 272 145 569 468 792 153 761 770 878 281 467 209 208 298 37 700 18 334 93 5 750 412 779 523 517 360 649 447 328 311 653 57 578 767 460 647 663 50 670 151 13 511 580 625 907 227 89",
"output": "1419726.5608617242"
},
{
"input": "100\n469 399 735 925 62 153 707 723 819 529 200 624 57 708 245 384 889 11 639 638 260 419 8 142 403 298 204 169 887 388 241 983 885 267 643 943 417 237 452 562 6 839 149 742 832 896 100 831 712 754 679 743 135 222 445 680 210 955 220 63 960 487 514 824 481 584 441 997 795 290 10 45 510 678 844 503 407 945 850 84 858 934 500 320 936 663 736 592 161 670 606 465 864 969 293 863 868 393 899 744",
"output": "1556458.0979239127"
},
{
"input": "100\n321 200 758 415 190 710 920 992 873 898 814 259 359 66 971 210 838 545 663 652 684 277 36 756 963 459 335 484 462 982 532 423 131 703 307 229 391 938 253 847 542 975 635 928 220 980 222 567 557 181 366 824 900 180 107 979 112 564 525 413 300 422 876 615 737 343 902 8 654 628 469 913 967 785 893 314 909 215 912 262 20 709 363 915 997 954 986 454 596 124 74 159 660 550 787 418 895 786 293 50",
"output": "1775109.8050211088"
},
{
"input": "100\n859 113 290 762 701 63 188 431 810 485 671 673 99 658 194 227 511 435 941 212 551 124 89 222 42 321 657 815 898 171 216 482 707 567 724 491 414 942 820 351 48 653 685 312 586 24 20 627 602 498 533 173 463 262 621 466 119 299 580 964 510 987 40 698 521 998 847 651 746 215 808 563 785 837 631 772 404 923 682 244 232 214 390 350 968 771 517 900 70 543 934 554 681 368 642 575 891 728 478 317",
"output": "1447969.4788174964"
},
{
"input": "100\n941 283 349 457 52 837 299 284 796 305 893 624 101 972 738 204 121 70 17 704 836 791 95 111 162 952 472 724 733 580 878 177 705 804 11 211 463 417 288 409 410 485 896 755 921 267 164 656 505 765 539 439 535 19 991 689 220 474 114 944 884 144 926 849 486 566 117 35 749 499 797 303 362 905 690 890 976 66 590 183 234 683 39 297 769 787 376 541 571 759 495 200 261 352 73 493 831 442 273 339",
"output": "1597889.4218394549"
},
{
"input": "100\n110 868 147 888 291 282 916 542 917 337 235 595 498 621 814 249 261 713 445 666 142 275 319 49 900 543 333 606 487 670 620 769 852 258 230 867 603 491 714 839 879 37 21 74 590 190 397 506 499 967 152 862 200 107 145 23 614 167 857 475 79 598 270 906 626 116 89 59 651 846 723 201 50 699 522 408 634 132 226 414 824 764 513 586 526 238 556 162 667 173 684 415 527 743 10 442 552 274 350 822",
"output": "1567230.6191330721"
},
{
"input": "100\n901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000",
"output": "298608.3817237098"
}
] | 1,650,886,950
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 44
| 124
| 512,000
|
import math
n = int(input())
raios = [int(x) for x in input().split()]
raios.sort()
resultado = 0.0
for i in range(len(raios)-1, -1, -1):
if i % 2 == 0:
resultado += math.pi*pow(raios[i], 2)
else:
resultado -= math.pi * pow(raios[i], 2)
if resultado >= 0:
print(format(resultado, ".20f"))
else:
print(format(-resultado, ".20f"))
|
Title: Trace
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
Input Specification:
The first line contains the single integer *n* (1<=≤<=*n*<=≤<=100). The second line contains *n* space-separated integers *r**i* (1<=≤<=*r**i*<=≤<=1000) — the circles' radii. It is guaranteed that all circles are different.
Output Specification:
Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10<=-<=4.
Demo Input:
['1\n1\n', '3\n1 4 2\n']
Demo Output:
['3.1415926536\n', '40.8407044967\n']
Note:
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 1<sup class="upper-index">2</sup> = π.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 4<sup class="upper-index">2</sup> - π × 2<sup class="upper-index">2</sup>) + π × 1<sup class="upper-index">2</sup> = π × 12 + π = 13π
|
```python
import math
n = int(input())
raios = [int(x) for x in input().split()]
raios.sort()
resultado = 0.0
for i in range(len(raios)-1, -1, -1):
if i % 2 == 0:
resultado += math.pi*pow(raios[i], 2)
else:
resultado -= math.pi * pow(raios[i], 2)
if resultado >= 0:
print(format(resultado, ".20f"))
else:
print(format(-resultado, ".20f"))
```
| 3
|
|
276
|
C
|
Little Girl and Maximum Sum
|
PROGRAMMING
| 1,500
|
[
"data structures",
"greedy",
"implementation",
"sortings"
] | null | null |
The little girl loves the problems on array queries very much.
One day she came across a rather well-known problem: you've got an array of $n$ elements (the elements of the array are indexed starting from 1); also, there are $q$ queries, each one is defined by a pair of integers $l_i$, $r_i$ $(1 \le l_i \le r_i \le n)$. You need to find for each query the sum of elements of the array with indexes from $l_i$ to $r_i$, inclusive.
The little girl found the problem rather boring. She decided to reorder the array elements before replying to the queries in a way that makes the sum of query replies maximum possible. Your task is to find the value of this maximum sum.
|
The first line contains two space-separated integers $n$ ($1 \le n \le 2\cdot10^5$) and $q$ ($1 \le q \le 2\cdot10^5$) — the number of elements in the array and the number of queries, correspondingly.
The next line contains $n$ space-separated integers $a_i$ ($1 \le a_i \le 2\cdot10^5$) — the array elements.
Each of the following $q$ lines contains two space-separated integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le n$) — the $i$-th query.
|
In a single line print, a single integer — the maximum sum of query replies after the array elements are reordered.
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.
|
[
"3 3\n5 3 2\n1 2\n2 3\n1 3\n",
"5 3\n5 2 4 1 3\n1 5\n2 3\n2 3\n"
] |
[
"25\n",
"33\n"
] |
none
| 1,500
|
[
{
"input": "3 3\n5 3 2\n1 2\n2 3\n1 3",
"output": "25"
},
{
"input": "5 3\n5 2 4 1 3\n1 5\n2 3\n2 3",
"output": "33"
},
{
"input": "34 21\n23 38 16 49 44 50 48 34 33 19 18 31 11 15 20 47 44 30 39 33 45 46 1 13 27 16 31 36 17 23 38 5 30 16\n8 16\n14 27\n8 26\n1 8\n5 6\n23 28\n4 33\n13 30\n12 30\n11 30\n9 21\n1 14\n15 22\n4 11\n5 24\n8 20\n17 33\n6 9\n3 14\n25 34\n10 17",
"output": "9382"
},
{
"input": "16 13\n40 32 15 16 35 36 45 23 30 42 25 8 29 21 39 23\n2 9\n3 11\n8 9\n4 14\n1 6\n5 10\n5 14\n5 11\n13 13\n2 8\n9 16\n6 10\n7 8",
"output": "2838"
},
{
"input": "31 48\n45 19 16 42 38 18 50 7 28 40 39 25 45 14 36 18 27 30 16 4 22 6 1 23 16 47 14 35 27 47 2\n6 16\n11 28\n4 30\n25 26\n11 30\n5 9\n4 17\n15 17\n10 25\n15 26\n1 3\n9 26\n8 29\n16 30\n5 24\n27 30\n9 10\n22 29\n2 6\n15 24\n6 21\n19 21\n4 28\n1 7\n18 21\n10 22\n6 15\n14 28\n4 29\n12 13\n19 29\n5 6\n13 31\n21 27\n9 25\n6 18\n6 8\n28 30\n2 4\n15 21\n1 1\n8 30\n3 31\n11 27\n28 29\n6 22\n20 22\n9 25",
"output": "17471"
},
{
"input": "22 7\n44 41 40 41 37 42 46 16 50 47 30 7 32 6 20 14 47 25 11 1 35 12\n1 10\n10 20\n4 5\n1 8\n2 12\n8 8\n2 16",
"output": "2202"
},
{
"input": "3 2\n1 2 3\n2 3\n1 2",
"output": "9"
}
] | 1,670,323,278
| 2,147,483,647
|
PyPy 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 6
| 1,000
| 19,251,200
|
n,m=[int(x) for x in input().split()]
arr=[int(x) for x in input().split()]
ans=[0 for _ in range(n)]
for _ in range(m):
x,y=[int(x) for x in input().split()]
ans[x-1]+=1
if y!=n:
ans[y]-=1
for i in range(1,n):
ans[i]+=ans[i-1]
ans.sort()
arr.sort()
# print(arr)
# print(ans)
solution=0
for i in range(n):
solution+=(ans[i]*arr[i])
print(solution)
|
Title: Little Girl and Maximum Sum
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The little girl loves the problems on array queries very much.
One day she came across a rather well-known problem: you've got an array of $n$ elements (the elements of the array are indexed starting from 1); also, there are $q$ queries, each one is defined by a pair of integers $l_i$, $r_i$ $(1 \le l_i \le r_i \le n)$. You need to find for each query the sum of elements of the array with indexes from $l_i$ to $r_i$, inclusive.
The little girl found the problem rather boring. She decided to reorder the array elements before replying to the queries in a way that makes the sum of query replies maximum possible. Your task is to find the value of this maximum sum.
Input Specification:
The first line contains two space-separated integers $n$ ($1 \le n \le 2\cdot10^5$) and $q$ ($1 \le q \le 2\cdot10^5$) — the number of elements in the array and the number of queries, correspondingly.
The next line contains $n$ space-separated integers $a_i$ ($1 \le a_i \le 2\cdot10^5$) — the array elements.
Each of the following $q$ lines contains two space-separated integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le n$) — the $i$-th query.
Output Specification:
In a single line print, a single integer — the maximum sum of query replies after the array elements are reordered.
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:
['3 3\n5 3 2\n1 2\n2 3\n1 3\n', '5 3\n5 2 4 1 3\n1 5\n2 3\n2 3\n']
Demo Output:
['25\n', '33\n']
Note:
none
|
```python
n,m=[int(x) for x in input().split()]
arr=[int(x) for x in input().split()]
ans=[0 for _ in range(n)]
for _ in range(m):
x,y=[int(x) for x in input().split()]
ans[x-1]+=1
if y!=n:
ans[y]-=1
for i in range(1,n):
ans[i]+=ans[i-1]
ans.sort()
arr.sort()
# print(arr)
# print(ans)
solution=0
for i in range(n):
solution+=(ans[i]*arr[i])
print(solution)
```
| 0
|
|
677
|
A
|
Vanya and Fence
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | 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,693,732,289
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 15
| 0
|
n, h = map(int, input().split())
count = 0
for i in range(n):
person = int(input())
if person <= h:
count += 1
else:
count += 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 = map(int, input().split())
count = 0
for i in range(n):
person = int(input())
if person <= h:
count += 1
else:
count += 2
print(count)
```
| -1
|
|
602
|
A
|
Two Bases
|
PROGRAMMING
| 1,100
|
[
"brute force",
"implementation"
] | null | null |
After seeing the "ALL YOUR BASE ARE BELONG TO US" meme for the first time, numbers *X* and *Y* realised that they have different bases, which complicated their relations.
You're given a number *X* represented in base *b**x* and a number *Y* represented in base *b**y*. Compare those two numbers.
|
The first line of the input contains two space-separated integers *n* and *b**x* (1<=≤<=*n*<=≤<=10, 2<=≤<=*b**x*<=≤<=40), where *n* is the number of digits in the *b**x*-based representation of *X*.
The second line contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=<<=*b**x*) — the digits of *X*. They are given in the order from the most significant digit to the least significant one.
The following two lines describe *Y* in the same way: the third line contains two space-separated integers *m* and *b**y* (1<=≤<=*m*<=≤<=10, 2<=≤<=*b**y*<=≤<=40, *b**x*<=≠<=*b**y*), where *m* is the number of digits in the *b**y*-based representation of *Y*, and the fourth line contains *m* space-separated integers *y*1,<=*y*2,<=...,<=*y**m* (0<=≤<=*y**i*<=<<=*b**y*) — the digits of *Y*.
There will be no leading zeroes. Both *X* and *Y* will be positive. All digits of both numbers are given in the standard decimal numeral system.
|
Output a single character (quotes for clarity):
- '<' if *X*<=<<=*Y* - '>' if *X*<=><=*Y* - '=' if *X*<==<=*Y*
|
[
"6 2\n1 0 1 1 1 1\n2 10\n4 7\n",
"3 3\n1 0 2\n2 5\n2 4\n",
"7 16\n15 15 4 0 0 7 10\n7 9\n4 8 0 3 1 5 0\n"
] |
[
"=\n",
"<\n",
">\n"
] |
In the first sample, *X* = 101111<sub class="lower-index">2</sub> = 47<sub class="lower-index">10</sub> = *Y*.
In the second sample, *X* = 102<sub class="lower-index">3</sub> = 21<sub class="lower-index">5</sub> and *Y* = 24<sub class="lower-index">5</sub> = 112<sub class="lower-index">3</sub>, thus *X* < *Y*.
In the third sample, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/603a342b0ae3e56fed542d1c50c0a5ff6ce2cbaa.png" style="max-width: 100.0%;max-height: 100.0%;"/> and *Y* = 4803150<sub class="lower-index">9</sub>. We may notice that *X* starts with much larger digits and *b*<sub class="lower-index">*x*</sub> is much larger than *b*<sub class="lower-index">*y*</sub>, so *X* is clearly larger than *Y*.
| 500
|
[
{
"input": "6 2\n1 0 1 1 1 1\n2 10\n4 7",
"output": "="
},
{
"input": "3 3\n1 0 2\n2 5\n2 4",
"output": "<"
},
{
"input": "7 16\n15 15 4 0 0 7 10\n7 9\n4 8 0 3 1 5 0",
"output": ">"
},
{
"input": "2 2\n1 0\n2 3\n1 0",
"output": "<"
},
{
"input": "2 2\n1 0\n1 3\n1",
"output": ">"
},
{
"input": "10 2\n1 0 1 0 1 0 1 0 1 0\n10 3\n2 2 2 2 2 2 2 2 2 2",
"output": "<"
},
{
"input": "10 16\n15 15 4 0 0 0 0 7 10 9\n7 9\n4 8 0 3 1 5 0",
"output": ">"
},
{
"input": "5 5\n4 4 4 4 4\n4 6\n5 5 5 5",
"output": ">"
},
{
"input": "2 8\n1 0\n4 2\n1 0 0 0",
"output": "="
},
{
"input": "5 2\n1 0 0 0 1\n6 8\n1 4 7 2 0 0",
"output": "<"
},
{
"input": "6 7\n1 1 2 1 2 1\n6 6\n2 3 2 2 2 2",
"output": "="
},
{
"input": "9 35\n34 3 20 29 27 30 2 8 5\n7 33\n17 3 22 31 1 11 6",
"output": ">"
},
{
"input": "1 8\n5\n9 27\n23 23 23 23 23 23 23 23 23",
"output": "<"
},
{
"input": "4 7\n3 0 6 6\n3 11\n7 10 10",
"output": ">"
},
{
"input": "1 40\n1\n2 5\n1 0",
"output": "<"
},
{
"input": "1 36\n35\n4 5\n2 4 4 1",
"output": "<"
},
{
"input": "1 30\n1\n1 31\n1",
"output": "="
},
{
"input": "1 3\n1\n1 2\n1",
"output": "="
},
{
"input": "1 2\n1\n1 40\n1",
"output": "="
},
{
"input": "6 29\n1 1 1 1 1 1\n10 21\n1 1 1 1 1 1 1 1 1 1",
"output": "<"
},
{
"input": "3 5\n1 0 0\n3 3\n2 2 2",
"output": "<"
},
{
"input": "2 8\n1 0\n2 3\n2 2",
"output": "="
},
{
"input": "2 4\n3 3\n2 15\n1 0",
"output": "="
},
{
"input": "2 35\n1 0\n2 6\n5 5",
"output": "="
},
{
"input": "2 6\n5 5\n2 34\n1 0",
"output": ">"
},
{
"input": "2 7\n1 0\n2 3\n2 2",
"output": "<"
},
{
"input": "2 2\n1 0\n1 3\n2",
"output": "="
},
{
"input": "2 9\n5 5\n4 3\n1 0 0 0",
"output": ">"
},
{
"input": "1 24\n6\n3 9\n1 1 1",
"output": "<"
},
{
"input": "5 37\n9 9 9 9 9\n6 27\n13 0 0 0 0 0",
"output": "<"
},
{
"input": "10 2\n1 1 1 1 1 1 1 1 1 1\n10 34\n14 14 14 14 14 14 14 14 14 14",
"output": "<"
},
{
"input": "7 26\n8 0 0 0 0 0 0\n9 9\n3 3 3 3 3 3 3 3 3",
"output": ">"
},
{
"input": "2 40\n2 0\n5 13\n4 0 0 0 0",
"output": "<"
},
{
"input": "1 22\n15\n10 14\n3 3 3 3 3 3 3 3 3 3",
"output": "<"
},
{
"input": "10 22\n3 3 3 3 3 3 3 3 3 3\n3 40\n19 19 19",
"output": ">"
},
{
"input": "2 29\n11 11\n6 26\n11 11 11 11 11 11",
"output": "<"
},
{
"input": "5 3\n1 0 0 0 0\n4 27\n1 0 0 0",
"output": "<"
},
{
"input": "10 3\n1 0 0 0 0 0 0 0 0 0\n8 13\n1 0 0 0 0 0 0 0",
"output": "<"
},
{
"input": "4 20\n1 1 1 1\n5 22\n1 1 1 1 1",
"output": "<"
},
{
"input": "10 39\n34 2 24 34 11 6 33 12 22 21\n10 36\n25 35 17 24 30 0 1 32 14 35",
"output": ">"
},
{
"input": "10 39\n35 12 31 35 28 27 25 8 22 25\n10 40\n23 21 18 12 15 29 38 32 4 8",
"output": ">"
},
{
"input": "10 38\n16 19 37 32 16 7 14 33 16 11\n10 39\n10 27 35 15 31 15 17 16 38 35",
"output": ">"
},
{
"input": "10 39\n20 12 10 32 24 14 37 35 10 38\n9 40\n1 13 0 10 22 20 1 5 35",
"output": ">"
},
{
"input": "10 40\n18 1 2 25 28 2 10 2 17 37\n10 39\n37 8 12 8 21 11 23 11 25 21",
"output": "<"
},
{
"input": "9 39\n10 20 16 36 30 29 28 9 8\n9 38\n12 36 10 22 6 3 19 12 34",
"output": "="
},
{
"input": "7 39\n28 16 13 25 19 23 4\n7 38\n33 8 2 19 3 21 14",
"output": "="
},
{
"input": "10 16\n15 15 4 0 0 0 0 7 10 9\n10 9\n4 8 0 3 1 5 4 8 1 0",
"output": ">"
},
{
"input": "7 22\n1 13 9 16 7 13 3\n4 4\n3 0 2 1",
"output": ">"
},
{
"input": "10 29\n10 19 8 27 1 24 13 15 13 26\n2 28\n20 14",
"output": ">"
},
{
"input": "6 16\n2 13 7 13 15 6\n10 22\n17 17 21 9 16 11 4 4 13 17",
"output": "<"
},
{
"input": "8 26\n6 6 17 25 24 8 8 25\n4 27\n24 7 5 24",
"output": ">"
},
{
"input": "10 23\n5 21 4 15 12 7 10 7 16 21\n4 17\n3 11 1 14",
"output": ">"
},
{
"input": "10 21\n4 7 7 2 13 7 19 19 18 19\n3 31\n6 11 28",
"output": ">"
},
{
"input": "1 30\n9\n7 37\n20 11 18 14 0 36 27",
"output": "<"
},
{
"input": "5 35\n22 18 28 29 11\n2 3\n2 0",
"output": ">"
},
{
"input": "7 29\n14 26 14 22 11 11 8\n6 28\n2 12 10 17 0 14",
"output": ">"
},
{
"input": "2 37\n25 2\n3 26\n13 13 12",
"output": "<"
},
{
"input": "8 8\n4 0 4 3 4 1 5 6\n8 24\n19 8 15 6 10 7 2 18",
"output": "<"
},
{
"input": "4 22\n18 16 1 2\n10 26\n23 0 12 24 16 2 24 25 1 11",
"output": "<"
},
{
"input": "7 31\n14 6 16 6 26 18 17\n7 24\n22 10 4 5 14 6 9",
"output": ">"
},
{
"input": "10 29\n15 22 0 5 11 12 17 22 4 27\n4 22\n9 2 8 14",
"output": ">"
},
{
"input": "2 10\n6 0\n10 26\n16 14 8 18 24 4 9 5 22 25",
"output": "<"
},
{
"input": "7 2\n1 0 0 0 1 0 1\n9 6\n1 1 5 1 2 5 3 5 3",
"output": "<"
},
{
"input": "3 9\n2 5 4\n1 19\n15",
"output": ">"
},
{
"input": "6 16\n4 9 13 4 2 8\n4 10\n3 5 2 4",
"output": ">"
},
{
"input": "2 12\n1 4\n8 16\n4 4 10 6 15 10 8 15",
"output": "<"
},
{
"input": "3 19\n9 18 16\n4 10\n4 3 5 4",
"output": "<"
},
{
"input": "7 3\n1 1 2 1 2 0 2\n2 2\n1 0",
"output": ">"
},
{
"input": "3 2\n1 1 1\n1 3\n1",
"output": ">"
},
{
"input": "4 4\n1 3 1 3\n9 3\n1 1 0 1 2 2 2 2 1",
"output": "<"
},
{
"input": "9 3\n1 0 0 1 1 0 0 1 2\n6 4\n1 2 0 1 3 2",
"output": ">"
},
{
"input": "3 5\n1 1 3\n10 4\n3 3 2 3 0 0 0 3 1 1",
"output": "<"
},
{
"input": "6 4\n3 3 2 2 0 2\n6 5\n1 1 1 1 0 3",
"output": ">"
},
{
"input": "6 5\n4 4 4 3 1 3\n7 6\n4 2 2 2 5 0 4",
"output": "<"
},
{
"input": "2 5\n3 3\n6 6\n4 2 0 1 1 0",
"output": "<"
},
{
"input": "10 6\n3 5 4 2 4 2 3 5 4 2\n10 7\n3 2 1 1 3 1 0 3 4 5",
"output": "<"
},
{
"input": "9 7\n2 0 3 2 6 6 1 4 3\n9 6\n4 4 1 1 4 5 5 0 2",
"output": ">"
},
{
"input": "1 7\n2\n4 8\n3 2 3 2",
"output": "<"
},
{
"input": "2 8\n4 1\n1 7\n1",
"output": ">"
},
{
"input": "1 10\n7\n3 9\n2 1 7",
"output": "<"
},
{
"input": "9 9\n2 2 3 6 3 6 3 8 4\n6 10\n4 7 7 0 3 8",
"output": ">"
},
{
"input": "3 11\n6 5 2\n8 10\n5 0 1 8 3 5 1 4",
"output": "<"
},
{
"input": "6 11\n10 6 1 0 2 2\n9 10\n4 3 4 1 1 6 3 4 1",
"output": "<"
},
{
"input": "2 19\n4 8\n8 18\n7 8 6 8 4 11 9 1",
"output": "<"
},
{
"input": "2 24\n20 9\n10 23\n21 10 15 11 6 8 20 16 14 11",
"output": "<"
},
{
"input": "8 36\n23 5 27 1 10 7 26 27\n10 35\n28 33 9 22 10 28 26 4 27 29",
"output": "<"
},
{
"input": "6 37\n22 15 14 10 1 8\n6 36\n18 5 28 10 1 17",
"output": ">"
},
{
"input": "5 38\n1 31 2 21 21\n9 37\n8 36 32 30 13 9 24 2 35",
"output": "<"
},
{
"input": "3 39\n27 4 3\n8 38\n32 15 11 34 35 27 30 15",
"output": "<"
},
{
"input": "2 40\n22 38\n5 39\n8 9 32 4 1",
"output": "<"
},
{
"input": "9 37\n1 35 7 33 20 21 26 24 5\n10 40\n39 4 11 9 33 12 26 32 11 8",
"output": "<"
},
{
"input": "4 39\n13 25 23 35\n6 38\n19 36 20 4 12 33",
"output": "<"
},
{
"input": "5 37\n29 29 5 7 27\n3 39\n13 1 10",
"output": ">"
},
{
"input": "7 28\n1 10 7 0 13 14 11\n6 38\n8 11 27 5 14 35",
"output": "="
},
{
"input": "2 34\n1 32\n2 33\n2 0",
"output": "="
},
{
"input": "7 5\n4 0 4 1 3 0 4\n4 35\n1 18 7 34",
"output": "="
},
{
"input": "9 34\n5 8 4 4 26 1 30 5 24\n10 27\n1 6 3 10 8 13 22 3 12 8",
"output": "="
},
{
"input": "10 36\n1 13 13 23 31 35 5 32 18 21\n9 38\n32 1 20 14 12 37 13 15 23",
"output": "="
},
{
"input": "10 40\n1 1 14 5 6 3 3 11 3 25\n10 39\n1 11 24 33 25 34 38 29 27 33",
"output": "="
},
{
"input": "9 37\n2 6 1 9 19 6 11 28 35\n9 40\n1 6 14 37 1 8 31 4 9",
"output": "="
},
{
"input": "4 5\n1 4 2 0\n4 4\n3 2 2 3",
"output": "="
},
{
"input": "6 4\n1 1 1 2 2 2\n7 3\n1 2 2 0 1 0 0",
"output": "="
},
{
"input": "2 5\n3 3\n5 2\n1 0 0 1 0",
"output": "="
},
{
"input": "1 9\n2\n1 10\n2",
"output": "="
},
{
"input": "6 19\n4 9 14 1 3 1\n8 10\n1 1 1 7 3 7 3 0",
"output": "="
},
{
"input": "7 15\n8 5 8 10 13 6 13\n8 13\n1 6 9 10 12 3 12 8",
"output": "="
},
{
"input": "8 18\n1 1 4 15 7 4 9 3\n8 17\n1 10 2 10 3 11 14 10",
"output": "="
},
{
"input": "8 21\n5 19 0 14 13 13 10 5\n10 13\n1 0 0 6 11 10 8 2 8 1",
"output": "="
},
{
"input": "8 28\n3 1 10 19 10 14 21 15\n8 21\n14 0 18 13 2 1 18 6",
"output": ">"
},
{
"input": "7 34\n21 22 28 16 30 4 27\n7 26\n5 13 21 10 8 12 10",
"output": ">"
},
{
"input": "6 26\n7 6 4 18 6 1\n6 25\n5 3 11 1 8 15",
"output": ">"
},
{
"input": "10 31\n6 27 17 22 14 16 25 9 13 26\n10 39\n6 1 3 26 12 32 28 19 9 19",
"output": "<"
},
{
"input": "3 5\n2 2 3\n3 6\n4 3 5",
"output": "<"
},
{
"input": "2 24\n4 18\n2 40\n29 24",
"output": "<"
},
{
"input": "5 38\n2 24 34 14 17\n8 34\n4 24 31 2 14 15 8 15",
"output": "<"
},
{
"input": "9 40\n39 39 39 39 39 39 39 39 39\n6 35\n34 34 34 34 34 34",
"output": ">"
},
{
"input": "10 40\n39 39 39 39 39 39 39 39 39 39\n10 8\n7 7 7 7 7 7 7 7 7 7",
"output": ">"
},
{
"input": "10 40\n39 39 39 39 39 39 39 39 39 39\n10 39\n38 38 38 38 38 38 38 38 38 38",
"output": ">"
}
] | 1,448,383,222
| 322
|
Python 3
|
OK
|
TESTS
| 118
| 77
| 0
|
n, bx = map(int, input().split())
x = list(map(int, input().split()))
m, by = map(int, input().split())
y = list(map(int, input().split()))
tmp = 1
ans = 0
for i in range(1, n + 1):
ans += x[-i] * tmp
tmp *= bx
ans1 = 0
tmp = 1
for i in range(1, m + 1):
ans1 += y[-i] * tmp
tmp *= by
if ans < ans1:
print("<")
elif ans > ans1:
print(">")
else:
print("=")
|
Title: Two Bases
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
After seeing the "ALL YOUR BASE ARE BELONG TO US" meme for the first time, numbers *X* and *Y* realised that they have different bases, which complicated their relations.
You're given a number *X* represented in base *b**x* and a number *Y* represented in base *b**y*. Compare those two numbers.
Input Specification:
The first line of the input contains two space-separated integers *n* and *b**x* (1<=≤<=*n*<=≤<=10, 2<=≤<=*b**x*<=≤<=40), where *n* is the number of digits in the *b**x*-based representation of *X*.
The second line contains *n* space-separated integers *x*1,<=*x*2,<=...,<=*x**n* (0<=≤<=*x**i*<=<<=*b**x*) — the digits of *X*. They are given in the order from the most significant digit to the least significant one.
The following two lines describe *Y* in the same way: the third line contains two space-separated integers *m* and *b**y* (1<=≤<=*m*<=≤<=10, 2<=≤<=*b**y*<=≤<=40, *b**x*<=≠<=*b**y*), where *m* is the number of digits in the *b**y*-based representation of *Y*, and the fourth line contains *m* space-separated integers *y*1,<=*y*2,<=...,<=*y**m* (0<=≤<=*y**i*<=<<=*b**y*) — the digits of *Y*.
There will be no leading zeroes. Both *X* and *Y* will be positive. All digits of both numbers are given in the standard decimal numeral system.
Output Specification:
Output a single character (quotes for clarity):
- '<' if *X*<=<<=*Y* - '>' if *X*<=><=*Y* - '=' if *X*<==<=*Y*
Demo Input:
['6 2\n1 0 1 1 1 1\n2 10\n4 7\n', '3 3\n1 0 2\n2 5\n2 4\n', '7 16\n15 15 4 0 0 7 10\n7 9\n4 8 0 3 1 5 0\n']
Demo Output:
['=\n', '<\n', '>\n']
Note:
In the first sample, *X* = 101111<sub class="lower-index">2</sub> = 47<sub class="lower-index">10</sub> = *Y*.
In the second sample, *X* = 102<sub class="lower-index">3</sub> = 21<sub class="lower-index">5</sub> and *Y* = 24<sub class="lower-index">5</sub> = 112<sub class="lower-index">3</sub>, thus *X* < *Y*.
In the third sample, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/603a342b0ae3e56fed542d1c50c0a5ff6ce2cbaa.png" style="max-width: 100.0%;max-height: 100.0%;"/> and *Y* = 4803150<sub class="lower-index">9</sub>. We may notice that *X* starts with much larger digits and *b*<sub class="lower-index">*x*</sub> is much larger than *b*<sub class="lower-index">*y*</sub>, so *X* is clearly larger than *Y*.
|
```python
n, bx = map(int, input().split())
x = list(map(int, input().split()))
m, by = map(int, input().split())
y = list(map(int, input().split()))
tmp = 1
ans = 0
for i in range(1, n + 1):
ans += x[-i] * tmp
tmp *= bx
ans1 = 0
tmp = 1
for i in range(1, m + 1):
ans1 += y[-i] * tmp
tmp *= by
if ans < ans1:
print("<")
elif ans > ans1:
print(">")
else:
print("=")
```
| 3
|
|
53
|
A
|
Autocomplete
|
PROGRAMMING
| 1,100
|
[
"implementation"
] |
A. Autocomplete
|
2
|
256
|
Autocomplete is a program function that enables inputting the text (in editors, command line shells, browsers etc.) completing the text by its inputted part. Vasya is busy working on a new browser called 'BERowser'. He happens to be working on the autocomplete function in the address line at this very moment. A list consisting of *n* last visited by the user pages and the inputted part *s* are known. Your task is to complete *s* to make it an address of one of the pages from the list. You have to find the lexicographically smallest address having a prefix *s*.
|
The first line contains the *s* line which is the inputted part. The second line contains an integer *n* (1<=≤<=*n*<=≤<=100) which is the number of visited pages. Then follow *n* lines which are the visited pages, one on each line. All the lines have lengths of from 1 to 100 symbols inclusively and consist of lowercase Latin letters only.
|
If *s* is not the beginning of any of *n* addresses of the visited pages, print *s*. Otherwise, print the lexicographically minimal address of one of the visited pages starting from *s*.
The lexicographical order is the order of words in a dictionary. The lexicographical comparison of lines is realized by the '<' operator in the modern programming languages.
|
[
"next\n2\nnextpermutation\nnextelement\n",
"find\n4\nfind\nfindfirstof\nfindit\nfand\n",
"find\n4\nfondfind\nfondfirstof\nfondit\nfand\n"
] |
[
"nextelement\n",
"find\n",
"find\n"
] |
none
| 500
|
[
{
"input": "next\n2\nnextpermutation\nnextelement",
"output": "nextelement"
},
{
"input": "find\n4\nfind\nfindfirstof\nfindit\nfand",
"output": "find"
},
{
"input": "find\n4\nfondfind\nfondfirstof\nfondit\nfand",
"output": "find"
},
{
"input": "kudljmxcse\n4\nkudljmxcse\nszjebdoad\nchz\na",
"output": "kudljmxcse"
},
{
"input": "ntqwpa\n5\nvvepyowvn\nntqwpakay\nhh\nygiafasda\nntqwpadm",
"output": "ntqwpadm"
},
{
"input": "aflb\n6\nsaej\nujxsiijg\npp\nhgoprw\ncp\nnt",
"output": "aflb"
},
{
"input": "dzwzyj\n7\nwvixktp\ndzwzyjuhn\ndzwzyjqrbd\ndzwzyji\ndzwzyjyfys\ndzwzyjrcb\nxptb",
"output": "dzwzyji"
},
{
"input": "wmblbphwdjjskzmlsyiznluiudelhlvcpyrooajvbwudnnstdhesauyxjugdwhrrwg\n1\nwjhsbxrrhadgtnybsugdtprncwerwezxuaxnqfpnosbispmnymnaqssdkjeynrnn",
"output": "wmblbphwdjjskzmlsyiznluiudelhlvcpyrooajvbwudnnstdhesauyxjugdwhrrwg"
},
{
"input": "hzkqvwliymwjbejfpnydrbwskhyrtrlsdinfrgwmnbdpwytcnjeoowxrfgfuaffzayjylvzu\n1\nhzkqvwliymwjbejfpnydrbwskhyrtrlsdinfrgwmnbdpwytcnjeoowxrfgfuaffzayjylvzubwjlvhhsfurqb",
"output": "hzkqvwliymwjbejfpnydrbwskhyrtrlsdinfrgwmnbdpwytcnjeoowxrfgfuaffzayjylvzubwjlvhhsfurqb"
},
{
"input": "msjnqudojxtzvpc\n2\nvlxclsvqbucmbrkwwtoxek\nmsjnqudojxtzvpcldwjyystsxrtexfhllzhnkidmhmyxpld",
"output": "msjnqudojxtzvpcldwjyystsxrtexfhllzhnkidmhmyxpld"
}
] | 1,630,691,757
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 25
| 154
| 6,963,200
|
x=str(input());ans=".";ln = len(x)
for i in range(int(input())):
s=str(input())
if(s[:ln]==x and ans>s):ans=s
if(s[:ln]==x and ans=="."):ans=s
print(ans) if(ans!=".") else print(x)
|
Title: Autocomplete
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Autocomplete is a program function that enables inputting the text (in editors, command line shells, browsers etc.) completing the text by its inputted part. Vasya is busy working on a new browser called 'BERowser'. He happens to be working on the autocomplete function in the address line at this very moment. A list consisting of *n* last visited by the user pages and the inputted part *s* are known. Your task is to complete *s* to make it an address of one of the pages from the list. You have to find the lexicographically smallest address having a prefix *s*.
Input Specification:
The first line contains the *s* line which is the inputted part. The second line contains an integer *n* (1<=≤<=*n*<=≤<=100) which is the number of visited pages. Then follow *n* lines which are the visited pages, one on each line. All the lines have lengths of from 1 to 100 symbols inclusively and consist of lowercase Latin letters only.
Output Specification:
If *s* is not the beginning of any of *n* addresses of the visited pages, print *s*. Otherwise, print the lexicographically minimal address of one of the visited pages starting from *s*.
The lexicographical order is the order of words in a dictionary. The lexicographical comparison of lines is realized by the '<' operator in the modern programming languages.
Demo Input:
['next\n2\nnextpermutation\nnextelement\n', 'find\n4\nfind\nfindfirstof\nfindit\nfand\n', 'find\n4\nfondfind\nfondfirstof\nfondit\nfand\n']
Demo Output:
['nextelement\n', 'find\n', 'find\n']
Note:
none
|
```python
x=str(input());ans=".";ln = len(x)
for i in range(int(input())):
s=str(input())
if(s[:ln]==x and ans>s):ans=s
if(s[:ln]==x and ans=="."):ans=s
print(ans) if(ans!=".") else print(x)
```
| 3.94853
|
605
|
A
|
Sorting Railway Cars
|
PROGRAMMING
| 1,600
|
[
"constructive algorithms",
"greedy"
] | null | null |
An infinitely long railway has a train consisting of *n* cars, numbered from 1 to *n* (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
|
The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of cars in the train.
The second line contains *n* integers *p**i* (1<=≤<=*p**i*<=≤<=*n*, *p**i*<=≠<=*p**j* if *i*<=≠<=*j*) — the sequence of the numbers of the cars in the train.
|
Print a single integer — the minimum number of actions needed to sort the railway cars.
|
[
"5\n4 1 2 5 3\n",
"4\n4 1 3 2\n"
] |
[
"2\n",
"2\n"
] |
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
| 500
|
[
{
"input": "5\n4 1 2 5 3",
"output": "2"
},
{
"input": "4\n4 1 3 2",
"output": "2"
},
{
"input": "1\n1",
"output": "0"
},
{
"input": "2\n1 2",
"output": "0"
},
{
"input": "2\n2 1",
"output": "1"
},
{
"input": "6\n5 3 6 1 4 2",
"output": "4"
},
{
"input": "7\n1 2 3 6 7 4 5",
"output": "2"
},
{
"input": "8\n6 2 1 8 5 7 3 4",
"output": "5"
},
{
"input": "3\n1 2 3",
"output": "0"
},
{
"input": "3\n1 3 2",
"output": "1"
},
{
"input": "3\n2 1 3",
"output": "1"
},
{
"input": "3\n2 3 1",
"output": "1"
},
{
"input": "3\n3 1 2",
"output": "1"
},
{
"input": "3\n3 2 1",
"output": "2"
},
{
"input": "7\n1 3 5 7 2 4 6",
"output": "5"
},
{
"input": "7\n1 5 2 6 3 7 4",
"output": "3"
},
{
"input": "5\n1 4 2 3 5",
"output": "2"
},
{
"input": "9\n1 6 4 5 9 8 7 3 2",
"output": "7"
},
{
"input": "10\n5 1 6 2 8 3 4 10 9 7",
"output": "6"
},
{
"input": "50\n39 8 41 9 45 1 5 18 38 31 28 7 12 49 33 19 26 6 42 13 37 27 2 21 20 22 14 16 48 47 32 50 25 17 35 24 36 4 29 15 43 10 11 30 40 46 3 23 44 34",
"output": "46"
},
{
"input": "50\n43 15 10 33 32 31 13 7 5 22 36 1 25 14 38 19 8 6 24 42 28 21 44 35 4 3 49 30 27 46 2 9 17 37 45 41 18 39 12 11 16 20 50 26 29 34 40 47 48 23",
"output": "47"
},
{
"input": "50\n10 40 34 43 50 17 15 13 9 2 32 18 11 46 27 24 36 16 29 45 42 4 47 19 48 37 41 5 21 26 22 25 44 31 35 49 20 8 12 23 6 38 14 1 7 28 3 33 39 30",
"output": "46"
},
{
"input": "50\n10 37 3 46 45 29 36 13 21 25 35 5 18 33 12 19 50 16 30 47 20 42 39 28 2 6 38 8 7 31 22 27 26 9 15 14 34 48 4 32 40 43 44 24 11 1 23 17 49 41",
"output": "46"
},
{
"input": "50\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 42 37 38 39 40 41 36 43 44 45 46 47 48 49 50",
"output": "14"
},
{
"input": "50\n1 2 3 4 5 6 7 8 43 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 50 33 34 35 36 37 38 39 40 41 42 9 44 45 46 47 48 49 32",
"output": "27"
},
{
"input": "50\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 49 40 41 47 43 44 45 46 42 50 39 48",
"output": "11"
},
{
"input": "50\n1 2 3 4 27 6 7 8 9 10 30 12 13 14 15 16 17 18 19 20 21 22 23 24 28 26 5 25 29 11 31 32 33 34 38 36 37 35 39 40 41 42 43 44 45 46 47 48 49 50",
"output": "36"
},
{
"input": "50\n1 2 3 4 5 6 7 49 9 10 17 12 13 14 15 16 11 18 19 20 21 22 23 24 25 26 27 38 29 36 30 32 33 34 35 31 37 28 39 40 41 42 43 44 45 46 47 48 8 50",
"output": "38"
},
{
"input": "50\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 31 18 19 20 21 23 22 24 25 26 27 28 29 49 17 32 33 34 39 36 37 38 47 44 41 42 43 40 45 46 35 48 30 50",
"output": "33"
},
{
"input": "50\n1 2 15 4 5 6 7 8 9 10 11 12 13 14 3 16 17 18 19 32 21 22 36 28 23 26 27 24 29 30 31 20 33 34 37 25 35 38 40 39 41 42 43 44 45 46 47 48 49 50",
"output": "39"
},
{
"input": "5\n4 3 1 2 5",
"output": "3"
},
{
"input": "6\n1 3 5 6 4 2",
"output": "4"
},
{
"input": "10\n2 1 4 3 6 5 8 7 10 9",
"output": "8"
},
{
"input": "5\n1 2 4 5 3",
"output": "2"
},
{
"input": "7\n1 4 2 3 7 6 5",
"output": "4"
},
{
"input": "4\n3 1 2 4",
"output": "2"
},
{
"input": "6\n2 5 4 3 6 1",
"output": "4"
},
{
"input": "5\n1 3 4 5 2",
"output": "2"
},
{
"input": "6\n2 4 6 5 1 3",
"output": "4"
},
{
"input": "6\n1 2 4 5 6 3",
"output": "3"
},
{
"input": "9\n9 8 7 4 5 6 3 2 1",
"output": "6"
},
{
"input": "7\n4 1 2 3 6 5 7",
"output": "4"
}
] | 1,449,735,240
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 0
|
n = int(input())
cars = [int(x) for x in input().split()]
sorted_cars = sorted(enumerate(cars), key = lambda x : x[1])
max_sorted_length = 1
length = 1
for i in range(1, n):
if sorted_cars[i][0] > sorted_cars[i-1][0]:
length += 1
else:
if max_sorted_length < length: max_sorted_length = length
length = 1
print(n - max_sorted_length)
|
Title: Sorting Railway Cars
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
An infinitely long railway has a train consisting of *n* cars, numbered from 1 to *n* (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input Specification:
The first line of the input contains integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of cars in the train.
The second line contains *n* integers *p**i* (1<=≤<=*p**i*<=≤<=*n*, *p**i*<=≠<=*p**j* if *i*<=≠<=*j*) — the sequence of the numbers of the cars in the train.
Output Specification:
Print a single integer — the minimum number of actions needed to sort the railway cars.
Demo Input:
['5\n4 1 2 5 3\n', '4\n4 1 3 2\n']
Demo Output:
['2\n', '2\n']
Note:
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train.
|
```python
n = int(input())
cars = [int(x) for x in input().split()]
sorted_cars = sorted(enumerate(cars), key = lambda x : x[1])
max_sorted_length = 1
length = 1
for i in range(1, n):
if sorted_cars[i][0] > sorted_cars[i-1][0]:
length += 1
else:
if max_sorted_length < length: max_sorted_length = length
length = 1
print(n - max_sorted_length)
```
| 0
|
|
272
|
A
|
Dima and Friends
|
PROGRAMMING
| 1,000
|
[
"implementation",
"math"
] | null | 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,673,461,873
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 5
| 92
| 0
|
players = int(input()) + 1
fingers = sum(map(int, input().split()))
res = players - (fingers % players)
if res == 1:
print(3)
else:
print(res)
|
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
players = int(input()) + 1
fingers = sum(map(int, input().split()))
res = players - (fingers % players)
if res == 1:
print(3)
else:
print(res)
```
| 0
|
|
99
|
A
|
Help Far Away Kingdom
|
PROGRAMMING
| 800
|
[
"strings"
] |
A. Help Far Away Kingdom
|
2
|
256
|
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
- If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
|
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
|
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
|
[
"0.0\n",
"1.49\n",
"1.50\n",
"2.71828182845904523536\n",
"3.14159265358979323846\n",
"12345678901234567890.1\n",
"123456789123456789.999\n"
] |
[
"0",
"1",
"2",
"3",
"3",
"12345678901234567890",
"GOTO Vasilisa."
] |
none
| 500
|
[
{
"input": "0.0",
"output": "0"
},
{
"input": "1.49",
"output": "1"
},
{
"input": "1.50",
"output": "2"
},
{
"input": "2.71828182845904523536",
"output": "3"
},
{
"input": "3.14159265358979323846",
"output": "3"
},
{
"input": "12345678901234567890.1",
"output": "12345678901234567890"
},
{
"input": "123456789123456789.999",
"output": "GOTO Vasilisa."
},
{
"input": "12345678901234567890.9",
"output": "12345678901234567891"
},
{
"input": "123456789123456788.999",
"output": "123456789123456789"
},
{
"input": "9.000",
"output": "GOTO Vasilisa."
},
{
"input": "0.1",
"output": "0"
},
{
"input": "0.2",
"output": "0"
},
{
"input": "0.3",
"output": "0"
},
{
"input": "0.4",
"output": "0"
},
{
"input": "0.5",
"output": "1"
},
{
"input": "0.6",
"output": "1"
},
{
"input": "0.7",
"output": "1"
},
{
"input": "0.8",
"output": "1"
},
{
"input": "0.9",
"output": "1"
},
{
"input": "1.0",
"output": "1"
},
{
"input": "1.1",
"output": "1"
},
{
"input": "1.2",
"output": "1"
},
{
"input": "1.3",
"output": "1"
},
{
"input": "1.4",
"output": "1"
},
{
"input": "1.5",
"output": "2"
},
{
"input": "1.6",
"output": "2"
},
{
"input": "1.7",
"output": "2"
},
{
"input": "1.8",
"output": "2"
},
{
"input": "1.9",
"output": "2"
},
{
"input": "2.0",
"output": "2"
},
{
"input": "2.1",
"output": "2"
},
{
"input": "2.2",
"output": "2"
},
{
"input": "2.3",
"output": "2"
},
{
"input": "2.4",
"output": "2"
},
{
"input": "2.5",
"output": "3"
},
{
"input": "2.6",
"output": "3"
},
{
"input": "2.7",
"output": "3"
},
{
"input": "2.8",
"output": "3"
},
{
"input": "2.9",
"output": "3"
},
{
"input": "3.0",
"output": "3"
},
{
"input": "3.1",
"output": "3"
},
{
"input": "3.2",
"output": "3"
},
{
"input": "3.3",
"output": "3"
},
{
"input": "3.4",
"output": "3"
},
{
"input": "3.5",
"output": "4"
},
{
"input": "3.6",
"output": "4"
},
{
"input": "3.7",
"output": "4"
},
{
"input": "3.8",
"output": "4"
},
{
"input": "3.9",
"output": "4"
},
{
"input": "4.0",
"output": "4"
},
{
"input": "4.1",
"output": "4"
},
{
"input": "4.2",
"output": "4"
},
{
"input": "4.3",
"output": "4"
},
{
"input": "4.4",
"output": "4"
},
{
"input": "4.5",
"output": "5"
},
{
"input": "4.6",
"output": "5"
},
{
"input": "4.7",
"output": "5"
},
{
"input": "4.8",
"output": "5"
},
{
"input": "4.9",
"output": "5"
},
{
"input": "5.0",
"output": "5"
},
{
"input": "5.1",
"output": "5"
},
{
"input": "5.2",
"output": "5"
},
{
"input": "5.3",
"output": "5"
},
{
"input": "5.4",
"output": "5"
},
{
"input": "5.5",
"output": "6"
},
{
"input": "5.6",
"output": "6"
},
{
"input": "5.7",
"output": "6"
},
{
"input": "5.8",
"output": "6"
},
{
"input": "5.9",
"output": "6"
},
{
"input": "6.0",
"output": "6"
},
{
"input": "6.1",
"output": "6"
},
{
"input": "6.2",
"output": "6"
},
{
"input": "6.3",
"output": "6"
},
{
"input": "6.4",
"output": "6"
},
{
"input": "6.5",
"output": "7"
},
{
"input": "6.6",
"output": "7"
},
{
"input": "6.7",
"output": "7"
},
{
"input": "6.8",
"output": "7"
},
{
"input": "6.9",
"output": "7"
},
{
"input": "7.0",
"output": "7"
},
{
"input": "7.1",
"output": "7"
},
{
"input": "7.2",
"output": "7"
},
{
"input": "7.3",
"output": "7"
},
{
"input": "7.4",
"output": "7"
},
{
"input": "7.5",
"output": "8"
},
{
"input": "7.6",
"output": "8"
},
{
"input": "7.7",
"output": "8"
},
{
"input": "7.8",
"output": "8"
},
{
"input": "7.9",
"output": "8"
},
{
"input": "8.0",
"output": "8"
},
{
"input": "8.1",
"output": "8"
},
{
"input": "8.2",
"output": "8"
},
{
"input": "8.3",
"output": "8"
},
{
"input": "8.4",
"output": "8"
},
{
"input": "8.5",
"output": "9"
},
{
"input": "8.6",
"output": "9"
},
{
"input": "8.7",
"output": "9"
},
{
"input": "8.8",
"output": "9"
},
{
"input": "8.9",
"output": "9"
},
{
"input": "9.0",
"output": "GOTO Vasilisa."
},
{
"input": "9.1",
"output": "GOTO Vasilisa."
},
{
"input": "9.2",
"output": "GOTO Vasilisa."
},
{
"input": "9.3",
"output": "GOTO Vasilisa."
},
{
"input": "9.4",
"output": "GOTO Vasilisa."
},
{
"input": "9.5",
"output": "GOTO Vasilisa."
},
{
"input": "9.6",
"output": "GOTO Vasilisa."
},
{
"input": "9.7",
"output": "GOTO Vasilisa."
},
{
"input": "9.8",
"output": "GOTO Vasilisa."
},
{
"input": "9.9",
"output": "GOTO Vasilisa."
},
{
"input": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098.1664915772983166314490532653577560222779830866949001942720729759794777105570672781798092416748052690224813237139640723361527601154465287615917169132637313918577673651098507390501962",
"output": "609942239104813108618306232517836377583566292129955473517174437591594761209877970062547641606473593416245554763832875919009472288995880898848455284062760160557686724163817329189799336769669146848904803188614226720978399787805489531837751080926098"
},
{
"input": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394.20211856263503281388748282682120712214711232598021393495443628276945042110862480888110959179019986486690931930108026302665438087068150666835901617457150158918705186964935221768346957536540345814875615118637945520917367155931078965",
"output": "7002108534951820589946967018226114921984364117669853212254634761258884835434844673935047882480101006606512119541798298905598015607366335061012709906661245805358900665571472645463994925687210711492820804158354236327017974683658305043146543214454877759341394"
},
{
"input": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616067.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "1950583094879039694852660558765931995628486712128191844305265555887022812284005463780616068"
},
{
"input": "718130341896330596635811874410345440628950330.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "718130341896330596635811874410345440628950331"
},
{
"input": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280722.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "927925904158088313481229162503626281882161630091489367140850985555900173018122871746924067186432044676083646964286435457446768031295712712803570690846298544912543439221596866052681116386179629036945370280723"
},
{
"input": "68289614863244584294178637364598054554769889.500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "GOTO Vasilisa."
},
{
"input": "7536521504744364134984603189602839063535643888645969434165019366202558753840519.4999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999",
"output": "GOTO Vasilisa."
},
{
"input": "646188694587964249318078225173.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "646188694587964249318078225174"
},
{
"input": "7017472758334494297677068672222822550374695787171163207025095950296957261530.50",
"output": "7017472758334494297677068672222822550374695787171163207025095950296957261531"
},
{
"input": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774368.50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "259085737066615534998640212505663524594409165063310128108448186246980628179842202905722595400477937071746695941939306735605849342959111887834258250883469840846714848774369"
},
{
"input": "682500858233333594535201113441004740771119672961581796618069185960107115823662126812159957094407454522028503739299.5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "GOTO Vasilisa."
},
{
"input": "41203422675619090661099806687619.49999999999999999999999999999999999999999999999999999999999999999999999999999999999999999",
"output": "GOTO Vasilisa."
}
] | 1,382,029,681
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 6
| 92
| 0
|
number = input()
integer = ''
fraction = ''
for i in range(len(number)):
if number[i] == '.':
break
integer += number[i]
fraction = number[i:]
if integer[-1] != '9' and float(fraction) < 0.5:
round_num = int(integer)
elif integer[-1] != '9' and float(fraction) >= 0.5 :
round_num = int(integer) +1
elif integer[-1] == '9':
round_num = "GOTO Vasilisa"
print(round_num)
|
Title: Help Far Away Kingdom
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
In a far away kingdom lived the King, the Prince, the Shoemaker, the Dressmaker and many other citizens. They lived happily until great trouble came into the Kingdom. The ACMers settled there.
Most damage those strange creatures inflicted upon the kingdom was that they loved high precision numbers. As a result, the Kingdom healers had already had three appointments with the merchants who were asked to sell, say, exactly 0.273549107 beer barrels. To deal with the problem somehow, the King issued an order obliging rounding up all numbers to the closest integer to simplify calculations. Specifically, the order went like this:
- If a number's integer part does not end with digit 9 and its fractional part is strictly less than 0.5, then the rounded up number coincides with the number’s integer part. - If a number's integer part does not end with digit 9 and its fractional part is not less than 0.5, the rounded up number is obtained if we add 1 to the last digit of the number’s integer part.- If the number’s integer part ends with digit 9, to round up the numbers one should go to Vasilisa the Wise. In the whole Kingdom she is the only one who can perform the tricky operation of carrying into the next position.
Merchants found the algorithm very sophisticated and they asked you (the ACMers) to help them. Can you write a program that would perform the rounding according to the King’s order?
Input Specification:
The first line contains a single number to round up — the integer part (a non-empty set of decimal digits that do not start with 0 — with the exception of a case when the set consists of a single digit — in this case 0 can go first), then follows character «.» (a dot), and then follows the fractional part (any non-empty set of decimal digits). The number's length does not exceed 1000 characters, including the dot. There are no other characters in the input data.
Output Specification:
If the last number of the integer part is not equal to 9, print the rounded-up number without leading zeroes. Otherwise, print the message "GOTO Vasilisa." (without the quotes).
Demo Input:
['0.0\n', '1.49\n', '1.50\n', '2.71828182845904523536\n', '3.14159265358979323846\n', '12345678901234567890.1\n', '123456789123456789.999\n']
Demo Output:
['0', '1', '2', '3', '3', '12345678901234567890', 'GOTO Vasilisa.']
Note:
none
|
```python
number = input()
integer = ''
fraction = ''
for i in range(len(number)):
if number[i] == '.':
break
integer += number[i]
fraction = number[i:]
if integer[-1] != '9' and float(fraction) < 0.5:
round_num = int(integer)
elif integer[-1] != '9' and float(fraction) >= 0.5 :
round_num = int(integer) +1
elif integer[-1] == '9':
round_num = "GOTO Vasilisa"
print(round_num)
```
| 0
|
31
|
A
|
Worms Evolution
|
PROGRAMMING
| 1,200
|
[
"implementation"
] |
A. Worms Evolution
|
2
|
256
|
Professor Vasechkin is studying evolution of worms. Recently he put forward hypotheses that all worms evolve by division. There are *n* forms of worms. Worms of these forms have lengths *a*1, *a*2, ..., *a**n*. To prove his theory, professor needs to find 3 different forms that the length of the first form is equal to sum of lengths of the other two forms. Help him to do this.
|
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of worm's forms. The second line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=1000) — lengths of worms of each form.
|
Output 3 distinct integers *i* *j* *k* (1<=≤<=*i*,<=*j*,<=*k*<=≤<=*n*) — such indexes of worm's forms that *a**i*<==<=*a**j*<=+<=*a**k*. If there is no such triple, output -1. If there are several solutions, output any of them. It possible that *a**j*<==<=*a**k*.
|
[
"5\n1 2 3 5 7\n",
"5\n1 8 1 5 1\n"
] |
[
"3 2 1\n",
"-1\n"
] |
none
| 500
|
[
{
"input": "5\n1 2 3 5 7",
"output": "3 2 1"
},
{
"input": "5\n1 8 1 5 1",
"output": "-1"
},
{
"input": "4\n303 872 764 401",
"output": "-1"
},
{
"input": "6\n86 402 133 524 405 610",
"output": "6 4 1"
},
{
"input": "8\n217 779 418 895 996 473 3 22",
"output": "5 2 1"
},
{
"input": "10\n858 972 670 15 662 114 33 273 53 310",
"output": "2 6 1"
},
{
"input": "100\n611 697 572 770 603 870 128 245 49 904 468 982 788 943 549 288 668 796 803 515 999 735 912 49 298 80 412 841 494 434 543 298 17 571 271 105 70 313 178 755 194 279 585 766 412 164 907 841 776 556 731 268 735 880 176 267 287 65 239 588 155 658 821 47 783 595 585 69 226 906 429 161 999 148 7 484 362 585 952 365 92 749 904 525 307 626 883 367 450 755 564 950 728 724 69 106 119 157 96 290",
"output": "1 38 25"
},
{
"input": "100\n713 572 318 890 577 657 646 146 373 783 392 229 455 871 20 593 573 336 26 381 280 916 907 732 820 713 111 840 570 446 184 711 481 399 788 647 492 15 40 530 549 506 719 782 126 20 778 996 712 761 9 74 812 418 488 175 103 585 900 3 604 521 109 513 145 708 990 361 682 827 791 22 596 780 596 385 450 643 158 496 876 975 319 783 654 895 891 361 397 81 682 899 347 623 809 557 435 279 513 438",
"output": "1 63 61"
},
{
"input": "100\n156 822 179 298 981 82 610 345 373 378 895 734 768 15 78 335 764 608 932 297 717 553 916 367 425 447 361 195 66 70 901 236 905 744 919 564 296 610 963 628 840 52 100 750 345 308 37 687 192 704 101 815 10 990 216 358 823 546 578 821 706 148 182 582 421 482 829 425 121 337 500 301 402 868 66 935 625 527 746 585 308 523 488 914 608 709 875 252 151 781 447 2 756 176 976 302 450 35 680 791",
"output": "1 98 69"
},
{
"input": "100\n54 947 785 838 359 647 92 445 48 465 323 486 101 86 607 31 860 420 709 432 435 372 272 37 903 814 309 197 638 58 259 822 793 564 309 22 522 907 101 853 486 824 614 734 630 452 166 532 256 499 470 9 933 452 256 450 7 26 916 406 257 285 895 117 59 369 424 133 16 417 352 440 806 236 478 34 889 469 540 806 172 296 73 655 261 792 868 380 204 454 330 53 136 629 236 850 134 560 264 291",
"output": "2 29 27"
},
{
"input": "99\n175 269 828 129 499 890 127 263 995 807 508 289 996 226 437 320 365 642 757 22 190 8 345 499 834 713 962 889 336 171 608 492 320 257 472 801 176 325 301 306 198 729 933 4 640 322 226 317 567 586 249 237 202 633 287 128 911 654 719 988 420 855 361 574 716 899 317 356 581 440 284 982 541 111 439 29 37 560 961 224 478 906 319 416 736 603 808 87 762 697 392 713 19 459 262 238 239 599 997",
"output": "1 44 30"
},
{
"input": "98\n443 719 559 672 16 69 529 632 953 999 725 431 54 22 346 968 558 696 48 669 963 129 257 712 39 870 498 595 45 821 344 925 179 388 792 346 755 213 423 365 344 659 824 356 773 637 628 897 841 155 243 536 951 361 192 105 418 431 635 596 150 162 145 548 473 531 750 306 377 354 450 975 79 743 656 733 440 940 19 139 237 346 276 227 64 799 479 633 199 17 796 362 517 234 729 62 995 535",
"output": "2 70 40"
},
{
"input": "97\n359 522 938 862 181 600 283 1000 910 191 590 220 761 818 903 264 751 751 987 316 737 898 168 925 244 674 34 950 754 472 81 6 37 520 112 891 981 454 897 424 489 238 363 709 906 951 677 828 114 373 589 835 52 89 97 435 277 560 551 204 879 469 928 523 231 163 183 609 821 915 615 969 616 23 874 437 844 321 78 53 643 786 585 38 744 347 150 179 988 985 200 11 15 9 547 886 752",
"output": "1 23 10"
},
{
"input": "4\n303 872 764 401",
"output": "-1"
},
{
"input": "100\n328 397 235 453 188 254 879 225 423 36 384 296 486 592 231 849 856 255 213 898 234 800 701 529 951 693 507 326 15 905 618 348 967 927 28 979 752 850 343 35 84 302 36 390 482 826 249 918 91 289 973 457 557 348 365 239 709 565 320 560 153 130 647 708 483 469 788 473 322 844 830 562 611 961 397 673 69 960 74 703 369 968 382 451 328 160 211 230 566 208 7 545 293 73 806 375 157 410 303 58",
"output": "1 79 6"
},
{
"input": "33\n52 145 137 734 180 847 178 286 716 134 181 630 358 764 593 762 785 28 1 468 189 540 764 485 165 656 114 58 628 108 605 584 257",
"output": "8 30 7"
},
{
"input": "57\n75 291 309 68 444 654 985 158 514 204 116 918 374 806 176 31 49 455 269 66 722 713 164 818 317 295 546 564 134 641 28 13 987 478 146 219 213 940 289 173 157 666 168 391 392 71 870 477 446 988 414 568 964 684 409 671 454",
"output": "2 41 29"
},
{
"input": "88\n327 644 942 738 84 118 981 686 530 404 137 197 434 16 693 183 423 325 410 345 941 329 7 106 79 867 584 358 533 675 192 718 641 329 900 768 404 301 101 538 954 590 401 954 447 14 559 337 756 586 934 367 538 928 945 936 770 641 488 579 206 869 902 139 216 446 723 150 829 205 373 578 357 368 960 40 121 206 503 385 521 161 501 694 138 370 709 308",
"output": "1 77 61"
},
{
"input": "100\n804 510 266 304 788 625 862 888 408 82 414 470 777 991 729 229 933 406 601 1 596 720 608 706 432 361 527 548 59 548 474 515 4 991 263 568 681 24 117 563 576 587 281 643 904 521 891 106 842 884 943 54 605 815 504 757 311 374 335 192 447 652 633 410 455 402 382 150 432 836 413 819 669 875 638 925 217 805 632 520 605 266 728 795 162 222 603 159 284 790 914 443 775 97 789 606 859 13 851 47",
"output": "1 77 42"
},
{
"input": "100\n449 649 615 713 64 385 927 466 138 126 143 886 80 199 208 43 196 694 92 89 264 180 617 970 191 196 910 150 275 89 693 190 191 99 542 342 45 592 114 56 451 170 64 589 176 102 308 92 402 153 414 675 352 157 69 150 91 288 163 121 816 184 20 234 836 12 593 150 793 439 540 93 99 663 186 125 349 247 476 106 77 523 215 7 363 278 441 745 337 25 148 384 15 915 108 211 240 58 23 408",
"output": "1 6 5"
},
{
"input": "90\n881 436 52 308 97 261 153 931 670 538 702 156 114 445 154 685 452 76 966 790 93 42 547 65 736 364 136 489 719 322 239 628 696 735 55 703 622 375 100 188 804 341 546 474 484 446 729 290 974 301 602 225 996 244 488 983 882 460 962 754 395 617 61 640 534 292 158 375 632 902 420 979 379 38 100 67 963 928 190 456 545 571 45 716 153 68 844 2 102 116",
"output": "1 14 2"
},
{
"input": "80\n313 674 262 240 697 146 391 221 793 504 896 818 92 899 86 370 341 339 306 887 937 570 830 683 729 519 240 833 656 847 427 958 435 704 853 230 758 347 660 575 843 293 649 396 437 787 654 599 35 103 779 783 447 379 444 585 902 713 791 150 851 228 306 721 996 471 617 403 102 168 197 741 877 481 968 545 331 715 236 654",
"output": "1 13 8"
},
{
"input": "70\n745 264 471 171 946 32 277 511 269 469 89 831 69 2 369 407 583 602 646 633 429 747 113 302 722 321 344 824 241 372 263 287 822 24 652 758 246 967 219 313 882 597 752 965 389 775 227 556 95 904 308 340 899 514 400 187 275 318 621 546 659 488 199 154 811 1 725 79 925 82",
"output": "1 63 60"
},
{
"input": "60\n176 502 680 102 546 917 516 801 392 435 635 492 398 456 653 444 472 513 634 378 273 276 44 920 68 124 800 167 825 250 452 264 561 344 98 933 381 939 426 51 568 548 206 887 342 763 151 514 156 354 486 546 998 649 356 438 295 570 450 589",
"output": "2 26 20"
},
{
"input": "50\n608 92 889 33 146 803 402 91 868 400 828 505 375 558 584 129 361 776 974 123 765 804 326 186 61 927 904 511 762 775 640 593 300 664 897 461 869 911 986 789 607 500 309 457 294 104 724 471 216 155",
"output": "3 25 11"
},
{
"input": "40\n40 330 98 612 747 336 640 381 991 366 22 167 352 12 868 166 603 40 313 869 609 981 609 804 54 729 8 854 347 300 828 922 39 633 695 988 4 530 545 176",
"output": "5 10 8"
},
{
"input": "30\n471 920 308 544 347 222 878 671 467 332 215 180 681 114 151 203 492 951 653 614 453 510 540 422 399 532 113 198 932 825",
"output": "2 21 9"
},
{
"input": "20\n551 158 517 475 595 108 764 961 590 297 761 841 659 568 82 888 733 214 993 359",
"output": "3 20 2"
},
{
"input": "10\n983 748 726 406 196 993 2 251 66 263",
"output": "-1"
},
{
"input": "9\n933 266 457 863 768 257 594 136 145",
"output": "-1"
},
{
"input": "8\n537 198 48 771 944 868 700 163",
"output": "7 8 1"
},
{
"input": "7\n140 779 639 679 768 479 158",
"output": "2 3 1"
},
{
"input": "6\n744 359 230 586 944 442",
"output": "-1"
},
{
"input": "5\n700 939 173 494 120",
"output": "-1"
},
{
"input": "4\n303 872 764 401",
"output": "-1"
},
{
"input": "3\n907 452 355",
"output": "-1"
},
{
"input": "3\n963 630 333",
"output": "1 3 2"
},
{
"input": "3\n2 2 4",
"output": "3 2 1"
},
{
"input": "3\n2 4 100",
"output": "-1"
}
] | 1,637,860,380
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 62
| 0
|
# 31A
n=int(input())
a=list(map(int, input().split()))
r=0
for i in range(n):
for j in range(n):
for k in range(n):
if a[i]==a[j]+a[k]:
print(i,j,k)
r=1
break
if r==1:
break
if r==1:
break
if r==0:
print(-1)
|
Title: Worms Evolution
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Professor Vasechkin is studying evolution of worms. Recently he put forward hypotheses that all worms evolve by division. There are *n* forms of worms. Worms of these forms have lengths *a*1, *a*2, ..., *a**n*. To prove his theory, professor needs to find 3 different forms that the length of the first form is equal to sum of lengths of the other two forms. Help him to do this.
Input Specification:
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — amount of worm's forms. The second line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=1000) — lengths of worms of each form.
Output Specification:
Output 3 distinct integers *i* *j* *k* (1<=≤<=*i*,<=*j*,<=*k*<=≤<=*n*) — such indexes of worm's forms that *a**i*<==<=*a**j*<=+<=*a**k*. If there is no such triple, output -1. If there are several solutions, output any of them. It possible that *a**j*<==<=*a**k*.
Demo Input:
['5\n1 2 3 5 7\n', '5\n1 8 1 5 1\n']
Demo Output:
['3 2 1\n', '-1\n']
Note:
none
|
```python
# 31A
n=int(input())
a=list(map(int, input().split()))
r=0
for i in range(n):
for j in range(n):
for k in range(n):
if a[i]==a[j]+a[k]:
print(i,j,k)
r=1
break
if r==1:
break
if r==1:
break
if r==0:
print(-1)
```
| 0
|
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,597,084,017
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 81
| 216
| 6,656,000
|
N = int(input())
sum1 = 0
sum2 = 0
sum3 = 0
for i in range(N):
a,b,c = [int(j) for j in input().split()]
sum1 += a
sum2 += b
sum3 += c
if sum1 == sum2 == sum3 == 0:
print("YES")
else:
print("NO")
|
Title: Young Physicist
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" — thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.
Input Specification:
The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100), then follow *n* lines containing three integers each: the *x**i* coordinate, the *y**i* coordinate and the *z**i* coordinate of the force vector, applied to the body (<=-<=100<=≤<=*x**i*,<=*y**i*,<=*z**i*<=≤<=100).
Output Specification:
Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not.
Demo Input:
['3\n4 1 7\n-2 4 -1\n1 -5 -3\n', '3\n3 -1 7\n-5 2 -4\n2 -1 -3\n']
Demo Output:
['NO', 'YES']
Note:
none
|
```python
N = int(input())
sum1 = 0
sum2 = 0
sum3 = 0
for i in range(N):
a,b,c = [int(j) for j in input().split()]
sum1 += a
sum2 += b
sum3 += c
if sum1 == sum2 == sum3 == 0:
print("YES")
else:
print("NO")
```
| 3.933602
|
488
|
A
|
Giga Tower
|
PROGRAMMING
| 1,100
|
[
"brute force"
] | null | null |
Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view.
In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?).
Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.
|
The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).
|
Print the minimum *b* in a line.
|
[
"179\n",
"-1\n",
"18\n"
] |
[
"1\n",
"9\n",
"10\n"
] |
For the first sample, he has to arrive at the floor numbered 180.
For the second sample, he will arrive at 8.
Note that *b* should be positive, so the answer for the third sample is 10, not 0.
| 500
|
[
{
"input": "179",
"output": "1"
},
{
"input": "-1",
"output": "9"
},
{
"input": "18",
"output": "10"
},
{
"input": "-410058385",
"output": "1"
},
{
"input": "-586825624",
"output": "1"
},
{
"input": "852318890",
"output": "1"
},
{
"input": "919067153",
"output": "5"
},
{
"input": "690422411",
"output": "7"
},
{
"input": "-408490162",
"output": "1"
},
{
"input": "-8",
"output": "16"
},
{
"input": "-6",
"output": "14"
},
{
"input": "-4",
"output": "12"
},
{
"input": "-2",
"output": "10"
},
{
"input": "0",
"output": "8"
},
{
"input": "2",
"output": "6"
},
{
"input": "4",
"output": "4"
},
{
"input": "6",
"output": "2"
},
{
"input": "8",
"output": "10"
},
{
"input": "1000000000",
"output": "8"
},
{
"input": "-1000000000",
"output": "2"
},
{
"input": "88888",
"output": "1"
},
{
"input": "89",
"output": "9"
},
{
"input": "-80000000",
"output": "2"
},
{
"input": "-8888",
"output": "1"
},
{
"input": "-17",
"output": "9"
},
{
"input": "78",
"output": "2"
},
{
"input": "-19",
"output": "1"
},
{
"input": "-999999998",
"output": "9"
},
{
"input": "-999999997",
"output": "8"
},
{
"input": "999999997",
"output": "1"
},
{
"input": "811111111",
"output": "1"
},
{
"input": "-8",
"output": "16"
},
{
"input": "-5",
"output": "13"
},
{
"input": "-7",
"output": "15"
},
{
"input": "1000000000",
"output": "8"
}
] | 1,424,455,571
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 31
| 0
|
a = int(input(""))
count = 0
def check(m):
if "8"in str(m):
return true
else:
return false
while check(a) == false:
a = a + 1
count = count + 1
print(count)
|
Title: Giga Tower
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view.
In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?).
Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.
Input Specification:
The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).
Output Specification:
Print the minimum *b* in a line.
Demo Input:
['179\n', '-1\n', '18\n']
Demo Output:
['1\n', '9\n', '10\n']
Note:
For the first sample, he has to arrive at the floor numbered 180.
For the second sample, he will arrive at 8.
Note that *b* should be positive, so the answer for the third sample is 10, not 0.
|
```python
a = int(input(""))
count = 0
def check(m):
if "8"in str(m):
return true
else:
return false
while check(a) == false:
a = a + 1
count = count + 1
print(count)
```
| -1
|
|
980
|
A
|
Links and Pearls
|
PROGRAMMING
| 900
|
[
"implementation",
"math"
] | null | null |
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
|
The only line of input contains a string $s$ ($3 \leq |s| \leq 100$), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
|
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
|
[
"-o-o--",
"-o---\n",
"-o---o-\n",
"ooo\n"
] |
[
"YES",
"YES",
"NO",
"YES\n"
] |
none
| 500
|
[
{
"input": "-o-o--",
"output": "YES"
},
{
"input": "-o---",
"output": "YES"
},
{
"input": "-o---o-",
"output": "NO"
},
{
"input": "ooo",
"output": "YES"
},
{
"input": "---",
"output": "YES"
},
{
"input": "--o-o-----o----o--oo-o-----ooo-oo---o--",
"output": "YES"
},
{
"input": "-o--o-oo---o-o-o--o-o----oo------oo-----o----o-o-o--oo-o--o---o--o----------o---o-o-oo---o--o-oo-o--",
"output": "NO"
},
{
"input": "-ooo--",
"output": "YES"
},
{
"input": "---o--",
"output": "YES"
},
{
"input": "oo-ooo",
"output": "NO"
},
{
"input": "------o-o--o-----o--",
"output": "YES"
},
{
"input": "--o---o----------o----o----------o--o-o-----o-oo---oo--oo---o-------------oo-----o-------------o---o",
"output": "YES"
},
{
"input": "----------------------------------------------------------------------------------------------------",
"output": "YES"
},
{
"input": "-oo-oo------",
"output": "YES"
},
{
"input": "---------------------------------o----------------------------oo------------------------------------",
"output": "NO"
},
{
"input": "oo--o--o--------oo----------------o-----------o----o-----o----------o---o---o-----o---------ooo---",
"output": "NO"
},
{
"input": "--o---oooo--o-o--o-----o----ooooo--o-oo--o------oooo--------------ooo-o-o----",
"output": "NO"
},
{
"input": "-----------------------------o--o-o-------",
"output": "YES"
},
{
"input": "o-oo-o--oo----o-o----------o---o--o----o----o---oo-ooo-o--o-",
"output": "YES"
},
{
"input": "oooooooooo-ooo-oooooo-ooooooooooooooo--o-o-oooooooooooooo-oooooooooooooo",
"output": "NO"
},
{
"input": "-----------------o-o--oo------o--------o---o--o----------------oooo-------------ooo-----ooo-----o",
"output": "NO"
},
{
"input": "ooo-ooooooo-oo-ooooooooo-oooooooooooooo-oooo-o-oooooooooo--oooooooooooo-oooooooooo-ooooooo",
"output": "NO"
},
{
"input": "oo-o-ooooo---oo---o-oo---o--o-ooo-o---o-oo---oo---oooo---o---o-oo-oo-o-ooo----ooo--oo--o--oo-o-oo",
"output": "NO"
},
{
"input": "-----o-----oo-o-o-o-o----o---------oo---ooo-------------o----o---o-o",
"output": "YES"
},
{
"input": "oo--o-o-o----o-oooo-ooooo---o-oo--o-o--ooo--o--oooo--oo----o----o-o-oooo---o-oooo--ooo-o-o----oo---",
"output": "NO"
},
{
"input": "------oo----o----o-oo-o--------o-----oo-----------------------o------------o-o----oo---------",
"output": "NO"
},
{
"input": "-o--o--------o--o------o---o-o----------o-------o-o-o-------oo----oo------o------oo--o--",
"output": "NO"
},
{
"input": "------------------o----------------------------------o-o-------------",
"output": "YES"
},
{
"input": "-------------o----ooo-----o-o-------------ooo-----------ooo------o----oo---",
"output": "YES"
},
{
"input": "-------o--------------------o--o---------------o---o--o-----",
"output": "YES"
},
{
"input": "------------------------o------------o-----o----------------",
"output": "YES"
},
{
"input": "------oo----------o------o-----o---------o------------o----o--o",
"output": "YES"
},
{
"input": "------------o------------------o-----------------------o-----------o",
"output": "YES"
},
{
"input": "o---o---------------",
"output": "YES"
},
{
"input": "----------------------o---o----o---o-----------o-o-----o",
"output": "YES"
},
{
"input": "----------------------------------------------------------------------o-o---------------------",
"output": "YES"
},
{
"input": "----o---o-------------------------",
"output": "YES"
},
{
"input": "o----------------------oo----",
"output": "NO"
},
{
"input": "-o-o--o-o--o-----o-----o-o--o-o---oooo-o",
"output": "NO"
},
{
"input": "-o-ooo-o--o----o--o-o-oo-----------o-o-",
"output": "YES"
},
{
"input": "o-------o-------o-------------",
"output": "YES"
},
{
"input": "oo----------------------o--------------o--------------o-----",
"output": "YES"
},
{
"input": "-----------------------------------o---------------------o--------------------------",
"output": "YES"
},
{
"input": "--o--o----o-o---o--o----o-o--oo-----o-oo--o---o---ooo-o--",
"output": "YES"
},
{
"input": "---------------o-o----",
"output": "YES"
},
{
"input": "o------ooo--o-o-oo--o------o----ooo-----o-----o-----o-ooo-o---o----oo",
"output": "YES"
},
{
"input": "----o----o",
"output": "YES"
},
{
"input": "o--o--o--o--o--o--o--o--o--o--o--o--",
"output": "YES"
},
{
"input": "o---o---o---o---o----o----o----o---o---o---o",
"output": "YES"
},
{
"input": "o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-",
"output": "YES"
},
{
"input": "-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o",
"output": "YES"
},
{
"input": "o----------o----------o----------o----------o----------o----------o----------o----------o----------o",
"output": "YES"
},
{
"input": "o---------o---------o---------o---------o---------o---------o---------o---------o",
"output": "YES"
},
{
"input": "--------o--------o--------o--------o--------o--------o--------o--------o--------",
"output": "YES"
},
{
"input": "o---o----",
"output": "NO"
},
{
"input": "---o----o",
"output": "NO"
},
{
"input": "-o-",
"output": "YES"
},
{
"input": "------oooo",
"output": "NO"
},
{
"input": "oo--",
"output": "YES"
},
{
"input": "---o",
"output": "YES"
},
{
"input": "ooo-",
"output": "NO"
},
{
"input": "oooooooo----------",
"output": "NO"
},
{
"input": "oooo--",
"output": "NO"
},
{
"input": "o-ooooo",
"output": "NO"
},
{
"input": "-oo",
"output": "NO"
},
{
"input": "ooooo-",
"output": "NO"
},
{
"input": "ooo---------",
"output": "YES"
},
{
"input": "oo-",
"output": "NO"
},
{
"input": "---ooo",
"output": "YES"
}
] | 1,525,792,348
| 448
|
Python 3
|
WRONG_ANSWER
|
PRETESTS
| 4
| 93
| 7,065,600
|
if __name__ == '__main__':
n, m = 0, 0
for i in input():
if i == 'o':
n += 1
else:
m+=1
if n ==0:
print("NO")
elif m%n==0:
print("YES")
else:
print("NO")
|
Title: Links and Pearls
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A necklace can be described as a string of links ('-') and pearls ('o'), with the last link or pearl connected to the first one.
You can remove a link or a pearl and insert it between two other existing links or pearls (or between a link and a pearl) on the necklace. This process can be repeated as many times as you like, but you can't throw away any parts.
Can you make the number of links between every two adjacent pearls equal? Two pearls are considered to be adjacent if there is no other pearl between them.
Note that the final necklace should remain as one circular part of the same length as the initial necklace.
Input Specification:
The only line of input contains a string $s$ ($3 \leq |s| \leq 100$), representing the necklace, where a dash '-' represents a link and the lowercase English letter 'o' represents a pearl.
Output Specification:
Print "YES" if the links and pearls can be rejoined such that the number of links between adjacent pearls is equal. Otherwise print "NO".
You can print each letter in any case (upper or lower).
Demo Input:
['-o-o--', '-o---\n', '-o---o-\n', 'ooo\n']
Demo Output:
['YES', 'YES', 'NO', 'YES\n']
Note:
none
|
```python
if __name__ == '__main__':
n, m = 0, 0
for i in input():
if i == 'o':
n += 1
else:
m+=1
if n ==0:
print("NO")
elif m%n==0:
print("YES")
else:
print("NO")
```
| 0
|
|
205
|
A
|
Little Elephant and Rozdil
|
PROGRAMMING
| 900
|
[
"brute force",
"implementation"
] | null | null |
The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. "Rozdil").
However, Rozdil is dangerous to settle, so the Little Elephant wants to go to some other town. The Little Elephant doesn't like to spend much time on travelling, so for his journey he will choose a town that needs minimum time to travel to. If there are multiple such cities, then the Little Elephant won't go anywhere.
For each town except for Rozdil you know the time needed to travel to this town. Find the town the Little Elephant will go to or print "Still Rozdil", if he stays in Rozdil.
|
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of cities. The next line contains *n* integers, separated by single spaces: the *i*-th integer represents the time needed to go from town Rozdil to the *i*-th town. The time values are positive integers, not exceeding 109.
You can consider the cities numbered from 1 to *n*, inclusive. Rozdil is not among the numbered cities.
|
Print the answer on a single line — the number of the town the Little Elephant will go to. If there are multiple cities with minimum travel time, print "Still Rozdil" (without the quotes).
|
[
"2\n7 4\n",
"7\n7 4 47 100 4 9 12\n"
] |
[
"2\n",
"Still Rozdil\n"
] |
In the first sample there are only two cities where the Little Elephant can go. The travel time for the first town equals 7, to the second one — 4. The town which is closest to Rodzil (the only one) is the second one, so the answer is 2.
In the second sample the closest cities are cities two and five, the travelling time to both of them equals 4, so the answer is "Still Rozdil".
| 500
|
[
{
"input": "2\n7 4",
"output": "2"
},
{
"input": "7\n7 4 47 100 4 9 12",
"output": "Still Rozdil"
},
{
"input": "1\n47",
"output": "1"
},
{
"input": "2\n1000000000 1000000000",
"output": "Still Rozdil"
},
{
"input": "7\n7 6 5 4 3 2 1",
"output": "7"
},
{
"input": "10\n1 1 1 1 1 1 1 1 1 1",
"output": "Still Rozdil"
},
{
"input": "4\n1000000000 100000000 1000000 1000000",
"output": "Still Rozdil"
},
{
"input": "20\n7 1 1 2 1 1 8 7 7 8 4 3 7 10 5 3 10 5 10 6",
"output": "Still Rozdil"
},
{
"input": "20\n3 3 6 9 8 2 4 1 7 3 2 9 7 7 9 7 2 6 2 7",
"output": "8"
},
{
"input": "47\n35 79 84 56 67 95 80 34 77 68 14 55 95 32 40 89 58 79 96 66 50 79 35 86 31 74 91 35 22 72 84 38 11 59 73 51 65 11 11 62 30 12 32 71 69 15 11",
"output": "Still Rozdil"
},
{
"input": "47\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 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3",
"output": "32"
},
{
"input": "25\n73 56 65 70 57 57 49 50 65 68 54 48 66 55 55 66 60 70 47 62 63 70 62 70 63",
"output": "19"
},
{
"input": "100\n922 938 103 689 526 118 314 496 373 47 224 544 495 656 804 754 269 356 354 536 817 597 787 178 516 659 790 993 786 169 866 779 997 350 674 437 219 546 564 893 402 449 751 628 238 686 392 951 716 439 332 563 215 146 746 311 866 773 548 675 731 183 890 802 488 944 473 25 662 559 732 534 777 144 502 593 839 692 84 337 679 718 1005 663 709 940 86 469 310 960 902 233 606 761 116 231 662 903 68 622",
"output": "68"
},
{
"input": "5\n5 5 2 3 1",
"output": "5"
},
{
"input": "1\n1000000000",
"output": "1"
},
{
"input": "3\n7 7 4",
"output": "3"
},
{
"input": "3\n2 2 1",
"output": "3"
},
{
"input": "3\n4 4 3",
"output": "3"
},
{
"input": "2\n10000001 10000002",
"output": "1"
},
{
"input": "4\n3 3 2 1",
"output": "4"
},
{
"input": "3\n1 2 3",
"output": "1"
},
{
"input": "2\n1000000000 100000000",
"output": "2"
},
{
"input": "1\n99999999",
"output": "1"
},
{
"input": "3\n5 5 3",
"output": "3"
},
{
"input": "3\n7 7 5",
"output": "3"
},
{
"input": "3\n3 3 1",
"output": "3"
},
{
"input": "4\n10 10 10 1",
"output": "4"
}
] | 1,593,578,670
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 45
| 342
| 8,908,800
|
n = int(input())
L = map(int , input().split())
L = list(L)
M = L.copy()
# print(L,M,n)
L.sort()
# print(L,M,n)
count_min = 0
flag = True
# for i in L:
# if L[0] == i:
# count_min += 1
# if count_min >= 2:
# flag = False
# break
count_min = L.count(min(L))
if count_min > 1:
flag = False
if flag == False:
print("Still Rozdil")
else:
print(M.index(min(M)) + 1 )
|
Title: Little Elephant and Rozdil
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. "Rozdil").
However, Rozdil is dangerous to settle, so the Little Elephant wants to go to some other town. The Little Elephant doesn't like to spend much time on travelling, so for his journey he will choose a town that needs minimum time to travel to. If there are multiple such cities, then the Little Elephant won't go anywhere.
For each town except for Rozdil you know the time needed to travel to this town. Find the town the Little Elephant will go to or print "Still Rozdil", if he stays in Rozdil.
Input Specification:
The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the number of cities. The next line contains *n* integers, separated by single spaces: the *i*-th integer represents the time needed to go from town Rozdil to the *i*-th town. The time values are positive integers, not exceeding 109.
You can consider the cities numbered from 1 to *n*, inclusive. Rozdil is not among the numbered cities.
Output Specification:
Print the answer on a single line — the number of the town the Little Elephant will go to. If there are multiple cities with minimum travel time, print "Still Rozdil" (without the quotes).
Demo Input:
['2\n7 4\n', '7\n7 4 47 100 4 9 12\n']
Demo Output:
['2\n', 'Still Rozdil\n']
Note:
In the first sample there are only two cities where the Little Elephant can go. The travel time for the first town equals 7, to the second one — 4. The town which is closest to Rodzil (the only one) is the second one, so the answer is 2.
In the second sample the closest cities are cities two and five, the travelling time to both of them equals 4, so the answer is "Still Rozdil".
|
```python
n = int(input())
L = map(int , input().split())
L = list(L)
M = L.copy()
# print(L,M,n)
L.sort()
# print(L,M,n)
count_min = 0
flag = True
# for i in L:
# if L[0] == i:
# count_min += 1
# if count_min >= 2:
# flag = False
# break
count_min = L.count(min(L))
if count_min > 1:
flag = False
if flag == False:
print("Still Rozdil")
else:
print(M.index(min(M)) + 1 )
```
| 3
|
|
484
|
A
|
Bits
|
PROGRAMMING
| 1,700
|
[
"bitmasks",
"constructive algorithms"
] | null | null |
Let's denote as the number of bits set ('1' bits) in the binary representation of the non-negative integer *x*.
You are given multiple queries consisting of pairs of integers *l* and *r*. For each query, find the *x*, such that *l*<=≤<=*x*<=≤<=*r*, and is maximum possible. If there are multiple such numbers find the smallest of them.
|
The first line contains integer *n* — the number of queries (1<=≤<=*n*<=≤<=10000).
Each of the following *n* lines contain two integers *l**i*,<=*r**i* — the arguments for the corresponding query (0<=≤<=*l**i*<=≤<=*r**i*<=≤<=1018).
|
For each query print the answer in a separate line.
|
[
"3\n1 2\n2 4\n1 10\n"
] |
[
"1\n3\n7\n"
] |
The binary representations of numbers from 1 to 10 are listed below:
1<sub class="lower-index">10</sub> = 1<sub class="lower-index">2</sub>
2<sub class="lower-index">10</sub> = 10<sub class="lower-index">2</sub>
3<sub class="lower-index">10</sub> = 11<sub class="lower-index">2</sub>
4<sub class="lower-index">10</sub> = 100<sub class="lower-index">2</sub>
5<sub class="lower-index">10</sub> = 101<sub class="lower-index">2</sub>
6<sub class="lower-index">10</sub> = 110<sub class="lower-index">2</sub>
7<sub class="lower-index">10</sub> = 111<sub class="lower-index">2</sub>
8<sub class="lower-index">10</sub> = 1000<sub class="lower-index">2</sub>
9<sub class="lower-index">10</sub> = 1001<sub class="lower-index">2</sub>
10<sub class="lower-index">10</sub> = 1010<sub class="lower-index">2</sub>
| 500
|
[
{
"input": "3\n1 2\n2 4\n1 10",
"output": "1\n3\n7"
},
{
"input": "55\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n2 2\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n3 3\n3 4\n3 5\n3 6\n3 7\n3 8\n3 9\n3 10\n4 4\n4 5\n4 6\n4 7\n4 8\n4 9\n4 10\n5 5\n5 6\n5 7\n5 8\n5 9\n5 10\n6 6\n6 7\n6 8\n6 9\n6 10\n7 7\n7 8\n7 9\n7 10\n8 8\n8 9\n8 10\n9 9\n9 10\n10 10",
"output": "1\n1\n3\n3\n3\n3\n7\n7\n7\n7\n2\n3\n3\n3\n3\n7\n7\n7\n7\n3\n3\n3\n3\n7\n7\n7\n7\n4\n5\n5\n7\n7\n7\n7\n5\n5\n7\n7\n7\n7\n6\n7\n7\n7\n7\n7\n7\n7\n7\n8\n9\n9\n9\n9\n10"
},
{
"input": "18\n1 10\n1 100\n1 1000\n1 10000\n1 100000\n1 1000000\n1 10000000\n1 100000000\n1 1000000000\n1 10000000000\n1 100000000000\n1 1000000000000\n1 10000000000000\n1 100000000000000\n1 1000000000000000\n1 10000000000000000\n1 100000000000000000\n1 1000000000000000000",
"output": "7\n63\n511\n8191\n65535\n524287\n8388607\n67108863\n536870911\n8589934591\n68719476735\n549755813887\n8796093022207\n70368744177663\n562949953421311\n9007199254740991\n72057594037927935\n576460752303423487"
},
{
"input": "3\n0 0\n1 3\n2 4",
"output": "0\n3\n3"
},
{
"input": "17\n0 0\n0 8\n1 8\n36 39\n3 4\n3 7\n2 17\n8 12\n9 12\n10 12\n10 15\n6 14\n8 15\n9 15\n15 15\n100000000000000000 1000000000000000000\n99999999999999999 1000000000000000000",
"output": "0\n7\n7\n39\n3\n7\n15\n11\n11\n11\n15\n7\n15\n15\n15\n576460752303423487\n576460752303423487"
}
] | 1,564,421,119
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 1
| 124
| 1,433,600
|
from sys import stdin
#stdin = open("sum.in", 'r')
hat = stdin.readlines()
#print(hat)
nn = int(hat[0])
def x(n, ind):
return n & ~(1 << ind-1)
for j in range(nn):
#print("hell")
flag = True
a, b = map(int, hat[1+j].split())
mine = 0
for i in range(58, 0, -1):
if a < 2**i <= b:
print(2**i-1)
flag = False
break
elif 2**i <= b:
#print(i)
mine = 2**(i+1)-1
break
if not flag:
#print("yes")
continue
y = len(str(bin(mine)))-3
while y:
mine = mine & ~(1 << y-1)
y -= 1
if a < mine <= b:
print(mine)
break
|
Title: Bits
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's denote as the number of bits set ('1' bits) in the binary representation of the non-negative integer *x*.
You are given multiple queries consisting of pairs of integers *l* and *r*. For each query, find the *x*, such that *l*<=≤<=*x*<=≤<=*r*, and is maximum possible. If there are multiple such numbers find the smallest of them.
Input Specification:
The first line contains integer *n* — the number of queries (1<=≤<=*n*<=≤<=10000).
Each of the following *n* lines contain two integers *l**i*,<=*r**i* — the arguments for the corresponding query (0<=≤<=*l**i*<=≤<=*r**i*<=≤<=1018).
Output Specification:
For each query print the answer in a separate line.
Demo Input:
['3\n1 2\n2 4\n1 10\n']
Demo Output:
['1\n3\n7\n']
Note:
The binary representations of numbers from 1 to 10 are listed below:
1<sub class="lower-index">10</sub> = 1<sub class="lower-index">2</sub>
2<sub class="lower-index">10</sub> = 10<sub class="lower-index">2</sub>
3<sub class="lower-index">10</sub> = 11<sub class="lower-index">2</sub>
4<sub class="lower-index">10</sub> = 100<sub class="lower-index">2</sub>
5<sub class="lower-index">10</sub> = 101<sub class="lower-index">2</sub>
6<sub class="lower-index">10</sub> = 110<sub class="lower-index">2</sub>
7<sub class="lower-index">10</sub> = 111<sub class="lower-index">2</sub>
8<sub class="lower-index">10</sub> = 1000<sub class="lower-index">2</sub>
9<sub class="lower-index">10</sub> = 1001<sub class="lower-index">2</sub>
10<sub class="lower-index">10</sub> = 1010<sub class="lower-index">2</sub>
|
```python
from sys import stdin
#stdin = open("sum.in", 'r')
hat = stdin.readlines()
#print(hat)
nn = int(hat[0])
def x(n, ind):
return n & ~(1 << ind-1)
for j in range(nn):
#print("hell")
flag = True
a, b = map(int, hat[1+j].split())
mine = 0
for i in range(58, 0, -1):
if a < 2**i <= b:
print(2**i-1)
flag = False
break
elif 2**i <= b:
#print(i)
mine = 2**(i+1)-1
break
if not flag:
#print("yes")
continue
y = len(str(bin(mine)))-3
while y:
mine = mine & ~(1 << y-1)
y -= 1
if a < mine <= b:
print(mine)
break
```
| 0
|
|
429
|
A
|
Xor-tree
|
PROGRAMMING
| 1,300
|
[
"dfs and similar",
"trees"
] | null | null |
Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.
The game is played on a tree having *n* nodes, numbered from 1 to *n*. Each node *i* has an initial value *init**i*, which is either 0 or 1. The root of the tree is node 1.
One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node *x*. Right after someone has picked node *x*, the value of node *x* flips, the values of sons of *x* remain the same, the values of sons of sons of *x* flips, the values of sons of sons of sons of *x* remain the same and so on.
The goal of the game is to get each node *i* to have value *goal**i*, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
|
The first line contains an integer *n* (1<=≤<=*n*<=≤<=105). Each of the next *n*<=-<=1 lines contains two integers *u**i* and *v**i* (1<=≤<=*u**i*,<=*v**i*<=≤<=*n*; *u**i*<=≠<=*v**i*) meaning there is an edge between nodes *u**i* and *v**i*.
The next line contains *n* integer numbers, the *i*-th of them corresponds to *init**i* (*init**i* is either 0 or 1). The following line also contains *n* integer numbers, the *i*-th number corresponds to *goal**i* (*goal**i* is either 0 or 1).
|
In the first line output an integer number *cnt*, representing the minimal number of operations you perform. Each of the next *cnt* lines should contain an integer *x**i*, representing that you pick a node *x**i*.
|
[
"10\n2 1\n3 1\n4 2\n5 1\n6 2\n7 5\n8 6\n9 8\n10 5\n1 0 1 1 0 1 0 1 0 1\n1 0 1 0 0 1 1 1 0 1\n"
] |
[
"2\n4\n7\n"
] |
none
| 500
|
[
{
"input": "10\n2 1\n3 1\n4 2\n5 1\n6 2\n7 5\n8 6\n9 8\n10 5\n1 0 1 1 0 1 0 1 0 1\n1 0 1 0 0 1 1 1 0 1",
"output": "2\n4\n7"
},
{
"input": "15\n2 1\n3 2\n4 3\n5 4\n6 5\n7 6\n8 7\n9 8\n10 9\n11 10\n12 11\n13 12\n14 13\n15 14\n0 1 0 0 1 1 1 1 1 1 0 0 0 1 1\n1 1 1 1 0 0 1 1 0 1 0 0 1 1 0",
"output": "7\n1\n4\n7\n8\n9\n11\n13"
},
{
"input": "20\n2 1\n3 2\n4 3\n5 4\n6 4\n7 1\n8 2\n9 4\n10 2\n11 6\n12 9\n13 2\n14 12\n15 14\n16 8\n17 9\n18 13\n19 2\n20 17\n1 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 1 0 1 0\n1 0 0 1 0 0 1 1 0 0 1 0 0 1 0 0 0 1 0 1",
"output": "8\n11\n15\n17\n20\n10\n18\n19\n7"
},
{
"input": "30\n2 1\n3 2\n4 3\n5 3\n6 5\n7 3\n8 3\n9 2\n10 3\n11 2\n12 11\n13 6\n14 4\n15 5\n16 11\n17 9\n18 14\n19 6\n20 2\n21 19\n22 9\n23 19\n24 20\n25 14\n26 22\n27 1\n28 6\n29 13\n30 27\n1 0 1 1 1 1 0 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 1 1 1 0\n0 1 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 0 1 1 0 0 0",
"output": "15\n1\n2\n4\n5\n6\n13\n29\n19\n21\n23\n28\n7\n22\n26\n30"
},
{
"input": "15\n2 1\n3 1\n4 1\n5 1\n6 3\n7 1\n8 1\n9 1\n10 5\n11 9\n12 3\n13 5\n14 5\n15 4\n1 1 0 0 0 0 1 1 1 0 1 1 1 0 0\n1 0 1 1 0 1 1 1 1 1 1 1 1 1 0",
"output": "6\n2\n3\n6\n4\n10\n14"
},
{
"input": "20\n2 1\n3 1\n4 2\n5 2\n6 3\n7 1\n8 6\n9 2\n10 3\n11 6\n12 2\n13 3\n14 2\n15 1\n16 8\n17 15\n18 2\n19 14\n20 14\n0 0 0 0 1 1 1 1 1 1 0 1 1 1 0 0 0 1 1 1\n0 1 0 1 1 1 0 0 1 0 1 1 0 1 0 1 0 0 1 0",
"output": "10\n2\n4\n19\n18\n8\n16\n11\n10\n13\n7"
},
{
"input": "23\n2 1\n3 2\n4 1\n5 1\n6 5\n7 3\n8 2\n9 8\n10 5\n11 6\n12 9\n13 3\n14 11\n15 5\n16 2\n17 3\n18 10\n19 16\n20 14\n21 19\n22 17\n23 7\n0 1 0 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 1 0 0 0 0\n0 0 0 0 1 1 1 1 1 0 1 0 1 0 0 1 1 0 0 0 0 0 1",
"output": "8\n2\n23\n13\n17\n9\n4\n11\n20"
},
{
"input": "1\n0\n0",
"output": "0"
},
{
"input": "10\n1 10\n1 9\n10 2\n10 3\n3 7\n3 8\n9 4\n9 5\n5 6\n1 0 1 1 0 1 0 1 0 1\n0 0 0 0 0 0 0 0 0 0",
"output": "6\n1\n10\n2\n7\n5\n6"
}
] | 1,657,974,733
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 35
| 577
| 14,233,600
|
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
############################################################################
# ACTUAL CODE
############################################################################
from collections import deque
def solve(t):
n = int(input().strip())
# print(n,end=" ")
#take graph as input
g = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int,input().strip().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
initial = list(map(int,input().split()))
final = list(map(int,input().split()))
q = deque()
# (node,level%2,flip(levl%2),flip(lev%2==`))
q.append((0,0,0,0))
visited = [0 for i in range(n)]
ans = 0
all_nodes = []
#now we don bfs
while q:
(node,level,flip0,flip1) = q.popleft()
visited[node]=1
node_val = initial[node]
if((level%2==0 and flip0==1) or (level%2==1 and flip1==1)): node_val = node_val^1
if(final[node]!=node_val):
ans+=1
all_nodes.append(node+1)
if(level%2==0):flip0 = flip0^1
else: flip1 = flip1^1
for u in g[node]:
if(visited[u]==0):q.append((u,level+1,flip0,flip1))
print(ans)
for nodes in all_nodes:
print(nodes)
def main():
# tc = int(input().strip())
tc = 1
for t in range(1, tc+1):
# print(solve(t))
# print("case: %d"%t,end = " ")
solve(t)
#'''
############################################################################
# FAST-IO
# PyRIVAL
############################################################################
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
############################################################################
''' # '''
## DRIVER # PROGRAM ########################################################
if __name__ == "__main__":
main()
|
Title: Xor-tree
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Iahub is very proud of his recent discovery, propagating trees. Right now, he invented a new tree, called xor-tree. After this new revolutionary discovery, he invented a game for kids which uses xor-trees.
The game is played on a tree having *n* nodes, numbered from 1 to *n*. Each node *i* has an initial value *init**i*, which is either 0 or 1. The root of the tree is node 1.
One can perform several (possibly, zero) operations on the tree during the game. The only available type of operation is to pick a node *x*. Right after someone has picked node *x*, the value of node *x* flips, the values of sons of *x* remain the same, the values of sons of sons of *x* flips, the values of sons of sons of sons of *x* remain the same and so on.
The goal of the game is to get each node *i* to have value *goal**i*, which can also be only 0 or 1. You need to reach the goal of the game by using minimum number of operations.
Input Specification:
The first line contains an integer *n* (1<=≤<=*n*<=≤<=105). Each of the next *n*<=-<=1 lines contains two integers *u**i* and *v**i* (1<=≤<=*u**i*,<=*v**i*<=≤<=*n*; *u**i*<=≠<=*v**i*) meaning there is an edge between nodes *u**i* and *v**i*.
The next line contains *n* integer numbers, the *i*-th of them corresponds to *init**i* (*init**i* is either 0 or 1). The following line also contains *n* integer numbers, the *i*-th number corresponds to *goal**i* (*goal**i* is either 0 or 1).
Output Specification:
In the first line output an integer number *cnt*, representing the minimal number of operations you perform. Each of the next *cnt* lines should contain an integer *x**i*, representing that you pick a node *x**i*.
Demo Input:
['10\n2 1\n3 1\n4 2\n5 1\n6 2\n7 5\n8 6\n9 8\n10 5\n1 0 1 1 0 1 0 1 0 1\n1 0 1 0 0 1 1 1 0 1\n']
Demo Output:
['2\n4\n7\n']
Note:
none
|
```python
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
############################################################################
# ACTUAL CODE
############################################################################
from collections import deque
def solve(t):
n = int(input().strip())
# print(n,end=" ")
#take graph as input
g = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int,input().strip().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
initial = list(map(int,input().split()))
final = list(map(int,input().split()))
q = deque()
# (node,level%2,flip(levl%2),flip(lev%2==`))
q.append((0,0,0,0))
visited = [0 for i in range(n)]
ans = 0
all_nodes = []
#now we don bfs
while q:
(node,level,flip0,flip1) = q.popleft()
visited[node]=1
node_val = initial[node]
if((level%2==0 and flip0==1) or (level%2==1 and flip1==1)): node_val = node_val^1
if(final[node]!=node_val):
ans+=1
all_nodes.append(node+1)
if(level%2==0):flip0 = flip0^1
else: flip1 = flip1^1
for u in g[node]:
if(visited[u]==0):q.append((u,level+1,flip0,flip1))
print(ans)
for nodes in all_nodes:
print(nodes)
def main():
# tc = int(input().strip())
tc = 1
for t in range(1, tc+1):
# print(solve(t))
# print("case: %d"%t,end = " ")
solve(t)
#'''
############################################################################
# FAST-IO
# PyRIVAL
############################################################################
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
############################################################################
''' # '''
## DRIVER # PROGRAM ########################################################
if __name__ == "__main__":
main()
```
| 3
|
|
43
|
B
|
Letter
|
PROGRAMMING
| 1,100
|
[
"implementation",
"strings"
] |
B. Letter
|
2
|
256
|
Vasya decided to write an anonymous letter cutting the letters out of a newspaper heading. He knows heading *s*1 and text *s*2 that he wants to send. Vasya can use every single heading letter no more than once. Vasya doesn't have to cut the spaces out of the heading — he just leaves some blank space to mark them. Help him; find out if he will manage to compose the needed text.
|
The first line contains a newspaper heading *s*1. The second line contains the letter text *s*2. *s*1 и *s*2 are non-empty lines consisting of spaces, uppercase and lowercase Latin letters, whose lengths do not exceed 200 symbols. The uppercase and lowercase letters should be differentiated. Vasya does not cut spaces out of the heading.
|
If Vasya can write the given anonymous letter, print YES, otherwise print NO
|
[
"Instead of dogging Your footsteps it disappears but you dont notice anything\nwhere is your dog\n",
"Instead of dogging Your footsteps it disappears but you dont notice anything\nYour dog is upstears\n",
"Instead of dogging your footsteps it disappears but you dont notice anything\nYour dog is upstears\n",
"abcdefg hijk\nk j i h g f e d c b a\n"
] |
[
"NO\n",
"YES\n",
"NO\n",
"YES\n"
] |
none
| 1,000
|
[
{
"input": "Instead of dogging Your footsteps it disappears but you dont notice anything\nwhere is your dog",
"output": "NO"
},
{
"input": "Instead of dogging Your footsteps it disappears but you dont notice anything\nYour dog is upstears",
"output": "YES"
},
{
"input": "Instead of dogging your footsteps it disappears but you dont notice anything\nYour dog is upstears",
"output": "NO"
},
{
"input": "abcdefg hijk\nk j i h g f e d c b a",
"output": "YES"
},
{
"input": "HpOKgo\neAtAVB",
"output": "NO"
},
{
"input": "GRZGc\nLPzD",
"output": "NO"
},
{
"input": "GtPXu\nd",
"output": "NO"
},
{
"input": "FVF\nr ",
"output": "NO"
},
{
"input": "HpOKgo\nogK",
"output": "YES"
},
{
"input": "GRZGc\nZG",
"output": "YES"
},
{
"input": "HpOKgoueAtAVBdGffvQheJDejNDHhhwyKJisugiRAH OseK yUwqPPNuThUxTfthqIUeb wS jChGOdFDarNrKRT MlwKecxWNoKEeD BbiHAruE XMlvKYVsJGPP\nAHN XvoaNwV AVBKwKjr u U K wKE D K Jy KiHsR h d W Js IHyMPK Br iSqe E fDA g H",
"output": "YES"
},
{
"input": "GRZGcsLPzDrCSXhhNTaibJqVphhjbcPoZhCDUlzAbDnRWjHvxLKtpGiFWiGbfeDxBwCrdJmJGCGv GebAOinUsFrlqKTILOmxrFjSpEoVGoTdSSstJWVgMLKMPettxHASaQZNdOIObcTxtF qTHWBdNIKwj\nWqrxze Ji x q aT GllLrRV jMpGiMDTwwS JDsPGpAZKACmsFCOS CD Sj bCDgKF jJxa RddtLFAi VGLHH SecObzG q hPF ",
"output": "YES"
},
{
"input": "GtPXuwdAxNhODQbjRslDDKciOALJrCifTjDQurQEBeFUUSZWwCZQPdYwZkYbrduMijFjgodAOrKIuUKwSXageZuOWMIhAMexyLRzFuzuXqBDTEaWMzVdbzhxDGSJC SsIYuYILwpiwwcObEHWpFvHeBkWYNitqYrxqgHReHcKnHbtjcWZuaxPBVPb\nTQIKyqFaewOkY lZUOOuxEw EwuKcArxRQGFYkvVWIAe SuanPeHuDjquurJu aSxwgOSw jYMwjxItNUUArQjO BIujAhSwttLWp",
"output": "YES"
},
{
"input": "FVFSr unvtXbpKWF vPaAgNaoTqklzVqiGYcUcBIcattzBrRuNSnKUtmdGKbjcE\nUzrU K an GFGR Wc zt iBa P c T K v p V In b B c",
"output": "YES"
},
{
"input": "lSwjnYLYtDNIZjxHiTawdh ntSzggZogcIZTuiTMWVgwyloMtEhqkrOxgIcFvwvsboXUPILPIymFAEXnhApewJXJNtFyZ\nAoxe jWZ u yImg o AZ FNI w lpj tNhT g y ZYcb rc J w Dlv",
"output": "YES"
},
{
"input": "kvlekcdJqODUKdsJlXkRaileTmdGwUHWWgvgUokQxRzzbpFnswvNKiDnjfOFGvFcnaaiRnBGQmqoPxDHepgYasLhzjDgmvaFfVNEcSPVQCJKAbSyTGpXsAjIHr\nGjzUllNaGGKXUdYmDFpqFAKIwvTpjmqnyswWRTnxlBnavAGvavxJemrjvRJc",
"output": "YES"
},
{
"input": "kWbvhgvvoYOhwXmgTwOSCDXrtFHhqwvMlCvsuuAUXMmWaYXiqHplFZZemhgkTuvsUtIaUxtyYauBIpjdbyYxjZ ZkaBPzwqPfqF kCqGRmXvWuabnQognnkvdNDtRUsSUvSzgBuxCMBWJifbxWegsknp\nBsH bWHJD n Ca T xq PRCv tatn Wjy sm I q s WCjFqdWe t W XUs Do eb Pfh ii hTbF O Fll",
"output": "YES"
},
{
"input": "OTmLdkMhmDEOMQMiW ZpzEIjyElHFrNCfFQDp SZyoZaEIUIpyCHfwOUqiSkKtFHggrTBGkqfOxkChPztmPrsHoxVwAdrxbZLKxPXHlMnrkgMgiaHFopiFFiUEtKwCjpJtwdwkbJCgA bxeDIscFdmHQJLAMNhWlrZisQrHQpvbALWTwpf jnx\nDbZwrQbydCdkJMCrftiwtPFfpMiwwrfIrKidEChKECxQUBVUEfFirbGWiLkFQkdJiFtkrtkbIAEXCEDkwLpK",
"output": "YES"
},
{
"input": "NwcGaIeSkOva\naIa",
"output": "YES"
},
{
"input": "gSrAcVYgAdbdayzbKGhIzLDjyznLRIJH KyvilAaEddmgkBPCNzpmPNeGEbmmpAyHvUSoPvnaORrPUuafpReEGoDOQsAYnUHYfBqhdcopQfxJuGXgKnbdVMQNhJYkyjiJDKlShqBTtnnDQQzEijOMcYRGMgPGVhfIReYennKBLwDTVvcHMIHMgVpJkvzTrezxqS\nHJerIVvRyfrPgAQMTI AqGNO mQDfDwQHKgeeYmuRmozKHILvehMPOJNMRtPTAfvKvsoGKi xHEeKqDAYmQJPUXRJbIbHrgVOMGMTdvYiLui",
"output": "YES"
},
{
"input": "ReB hksbHqQXxUgpvoNK bFqmNVCEiOyKdKcAJQRkpeohpfuqZabvrLfmpZOMcfyFBJGZwVMxiUPP pbZZtJjxhEwvrAba\nJTCpQnIViIGIdQtLnmkVzmcbBZR CoxAdTtWSYpbOglDFifqIVQ vfGKGtLpxpJHiHSWCMeRcrVOXBGBhoEnVhNTPWGTOErNtSvokcGdgZXbgTEtISUyTwaXUEIlJMmutsdCbiyrPZPJyRdOjnSuAGttLy",
"output": "NO"
},
{
"input": "hrLzRegCuDGxTrhDgVvM KowwyYuXGzIpcXdSMgeQVfVOtJZdkhNYSegwFWWoPqcZoeapbQnyCtojgkcyezUNHGGIZrhzsKrvvcrtokIdcnqXXkCNKjrOjrnEAKBNxyDdiMVeyLvXxUYMZQRFdlcdlcxzKTeYzBlmpNiwWbNAAhWkMoGpRxkCuyqkzXdKWwGH\nJESKDOfnFdxPvUOCkrgSBEPQHJtJHzuNGstRbTCcchRWJvCcveSEAtwtOmZZiW",
"output": "NO"
},
{
"input": "yDBxCtUygQwWqONxQCcuAvVCkMGlqgC zvkfEkwqbhMCQxnkwQIUhucCbVUyOBUcXvTNEGriTBwMDMfdsPZgWRgIUDqM\neptVnORTTyixxmWIBpSTEwOXqGZllBgSxPenYCDlFwckJlWsoVwWLAIbPOmFqcKcTcoQqahetl KLfVSyaLVebzsGwPSVbtQAeUdZAaJtfxlCEvvaRhLlVvRJhKat IaB awdqcDlrrhTbRxjEbzGwcdmdavkhcjHjzmwbxAgw",
"output": "NO"
},
{
"input": "jlMwnnotSdlQMluKWkJwAeCetcqbIEnKeNyLWoKCGONDRBQOjbkGpUvDlmSFUJ bWhohqmmIUWTlDsvelUArAcZJBipMDwUvRfBsYzMdQnPDPAuBaeJmAxVKwUMJrwMDxNtlrtAowVWqWiwFGtmquZAcrpFsLHCrvMSMMlvQUqypAihQWrFMNoaqfs IBg\nNzeWQ bafrmDsYlpNHSGTBBgPl WIcuNhyNaNOEFvL",
"output": "NO"
},
{
"input": "zyWvXBcUZqGqjHwZHQryBtFliLYnweXAoMKNpLaunaOlzaauWmLtywsEvWPiwxJapocAFRMjrqWJXYqfKEbBKnzLO\npsbi bsXpSeJaCkIuPWfSRADXdIClxcDCowwJzGCDTyAl",
"output": "NO"
},
{
"input": "kKhuIwRPLCwPFfcnsyCfBdnsraGeOCcLTfXuGjqFSGPSAeDZJSS bXKFanNqWjpFnvRpWxHJspvisDlADJBioxXNbVoXeUedoPcNEpUyEeYxdJXhGzFAmpAiHotSVwbZQsuWjIVhVaEGgqbZHIoDpiEmjTtFylCwCkWWzUOoUfOHxEZvDwNpXhBWamHn\nK VpJjGhNbwCRhcfmNGVjewBFpEmPlIKeTuWiukDtEWpjgqciqglkyNfWrBLbGAKvlNWxaUelJmSlSoakSpRzePvJsshOsTYrMPXdxKpaShjyVIXGhRIAdtiGpNwtiRmGTBZhkJqIMdxMHX RMxCMYcWjcjhtCHyFnCvjjezGbkRDRiVxkbh",
"output": "NO"
},
{
"input": "AXssNpFKyQmJcBdBdfkhhMUzfqJVgcLBddkwtnFSzSRUCjiDcdtmkzIGkCKSxWUEGhmHmciktJyGMkgCductyHx\nI nYhmJfPnvoKUiXYUBIPIcxNYTtvwPUoXERZvY ahlDpQFNMmVZqEBiYqYlHNqcpSCmhFczBlOAhsYFeqMGfqL EJsDNOgwoJfBzqijKOFcYQ",
"output": "NO"
},
{
"input": "lkhrzDZmkdbjzYKPNMRkiwCFoZsMzBQMnxxdKKVJezSBjnLjPpUYtabcPTIaDJeDEobbWHdKOdVfMQwDXzDDcSrwVenDEYpMqfiOQ xSsqApWnAMoyhQXCKFzHvvzvUvkWwmwZrvZz\nsUzGspYpRFsHRbRgTQuCBgnFgPkisTUfFNwyEEWWRiweWWgjRkVQxgTwxOzdsOwfrGIH O gCXpzvHzfItuEHaihmugEyymSJIogYwX qAwcwIItidfnzZDhZgQHi eRjMAeVkJHceDZuJkmxGowOsmcGYYvk Ajtgi TxwihvjLViNZjvscTWvsaQUelTSivLShhEl",
"output": "NO"
},
{
"input": "BRsVjyNhrqRHVwrJzuzRigEhdpbDmaACSPfed\nlWqKTjlrqOCUbgBBZdZDGCeQJDXawPnnDkQdZDgwrEQk",
"output": "NO"
},
{
"input": "KRmINuyBYPwiTsdlyiNVuylToysJKmOpcLovAtwGPqrgFJQNAYvuAiyQRkeFMECVZvkDEmTauXlyjAaYRnTJXORMZRnTakBaUzSelMilejySDIZjQjzcOIrwXdvDvpeRIkoBgreyFXIyyIZutjiEBtwrmzQtPVUhvvdEtDMbXjBpoPVjGdM EXTAK JbCnw\nXZZqlJvzKKtvdNlzFPDTYxidqlsgufVzyEmO FZuLQ vVQsJESNviUCovCK NwwlbxsmPtOJNmAonCqrOZ bZ LVKAsQGmoLnYjeekvEIECFk",
"output": "NO"
}
] | 1,578,949,023
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 30
| 218
| 307,200
|
a = ''.join(input().split())
b = ''.join(input().split())
c = set(list(b))
q = True
for _ in c:
if b.count(_) > a.count(_):
q = False
if q:
print('YES')
else:
print('NO')
|
Title: Letter
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Vasya decided to write an anonymous letter cutting the letters out of a newspaper heading. He knows heading *s*1 and text *s*2 that he wants to send. Vasya can use every single heading letter no more than once. Vasya doesn't have to cut the spaces out of the heading — he just leaves some blank space to mark them. Help him; find out if he will manage to compose the needed text.
Input Specification:
The first line contains a newspaper heading *s*1. The second line contains the letter text *s*2. *s*1 и *s*2 are non-empty lines consisting of spaces, uppercase and lowercase Latin letters, whose lengths do not exceed 200 symbols. The uppercase and lowercase letters should be differentiated. Vasya does not cut spaces out of the heading.
Output Specification:
If Vasya can write the given anonymous letter, print YES, otherwise print NO
Demo Input:
['Instead of dogging Your footsteps it disappears but you dont notice anything\nwhere is your dog\n', 'Instead of dogging Your footsteps it disappears but you dont notice anything\nYour dog is upstears\n', 'Instead of dogging your footsteps it disappears but you dont notice anything\nYour dog is upstears\n', 'abcdefg hijk\nk j i h g f e d c b a\n']
Demo Output:
['NO\n', 'YES\n', 'NO\n', 'YES\n']
Note:
none
|
```python
a = ''.join(input().split())
b = ''.join(input().split())
c = set(list(b))
q = True
for _ in c:
if b.count(_) > a.count(_):
q = False
if q:
print('YES')
else:
print('NO')
```
| 3.944928
|
893
|
A
|
Chess For Three
|
PROGRAMMING
| 900
|
[
"implementation"
] | null | null |
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
- Alex and Bob play the first game, and Carl is spectating; - When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played *n* games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
|
The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the number of games Alex, Bob and Carl played.
Then *n* lines follow, describing the game log. *i*-th line contains one integer *a**i* (1<=≤<=*a**i*<=≤<=3) which is equal to 1 if Alex won *i*-th game, to 2 if Bob won *i*-th game and 3 if Carl won *i*-th game.
|
Print YES if the situation described in the log was possible. Otherwise print NO.
|
[
"3\n1\n1\n2\n",
"2\n1\n2\n"
] |
[
"YES\n",
"NO\n"
] |
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob; 1. Alex wins, Bob replaces Carl; 1. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
| 0
|
[
{
"input": "3\n1\n1\n2",
"output": "YES"
},
{
"input": "2\n1\n2",
"output": "NO"
},
{
"input": "100\n2\n3\n1\n2\n3\n3\n3\n1\n1\n1\n1\n3\n3\n3\n3\n1\n2\n3\n3\n3\n3\n3\n3\n3\n1\n2\n2\n2\n3\n1\n1\n3\n3\n3\n3\n3\n3\n3\n3\n1\n2\n3\n3\n3\n1\n1\n1\n1\n3\n3\n3\n3\n1\n2\n3\n1\n2\n2\n2\n3\n3\n2\n1\n3\n3\n1\n2\n3\n1\n1\n1\n2\n2\n2\n3\n1\n1\n1\n1\n1\n1\n3\n2\n2\n2\n2\n2\n2\n3\n1\n2\n2\n2\n2\n2\n3\n3\n2\n1\n1",
"output": "YES"
},
{
"input": "99\n1\n3\n2\n2\n3\n1\n1\n3\n3\n3\n3\n3\n3\n1\n1\n3\n3\n3\n3\n1\n1\n3\n2\n1\n1\n1\n1\n1\n1\n1\n3\n2\n2\n2\n1\n3\n3\n1\n1\n3\n2\n1\n3\n3\n1\n2\n3\n3\n3\n1\n2\n2\n2\n3\n3\n3\n3\n3\n3\n2\n2\n2\n2\n3\n3\n3\n1\n1\n3\n2\n1\n1\n2\n2\n2\n3\n3\n2\n1\n1\n2\n2\n1\n3\n2\n1\n1\n2\n3\n3\n3\n3\n2\n2\n2\n2\n2\n1\n3",
"output": "YES"
},
{
"input": "100\n2\n2\n1\n3\n1\n3\n3\n1\n1\n3\n1\n1\n3\n2\n1\n3\n1\n1\n3\n3\n2\n2\n3\n1\n1\n2\n3\n2\n2\n3\n1\n1\n2\n3\n2\n1\n2\n2\n3\n3\n1\n1\n3\n1\n2\n1\n3\n1\n1\n3\n2\n2\n2\n1\n1\n1\n3\n1\n3\n2\n1\n2\n2\n2\n3\n3\n2\n1\n1\n3\n3\n2\n1\n2\n1\n1\n3\n1\n2\n3\n2\n3\n3\n3\n2\n2\n1\n3\n1\n2\n3\n1\n2\n3\n3\n1\n2\n1\n3\n1",
"output": "NO"
},
{
"input": "10\n2\n3\n3\n3\n3\n2\n2\n2\n3\n2",
"output": "NO"
},
{
"input": "100\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1",
"output": "YES"
},
{
"input": "1\n3",
"output": "NO"
},
{
"input": "1\n2",
"output": "YES"
},
{
"input": "42\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n1",
"output": "YES"
},
{
"input": "4\n2\n3\n3\n3",
"output": "YES"
},
{
"input": "3\n1\n2\n3",
"output": "NO"
},
{
"input": "5\n1\n1\n1\n1\n3",
"output": "NO"
},
{
"input": "5\n2\n3\n3\n3\n3",
"output": "YES"
},
{
"input": "2\n3\n3",
"output": "NO"
},
{
"input": "4\n1\n2\n2\n1",
"output": "NO"
},
{
"input": "3\n2\n2\n3",
"output": "NO"
},
{
"input": "5\n2\n3\n3\n1\n1",
"output": "NO"
},
{
"input": "3\n3\n1\n3",
"output": "NO"
},
{
"input": "3\n3\n3\n1",
"output": "NO"
},
{
"input": "2\n2\n1",
"output": "NO"
},
{
"input": "3\n1\n1\n3",
"output": "NO"
},
{
"input": "6\n2\n2\n2\n3\n1\n3",
"output": "NO"
},
{
"input": "2\n3\n1",
"output": "NO"
},
{
"input": "2\n3\n2",
"output": "NO"
},
{
"input": "2\n1\n3",
"output": "YES"
},
{
"input": "3\n1\n3\n1",
"output": "NO"
},
{
"input": "5\n1\n1\n2\n2\n3",
"output": "NO"
},
{
"input": "3\n2\n1\n1",
"output": "NO"
},
{
"input": "2\n2\n2",
"output": "YES"
},
{
"input": "3\n2\n2\n1",
"output": "YES"
},
{
"input": "5\n2\n2\n2\n2\n2",
"output": "YES"
},
{
"input": "8\n1\n1\n1\n1\n1\n1\n1\n1",
"output": "YES"
},
{
"input": "3\n3\n2\n2",
"output": "NO"
},
{
"input": "3\n3\n2\n3",
"output": "NO"
},
{
"input": "7\n2\n2\n2\n2\n2\n2\n2",
"output": "YES"
},
{
"input": "3\n2\n2\n2",
"output": "YES"
}
] | 1,602,832,708
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 37
| 140
| 0
|
p=3;a=[1,2,3];k=0
for i in range(int(input())):
x=int(input())
if x==p:
k=1
else:
p=[i for i in a if i not in [x,p]][0]
print('YES' if k==0 else 'NO')
|
Title: Chess For Three
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
- Alex and Bob play the first game, and Carl is spectating; - When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played *n* games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input Specification:
The first line contains one integer *n* (1<=≤<=*n*<=≤<=100) — the number of games Alex, Bob and Carl played.
Then *n* lines follow, describing the game log. *i*-th line contains one integer *a**i* (1<=≤<=*a**i*<=≤<=3) which is equal to 1 if Alex won *i*-th game, to 2 if Bob won *i*-th game and 3 if Carl won *i*-th game.
Output Specification:
Print YES if the situation described in the log was possible. Otherwise print NO.
Demo Input:
['3\n1\n1\n2\n', '2\n1\n2\n']
Demo Output:
['YES\n', 'NO\n']
Note:
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob; 1. Alex wins, Bob replaces Carl; 1. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
|
```python
p=3;a=[1,2,3];k=0
for i in range(int(input())):
x=int(input())
if x==p:
k=1
else:
p=[i for i in a if i not in [x,p]][0]
print('YES' if k==0 else 'NO')
```
| 3
|
|
707
|
A
|
Brain's Photos
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Small, but very brave, mouse Brain was not accepted to summer school of young villains. He was upset and decided to postpone his plans of taking over the world, but to become a photographer instead.
As you may know, the coolest photos are on the film (because you can specify the hashtag #film for such).
Brain took a lot of colourful pictures on colored and black-and-white film. Then he developed and translated it into a digital form. But now, color and black-and-white photos are in one folder, and to sort them, one needs to spend more than one hour!
As soon as Brain is a photographer not programmer now, he asks you to help him determine for a single photo whether it is colored or black-and-white.
Photo can be represented as a matrix sized *n*<=×<=*m*, and each element of the matrix stores a symbol indicating corresponding pixel color. There are only 6 colors:
- 'C' (cyan)- 'M' (magenta)- 'Y' (yellow)- 'W' (white)- 'G' (grey)- 'B' (black)
The photo is considered black-and-white if it has only white, black and grey pixels in it. If there are any of cyan, magenta or yellow pixels in the photo then it is considered colored.
|
The first line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of photo pixel matrix rows and columns respectively.
Then *n* lines describing matrix rows follow. Each of them contains *m* space-separated characters describing colors of pixels in a row. Each character in the line is one of the 'C', 'M', 'Y', 'W', 'G' or 'B'.
|
Print the "#Black&White" (without quotes), if the photo is black-and-white and "#Color" (without quotes), if it is colored, in the only line.
|
[
"2 2\nC M\nY Y\n",
"3 2\nW W\nW W\nB B\n",
"1 1\nW\n"
] |
[
"#Color",
"#Black&White",
"#Black&White"
] |
none
| 500
|
[
{
"input": "2 2\nC M\nY Y",
"output": "#Color"
},
{
"input": "3 2\nW W\nW W\nB B",
"output": "#Black&White"
},
{
"input": "1 1\nW",
"output": "#Black&White"
},
{
"input": "2 3\nW W W\nB G Y",
"output": "#Color"
},
{
"input": "1 1\nW",
"output": "#Black&White"
},
{
"input": "5 5\nW G B Y M\nG B Y M C\nB Y M C W\nY M C W G\nM C W G B",
"output": "#Color"
},
{
"input": "1 6\nC M Y W G B",
"output": "#Color"
},
{
"input": "1 3\nW G B",
"output": "#Black&White"
},
{
"input": "1 1\nW",
"output": "#Black&White"
},
{
"input": "5 5\nW G B W G\nG B W G B\nB W G B W\nW G B W G\nG B W G B",
"output": "#Black&White"
},
{
"input": "2 3\nW W W\nB G C",
"output": "#Color"
},
{
"input": "2 3\nW W W\nB G M",
"output": "#Color"
},
{
"input": "3 3\nC B W\nB Y M\nB B W",
"output": "#Color"
},
{
"input": "1 3\nW C W",
"output": "#Color"
},
{
"input": "3 3\nB W B\nB C W\nB W W",
"output": "#Color"
},
{
"input": "1 2\nW Y",
"output": "#Color"
},
{
"input": "1 1\nG",
"output": "#Black&White"
},
{
"input": "1 3\nB G W",
"output": "#Black&White"
},
{
"input": "2 2\nW W\nB C",
"output": "#Color"
},
{
"input": "1 1\nM",
"output": "#Color"
},
{
"input": "1 2\nW C",
"output": "#Color"
},
{
"input": "2 3\nW W M\nW W M",
"output": "#Color"
},
{
"input": "3 2\nW W\nW W\nB C",
"output": "#Color"
},
{
"input": "2 3\nW W C\nW W W",
"output": "#Color"
},
{
"input": "1 3\nG G G",
"output": "#Black&White"
},
{
"input": "1 1\nC",
"output": "#Color"
},
{
"input": "1 2\nC W",
"output": "#Color"
},
{
"input": "1 3\nW W C",
"output": "#Color"
},
{
"input": "2 2\nW B\nB G",
"output": "#Black&White"
},
{
"input": "2 2\nB B\nY Y",
"output": "#Color"
},
{
"input": "2 2\nG G\nC C",
"output": "#Color"
},
{
"input": "1 2\nB C",
"output": "#Color"
},
{
"input": "1 4\nG G G C",
"output": "#Color"
},
{
"input": "1 1\nB",
"output": "#Black&White"
},
{
"input": "2 1\nY\nB",
"output": "#Color"
}
] | 1,665,816,377
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 50
| 46
| 0
|
n, m = list( map(int, input().split()) )
lst = []
for _ in range(n):
inp = input().split()
lst.append(inp)
for i in range(n):
brk = False
for j in range(m):
ch = lst[i][j]
if ch == 'C' or ch == 'M' or ch == 'Y':
print('#Color')
brk = True
break
if brk:
break
else:
print('#Black&White')
|
Title: Brain's Photos
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Small, but very brave, mouse Brain was not accepted to summer school of young villains. He was upset and decided to postpone his plans of taking over the world, but to become a photographer instead.
As you may know, the coolest photos are on the film (because you can specify the hashtag #film for such).
Brain took a lot of colourful pictures on colored and black-and-white film. Then he developed and translated it into a digital form. But now, color and black-and-white photos are in one folder, and to sort them, one needs to spend more than one hour!
As soon as Brain is a photographer not programmer now, he asks you to help him determine for a single photo whether it is colored or black-and-white.
Photo can be represented as a matrix sized *n*<=×<=*m*, and each element of the matrix stores a symbol indicating corresponding pixel color. There are only 6 colors:
- 'C' (cyan)- 'M' (magenta)- 'Y' (yellow)- 'W' (white)- 'G' (grey)- 'B' (black)
The photo is considered black-and-white if it has only white, black and grey pixels in it. If there are any of cyan, magenta or yellow pixels in the photo then it is considered colored.
Input Specification:
The first line of the input contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of photo pixel matrix rows and columns respectively.
Then *n* lines describing matrix rows follow. Each of them contains *m* space-separated characters describing colors of pixels in a row. Each character in the line is one of the 'C', 'M', 'Y', 'W', 'G' or 'B'.
Output Specification:
Print the "#Black&White" (without quotes), if the photo is black-and-white and "#Color" (without quotes), if it is colored, in the only line.
Demo Input:
['2 2\nC M\nY Y\n', '3 2\nW W\nW W\nB B\n', '1 1\nW\n']
Demo Output:
['#Color', '#Black&White', '#Black&White']
Note:
none
|
```python
n, m = list( map(int, input().split()) )
lst = []
for _ in range(n):
inp = input().split()
lst.append(inp)
for i in range(n):
brk = False
for j in range(m):
ch = lst[i][j]
if ch == 'C' or ch == 'M' or ch == 'Y':
print('#Color')
brk = True
break
if brk:
break
else:
print('#Black&White')
```
| 3
|
|
924
|
C
|
Riverside Curio
|
PROGRAMMING
| 1,700
|
[
"data structures",
"dp",
"greedy"
] | null | null |
Arkady decides to observe a river for *n* consecutive days. The river's water level on each day is equal to some real value.
Arkady goes to the riverside each day and makes a mark on the side of the channel at the height of the water level, but if it coincides with a mark made before, no new mark is created. The water does not wash the marks away. Arkady writes down the number of marks strictly above the water level each day, on the *i*-th day this value is equal to *m**i*.
Define *d**i* as the number of marks strictly under the water level on the *i*-th day. You are to find out the minimum possible sum of *d**i* over all days. There are no marks on the channel before the first day.
|
The first line contains a single positive integer *n* (1<=≤<=*n*<=≤<=105) — the number of days.
The second line contains *n* space-separated integers *m*1,<=*m*2,<=...,<=*m**n* (0<=≤<=*m**i*<=<<=*i*) — the number of marks strictly above the water on each day.
|
Output one single integer — the minimum possible sum of the number of marks strictly below the water level among all days.
|
[
"6\n0 1 0 3 0 2\n",
"5\n0 1 2 1 2\n",
"5\n0 1 1 2 2\n"
] |
[
"6\n",
"1\n",
"0\n"
] |
In the first example, the following figure shows an optimal case.
Note that on day 3, a new mark should be created because if not, there cannot be 3 marks above water on day 4. The total number of marks underwater is 0 + 0 + 2 + 0 + 3 + 1 = 6.
In the second example, the following figure shows an optimal case.
| 1,250
|
[
{
"input": "6\n0 1 0 3 0 2",
"output": "6"
},
{
"input": "5\n0 1 2 1 2",
"output": "1"
},
{
"input": "5\n0 1 1 2 2",
"output": "0"
},
{
"input": "1\n0",
"output": "0"
},
{
"input": "100\n0 1 2 2 3 0 1 5 6 6 0 0 8 7 1 9 9 4 10 11 12 2 12 12 12 12 9 13 14 8 15 15 15 19 15 7 17 17 18 19 9 10 21 0 22 9 2 24 24 4 24 7 25 14 5 8 28 29 30 31 31 31 0 3 15 31 8 33 6 35 35 35 36 36 37 37 38 39 28 0 2 23 41 9 9 0 6 25 41 41 12 42 43 43 36 44 51 45 43 4",
"output": "761"
},
{
"input": "2\n0 1",
"output": "0"
},
{
"input": "2\n0 0",
"output": "0"
},
{
"input": "3\n0 1 0",
"output": "1"
},
{
"input": "3\n0 0 1",
"output": "0"
},
{
"input": "3\n0 1 1",
"output": "0"
},
{
"input": "3\n0 1 2",
"output": "0"
},
{
"input": "3\n0 0 0",
"output": "0"
},
{
"input": "4\n0 0 1 2",
"output": "0"
},
{
"input": "4\n0 1 0 3",
"output": "2"
},
{
"input": "4\n0 1 1 0",
"output": "1"
},
{
"input": "4\n0 0 1 1",
"output": "0"
},
{
"input": "5\n0 1 0 3 1",
"output": "4"
},
{
"input": "6\n0 0 0 2 0 1",
"output": "4"
},
{
"input": "7\n0 1 1 3 0 0 6",
"output": "10"
},
{
"input": "8\n0 0 2 0 3 0 3 2",
"output": "7"
},
{
"input": "9\n0 1 0 1 1 4 0 4 8",
"output": "17"
},
{
"input": "10\n0 1 2 0 4 5 3 6 0 5",
"output": "12"
},
{
"input": "10\n0 0 2 2 3 2 3 3 1 3",
"output": "4"
}
] | 1,602,603,753
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 42
| 295
| 7,372,800
|
#include <GOD>
#Pato Boride Azin Khone , Vase Hamine Delet Khune
import sys
import math
n = int(input())
arr = [int(i) for i in input().split()]
tt = [0]*n
for i in range(n):
if(i != 0):
tt[i]=max(tt[i-1] , arr[i]+1)
else:
tt[i]=arr[i]+1
ss = 0
for i in range(n-1 , -1 , -1):
if(i != n-1):
tt[i]=max(tt[i+1]-1 , tt[i])
ss+=(tt[i]-arr[i]-1)
else:
ss+=(tt[i]-arr[i]-1)
print(ss)
|
Title: Riverside Curio
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Arkady decides to observe a river for *n* consecutive days. The river's water level on each day is equal to some real value.
Arkady goes to the riverside each day and makes a mark on the side of the channel at the height of the water level, but if it coincides with a mark made before, no new mark is created. The water does not wash the marks away. Arkady writes down the number of marks strictly above the water level each day, on the *i*-th day this value is equal to *m**i*.
Define *d**i* as the number of marks strictly under the water level on the *i*-th day. You are to find out the minimum possible sum of *d**i* over all days. There are no marks on the channel before the first day.
Input Specification:
The first line contains a single positive integer *n* (1<=≤<=*n*<=≤<=105) — the number of days.
The second line contains *n* space-separated integers *m*1,<=*m*2,<=...,<=*m**n* (0<=≤<=*m**i*<=<<=*i*) — the number of marks strictly above the water on each day.
Output Specification:
Output one single integer — the minimum possible sum of the number of marks strictly below the water level among all days.
Demo Input:
['6\n0 1 0 3 0 2\n', '5\n0 1 2 1 2\n', '5\n0 1 1 2 2\n']
Demo Output:
['6\n', '1\n', '0\n']
Note:
In the first example, the following figure shows an optimal case.
Note that on day 3, a new mark should be created because if not, there cannot be 3 marks above water on day 4. The total number of marks underwater is 0 + 0 + 2 + 0 + 3 + 1 = 6.
In the second example, the following figure shows an optimal case.
|
```python
#include <GOD>
#Pato Boride Azin Khone , Vase Hamine Delet Khune
import sys
import math
n = int(input())
arr = [int(i) for i in input().split()]
tt = [0]*n
for i in range(n):
if(i != 0):
tt[i]=max(tt[i-1] , arr[i]+1)
else:
tt[i]=arr[i]+1
ss = 0
for i in range(n-1 , -1 , -1):
if(i != n-1):
tt[i]=max(tt[i+1]-1 , tt[i])
ss+=(tt[i]-arr[i]-1)
else:
ss+=(tt[i]-arr[i]-1)
print(ss)
```
| 3
|
|
10
|
D
|
LCIS
|
PROGRAMMING
| 2,800
|
[
"dp"
] |
D. LCIS
|
1
|
256
|
This problem differs from one which was on the online contest.
The sequence *a*1,<=*a*2,<=...,<=*a**n* is called increasing, if *a**i*<=<<=*a**i*<=+<=1 for *i*<=<<=*n*.
The sequence *s*1,<=*s*2,<=...,<=*s**k* is called the subsequence of the sequence *a*1,<=*a*2,<=...,<=*a**n*, if there exist such a set of indexes 1<=≤<=*i*1<=<<=*i*2<=<<=...<=<<=*i**k*<=≤<=*n* that *a**i**j*<==<=*s**j*. In other words, the sequence *s* can be derived from the sequence *a* by crossing out some elements.
You are given two sequences of integer numbers. You are to find their longest common increasing subsequence, i.e. an increasing sequence of maximum length that is the subsequence of both sequences.
|
The first line contains an integer *n* (1<=≤<=*n*<=≤<=500) — the length of the first sequence. The second line contains *n* space-separated integers from the range [0,<=109] — elements of the first sequence. The third line contains an integer *m* (1<=≤<=*m*<=≤<=500) — the length of the second sequence. The fourth line contains *m* space-separated integers from the range [0,<=109] — elements of the second sequence.
|
In the first line output *k* — the length of the longest common increasing subsequence. In the second line output the subsequence itself. Separate the elements with a space. If there are several solutions, output any.
|
[
"7\n2 3 1 6 5 4 6\n4\n1 3 5 6\n",
"5\n1 2 0 2 1\n3\n1 0 1\n"
] |
[
"3\n3 5 6 \n",
"2\n0 1 \n"
] |
none
| 0
|
[
{
"input": "7\n2 3 1 6 5 4 6\n4\n1 3 5 6",
"output": "3\n3 5 6 "
},
{
"input": "5\n1 2 0 2 1\n3\n1 0 1",
"output": "2\n0 1 "
},
{
"input": "2\n6 10\n3\n6 3 3",
"output": "1\n6 "
},
{
"input": "1\n7\n2\n7 9",
"output": "1\n7 "
},
{
"input": "3\n37 49 24\n3\n33 5 70",
"output": "0"
},
{
"input": "10\n7 10 1 2 1 7 1 5 9 9\n9\n6 2 5 6 7 7 5 5 2",
"output": "2\n2 7 "
},
{
"input": "9\n7 0 1 2 6 0 10 3 5\n4\n8 4 0 3",
"output": "2\n0 3 "
},
{
"input": "9\n7 4 4 5 0 6 5 4 10\n4\n5 2 10 9",
"output": "2\n5 10 "
},
{
"input": "8\n7 8 6 6 8 10 3 3\n5\n7 4 10 8 7",
"output": "2\n7 8 "
},
{
"input": "7\n4 2 4 3 10 3 6\n9\n7 5 2 3 0 1 6 1 4",
"output": "3\n2 3 6 "
},
{
"input": "1\n7\n10\n1 8 8 10 9 10 4 6 0 5",
"output": "0"
},
{
"input": "2\n5 2\n4\n8 8 0 4",
"output": "0"
},
{
"input": "3\n1 3 9\n10\n8 0 10 5 7 0 3 1 2 4",
"output": "1\n1 "
},
{
"input": "15\n10 4 7 7 10 1 4 9 1 10 9 6 8 8 2\n2\n0 4",
"output": "1\n4 "
},
{
"input": "16\n8 8 6 7 10 0 10 1 7 6 6 0 4 2 6 7\n12\n9 3 8 4 10 3 9 8 3 7 10 4",
"output": "2\n8 10 "
},
{
"input": "23\n174 172 196 135 91 174 208 92 132 53 202 118 5 244 161 140 71 21 185 56 60 195 217\n17\n38 218 120 77 22 214 164 194 79 195 36 167 42 89 201 80 11",
"output": "1\n195 "
},
{
"input": "53\n135 168 160 123 6 250 251 158 245 184 206 35 189 64 138 12 69 21 112 198 165 211 109 40 192 98 236 216 255 98 136 38 67 79 25 196 216 64 134 124 102 232 229 102 179 138 111 123 2 93 25 162 57\n57\n64 143 41 144 73 26 11 17 224 209 167 162 129 39 102 224 254 45 120 2 138 213 139 133 169 54 7 143 242 118 155 189 100 185 145 168 248 131 83 216 142 180 225 35 226 202 8 15 200 192 75 140 191 189 75 116 202",
"output": "3\n64 138 192 "
},
{
"input": "83\n95 164 123 111 177 71 38 225 103 59 210 209 117 139 115 140 66 21 39 84 14 227 0 43 90 233 96 98 232 237 108 139 55 220 14 225 134 39 68 167 193 125 86 216 87 14 94 75 255 24 165 98 177 191 239 123 98 90 29 52 155 231 187 90 180 1 31 237 167 145 242 115 61 190 47 41 61 206 191 248 126 196 26\n49\n234 134 9 207 37 95 116 239 105 197 191 15 151 249 156 235 17 161 197 199 87 78 191 188 44 151 179 238 72 29 228 157 174 99 190 114 95 185 160 168 58 216 131 151 233 204 213 87 76",
"output": "2\n95 233 "
},
{
"input": "13\n55 160 86 99 92 148 81 36 216 191 214 127 44\n85\n92 12 64 21 221 225 119 243 147 47 244 112 212 237 209 121 81 239 43 104 3 254 52 13 1 210 28 18 199 75 251 146 77 28 253 211 50 35 42 160 157 104 155 37 241 78 42 190 150 228 193 96 190 178 232 65 231 186 1 123 212 126 239 22 214 186 245 249 66 234 57 78 173 229 185 23 240 91 127 177 240 105 77 208 86",
"output": "2\n160 214 "
},
{
"input": "94\n100 161 99 102 209 51 5 188 217 53 121 5 233 55 25 156 136 195 243 157 110 202 136 151 86 171 253 38 126 40 27 76 60 119 222 52 134 104 184 146 133 220 88 108 246 61 215 184 181 134 223 164 41 193 232 217 38 192 226 91 81 99 204 232 178 4 187 61 160 255 121 142 191 114 114 181 226 49 86 55 252 169 59 190 246 93 21 22 17 18 120 88 93 144\n30\n61 51 176 38 119 33 100 185 103 84 161 166 103 227 43 200 127 53 52 89 19 215 76 254 110 30 239 247 11 182",
"output": "3\n51 53 110 "
},
{
"input": "6\n3 5 4 6 8 1\n10\n3 3 0 5 4 0 10 5 6 8",
"output": "4\n3 5 6 8 "
},
{
"input": "10\n0 1 2 3 4 5 6 7 8 9\n10\n0 1 2 3 4 5 6 7 8 9",
"output": "10\n0 1 2 3 4 5 6 7 8 9 "
},
{
"input": "8\n2 3 4 5 6 8 9 5\n9\n2 2 3 4 5 6 6 8 9",
"output": "7\n2 3 4 5 6 8 9 "
},
{
"input": "8\n0 4 10 6 7 2 8 5\n7\n0 4 6 7 7 0 8",
"output": "5\n0 4 6 7 8 "
},
{
"input": "10\n0 1 2 3 4 5 6 7 8 9\n10\n0 1 2 3 4 5 6 7 8 9",
"output": "10\n0 1 2 3 4 5 6 7 8 9 "
},
{
"input": "17\n12 17 39 156 100 177 188 129 14 142 45 144 243 151 158 194 245\n16\n125 12 17 199 65 39 100 185 129 194 142 144 62 92 158 194",
"output": "9\n12 17 39 100 129 142 144 158 194 "
},
{
"input": "20\n7 17 24 27 36 45 62 92 93 94 98 112 114 138 143 156 173 199 204 207\n20\n7 17 24 27 36 45 62 92 93 94 98 112 114 138 143 156 173 199 204 207",
"output": "20\n7 17 24 27 36 45 62 92 93 94 98 112 114 138 143 156 173 199 204 207 "
},
{
"input": "13\n0 46 104 116 63 118 158 16 221 222 136 245 223\n9\n0 46 104 116 118 158 221 222 245",
"output": "9\n0 46 104 116 118 158 221 222 245 "
},
{
"input": "13\n34 38 51 57 73 125 147 158 160 178 188 198 235\n15\n34 38 51 57 73 125 147 158 160 178 255 67 188 198 235",
"output": "13\n34 38 51 57 73 125 147 158 160 178 188 198 235 "
},
{
"input": "17\n25 29 37 207 122 189 118 42 54 95 154 160 162 225 228 237 248\n19\n25 29 248 37 147 209 42 54 255 95 154 160 162 225 228 237 73 248 10",
"output": "13\n25 29 37 42 54 95 154 160 162 225 228 237 248 "
},
{
"input": "10\n62914292 123971042 784965687 324817892 379711365 394545872 813282270 822333477 865397146 437913515\n9\n297835672 62914292 123971042 324817892 379711365 394545872 813282270 822333477 865397146",
"output": "8\n62914292 123971042 324817892 379711365 394545872 813282270 822333477 865397146 "
},
{
"input": "10\n130077811 57466561 335978192 71385678 434259735 454136111 482887469 530031703 688581885 809880630\n8\n373627898 57466561 71385678 434259735 454136111 482887469 530031703 809880630",
"output": "7\n57466561 71385678 434259735 454136111 482887469 530031703 809880630 "
},
{
"input": "17\n364396044 90653796 82853043 311258337 326557522 362475139 415783272 428510002 840021181 469284863 541444887 650535473 649258258 750028895 791368777 808443140 959785237\n13\n82853043 311258337 326557522 362475139 415783272 428510002 469284863 541444887 649258258 750028895 791368777 808443140 959785237",
"output": "13\n82853043 311258337 326557522 362475139 415783272 428510002 469284863 541444887 649258258 750028895 791368777 808443140 959785237 "
},
{
"input": "3\n6379263 55134355 76061584\n3\n6379263 55134355 76061584",
"output": "3\n6379263 55134355 76061584 "
},
{
"input": "3\n48875076 71023491 76538219\n3\n48875076 71023491 76538219",
"output": "3\n48875076 71023491 76538219 "
},
{
"input": "5\n6621317 78540394 52064998 89150480 53659440\n3\n78540394 46008538 839195",
"output": "1\n78540394 "
},
{
"input": "2\n34665180 51128665\n5\n71074966 34665180 47089728 44119345 51128665",
"output": "2\n34665180 51128665 "
},
{
"input": "4\n3 4 9 1\n7\n5 3 8 9 10 2 1",
"output": "2\n3 9 "
}
] | 1,647,175,304
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 1
| 46
| 1,638,400
|
module = 10**9 + 7
def calc(n):
a = [0] + [10**6] * (n-1)
for i in range(n):
if i + 2 <= n:
a[i+1] = min(a[i+1], a[i]+1)
if 2*(i + 1) <= n:
a[2*(i + 1) - 1] = min(a[2*(i + 1) - 1], a[i]+1)
if 3*(i + 1) <= n:
a[3*(i + 1) - 1] = min(a[3*(i + 1) - 1], a[i]+1)
s = []
x = a[-1]
while n > 1:
if n % 2 == 0:
if a[n // 2 - 1] == a[n - 1] - 1:
n = n//2
s.append(2)
continue
if n % 3 == 0:
if a[n//3-1] == a[n-1] - 1:
n = n // 3
s.append(3)
continue
if a[n-2] == a[n-1] - 1:
n = n-1
s.append(1)
return s[::-1]
def run_c():
n = int(input())
print(''.join(list(map(str, calc(n)))))
def stairs_rec(res, cube_count, max_first_step_width):
for first_step_width in range(max_first_step_width, -1, -1):
if first_step_width == cube_count:
res[0] += 1
elif first_step_width*(first_step_width-1)//2 < cube_count - first_step_width:
break
else:
stairs_rec(res, cube_count - first_step_width, first_step_width - 1)
#import numpy as np
def stairs_dp(n):
h = 1
while h*(h+1)//2 < n:
h += 1
#arr = np.zeros((h+1, n+1, n+1), dtype=int)
arr = [[[0]*(n+1) for _ in range(n+1)] for _ in range(h+1)]
for i in range(1, n+1):
#arr[1, i, i] = 1
arr[1][i][i] = 1
for height in range(2, h+1):
for width in range(height, n - height*(height - 1)//2+1):
for used_cubes in range(width + height*(height - 1)//2, min((2*width - height + 1)*height//2 + 1, n+1)):
for w in range(height-1, width):
#arr[height, width, used_cubes] += arr[height-1, w, used_cubes-width]
arr[height][width][used_cubes] += arr[height-1][w][used_cubes-width]
s = 0
for i in range(h+1):
for j in range(n+1):
s += arr[i][j][n]
#return sum(arr[:, :, n].flatten())
return s
def test_d():
for n in range(13, 20):
print(f"n={n}")
res = [0]
stairs_rec(res, n, n)
res1 = stairs_dp(n)
print(res[0], res1)
def run_d():
n = int(input())
res = [0]
#stairs_rec(res, n, n)
res1 = stairs_dp(n)
print(res1)
def nails_dp(arr):
if len(arr) < 4:
return arr[-1] - arr[0]
if len(arr) == 4:
return arr[-1] - arr[0] - (arr[2] - arr[1])
distances = [10**6]*len(arr)
distances[1:4] = arr[1] - arr[0], arr[2] - arr[0], arr[3] - arr[2] + arr[1] - arr[0]
for i in range(4, len(arr)):
distances[i] = min(distances[i-2] + arr[i] - arr[i-1], distances[i-3] + arr[i] - arr[i-2])
return distances[-1]
def nails_rec(arr):
if len(arr) < 4:
return arr[-1] - arr[0]
if len(arr) == 4:
return arr[-1] - arr[0] - (arr[2] - arr[1])
return min(nails_rec(arr[:-2]) + arr[-1] - arr[-2], nails_rec(arr[:-3]) + arr[-1] - arr[-3])
def test_e():
import random
while True:
n = random.randint(5, 7)
arr = sorted(set([random.randint(1,20) for _ in range(n)]))
print(arr)
res1 = nails_dp(arr)
res2 = nails_rec(arr)
if res1 != res2:
print(f'dp = {res1}, rec = {res2}')
break
def run_e():
n = int(input())
arr = sorted(list(map(int, input().split())))
print(nails_dp(arr))
def phone_knight(n):
phones_cnt = [1]*10
phones_cnt1 = [0] * 10
phones_cnt[0] = phones_cnt[8] = 0
for _ in range(n-1):
phones_cnt1[0] = phones_cnt[4] + phones_cnt[6]
phones_cnt1[1] = phones_cnt[8] + phones_cnt[6]
phones_cnt1[2] = phones_cnt[7] + phones_cnt[9]
phones_cnt1[3] = phones_cnt[4] + phones_cnt[8]
phones_cnt1[4] = phones_cnt[3] + phones_cnt[9] + phones_cnt[0]
phones_cnt1[5] = 0
phones_cnt1[6] = phones_cnt[1] + phones_cnt[7] + phones_cnt[0]
phones_cnt1[7] = phones_cnt[2] + phones_cnt[6]
phones_cnt1[8] = phones_cnt[1] + phones_cnt[3]
phones_cnt1[9] = phones_cnt[2] + phones_cnt[4]
phones_cnt = phones_cnt1[:]
#print(phones_cnt)
return sum(phones_cnt)
def run_f():
n = int(input())
print(phone_knight(n))
def knight_pass(n, m):
field = [[0]*(m + n + 2) for _ in range(m + n + 2)]
field[0][0] = 1
i = j = 0
k = n + m - 1
for i in range(n + m):
for j in range(m):
# i-j, j
if n > i - j > 0:
field[i - j - 1][j + 2] += field[i-j][j]
field[i-j+2][j+1] += field[i-j][j]
field[i-j+1][j+2] += field[i-j][j]
if m > j > 0:
field[i - j + 2][j - 1] += field[i - j][j]
return field[n-1][m-1]
def run_g():
n, m = map(int, input().split())
print(knight_pass(n, m))
def saw(n, k):
if n == 1:
return k
if k == 1:
return 0
seq_up = [i for i in range(k)]
seq_down = [k - 1 - i for i in range(k)]
seq_up_new = [0] * k
seq_down_new = [0] * k
for i in range(n-2):
sum_up = sum(seq_up[1:]) % module
sum_down = 0
for j in range(1, k+1):
sum_up -= seq_up[j - 1]
seq_down_new[j-1] = sum_up
seq_up_new[j-1] = sum_down
sum_down += seq_down[j-1] % module
seq_up = seq_up_new[:]
seq_down = seq_down_new[:]
return (sum(seq_up) + sum(seq_down)) % module
def run_i():
n, k = map(int, input().split())
print(saw(n, k))
def longest_increasing_subsequence(arr):
if len(arr) == 0:
return []
max_el = min(arr) - 1
dp = [(-1, 1)]*len(arr)
for i in range(len(arr)):
max_len = 1
i0 = -1
for j in range(i):
if arr[j] < arr[i] and dp[j][1] + 1 > max_len:
max_len = dp[j][1] + 1
i0 = j
dp[i] = (i0, max_len)
max_len = 0
n = len(arr)
for i in range(len(arr)):
if max_len < dp[i][1]:
max_len = dp[i][1]
n = i
seq = [arr[n]]
max_len -= 1
while max_len > 0:
seq.append(arr[dp[n][0]])
n = dp[n][0]
max_len -= 1
return seq[::-1]
def run_k():
n = int(input())
arr = list(map(int, input().split()))
seq = longest_increasing_subsequence(arr)
print(len(seq))
print(' '.join(list(map(str, seq))))
def turtle(field):
n = len(field)
m = len(field[0])
paths = [[-1]*m for _ in range(n)]
previous = [[0] * m for _ in range(n)]
paths[0][0] = field[0][0]
for i in range(n):
for j in range(m):
if i > 0:
if paths[i][j] < paths[i-1][j] + field[i][j]:
paths[i][j] = paths[i-1][j] + field[i][j]
previous[i][j] = 'D'
if j > 0:
if paths[i][j] < paths[i][j-1] + field[i][j]:
paths[i][j] = paths[i][j-1] + field[i][j]
previous[i][j] = 'R'
print(paths[-1][-1])
s = []
el = previous[-1][-1]
i = n-1
j = m-1
while i > 0 or j > 0:
s.append(el)
if el == 'D':
i -= 1
else:
j -= 1
el = previous[i][j]
print(' '.join(s[::-1]))
def run_m():
n, m = map(int, input().split())
field = []
for _ in range(n):
field.append(list(map(int, input().split())))
turtle(field)
def ones(n):
if n < 4:
return 2**n - int(n > 2)
seq = [4, 2, 1]
for _ in range(n-3):
seq = [sum(seq), seq[0], seq[1]]
return sum(seq)
def run_l():
n = int(input())
print(ones(n))
def longest_common_subsequence(s1, s2):
n1, n2 = len(s1), len(s2)
common = [[[] for _ in range(n2) ] for _ in range(n1)]
#common[0] = list(map(lambda x: [x] if x == s1[0] else [], s2))
#for i in range(n1):
# if s1[i] == s2[0]:
# common[i][0] = [s2[0]]
# else:
# common[i][0] = []
if s1[0] == s2[0]:
common[0][0] = [s1[0]]
for i1 in range(n1):
for i2 in range(n2):
if s1[i1] == s2[i2]:
if i1 > 0 and i2 > 0:
common[i1][i2] = common[i1 - 1][i2 - 1][:] + [s1[i1]]
else:
common[i1][i2] = [s1[i1]]
else:
if i1 > 0 and i2 > 0:
if len(common[i1-1][i2]) > len(common[i1][i2-1]):
common[i1][i2] = common[i1-1][i2][:]
else:
common[i1][i2] = common[i1][i2-1][:]
elif i1 == 0 and i2 > 0:
common[i1][i2] = common[i1][i2-1][:]
elif i1 > 0 and i2 == 0:
common[i1][i2] = common[i1-1][i2][:]
return common[-1][-1]
def longest_common_increasing_subsequence(s1, s2):
n1, n2 = len(s1), len(s2)
common = [[[] for _ in range(n2) ] for _ in range(n1)]
#common[0] = list(map(lambda x: [x] if x == s1[0] else [], s2))
#for i in range(n1):
# if s1[i] == s2[0]:
# common[i][0] = [s2[0]]
# else:
# common[i][0] = []
if s1[0] == s2[0]:
common[0][0] = [s1[0]]
for i1 in range(n1):
for i2 in range(n2):
if s1[i1] == s2[i2]:
if i1 > 0 and i2 > 0 and common[i1 - 1][i2 - 1] and common[i1 - 1][i2 - 1][-1] < s1[i1]:
common[i1][i2] = common[i1 - 1][i2 - 1][:] + [s1[i1]]
else:
common[i1][i2] = [s1[i1]]
else:
if i1 > 0 and i2 > 0:
if len(common[i1-1][i2]) > len(common[i1][i2-1]):
common[i1][i2] = common[i1-1][i2][:]
else:
common[i1][i2] = common[i1][i2-1][:]
elif i1 == 0 and i2 > 0:
common[i1][i2] = common[i1][i2-1][:]
elif i1 > 0 and i2 == 0:
common[i1][i2] = common[i1-1][i2][:]
return common[-1][-1]
def run_j():
n = int(input())
s1 = list(map(int, input().split()))
#s1 = input().strip().split()
n = int(input())
s2 = list(map(int, input().split()))
#s2 = input().strip().split()
s = longest_common_increasing_subsequence(s1, s2)
print(len(s))
print(' '.join(list(map(str, s))))
if __name__ == '__main__':
#test_f()
run_j()
|
Title: LCIS
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
This problem differs from one which was on the online contest.
The sequence *a*1,<=*a*2,<=...,<=*a**n* is called increasing, if *a**i*<=<<=*a**i*<=+<=1 for *i*<=<<=*n*.
The sequence *s*1,<=*s*2,<=...,<=*s**k* is called the subsequence of the sequence *a*1,<=*a*2,<=...,<=*a**n*, if there exist such a set of indexes 1<=≤<=*i*1<=<<=*i*2<=<<=...<=<<=*i**k*<=≤<=*n* that *a**i**j*<==<=*s**j*. In other words, the sequence *s* can be derived from the sequence *a* by crossing out some elements.
You are given two sequences of integer numbers. You are to find their longest common increasing subsequence, i.e. an increasing sequence of maximum length that is the subsequence of both sequences.
Input Specification:
The first line contains an integer *n* (1<=≤<=*n*<=≤<=500) — the length of the first sequence. The second line contains *n* space-separated integers from the range [0,<=109] — elements of the first sequence. The third line contains an integer *m* (1<=≤<=*m*<=≤<=500) — the length of the second sequence. The fourth line contains *m* space-separated integers from the range [0,<=109] — elements of the second sequence.
Output Specification:
In the first line output *k* — the length of the longest common increasing subsequence. In the second line output the subsequence itself. Separate the elements with a space. If there are several solutions, output any.
Demo Input:
['7\n2 3 1 6 5 4 6\n4\n1 3 5 6\n', '5\n1 2 0 2 1\n3\n1 0 1\n']
Demo Output:
['3\n3 5 6 \n', '2\n0 1 \n']
Note:
none
|
```python
module = 10**9 + 7
def calc(n):
a = [0] + [10**6] * (n-1)
for i in range(n):
if i + 2 <= n:
a[i+1] = min(a[i+1], a[i]+1)
if 2*(i + 1) <= n:
a[2*(i + 1) - 1] = min(a[2*(i + 1) - 1], a[i]+1)
if 3*(i + 1) <= n:
a[3*(i + 1) - 1] = min(a[3*(i + 1) - 1], a[i]+1)
s = []
x = a[-1]
while n > 1:
if n % 2 == 0:
if a[n // 2 - 1] == a[n - 1] - 1:
n = n//2
s.append(2)
continue
if n % 3 == 0:
if a[n//3-1] == a[n-1] - 1:
n = n // 3
s.append(3)
continue
if a[n-2] == a[n-1] - 1:
n = n-1
s.append(1)
return s[::-1]
def run_c():
n = int(input())
print(''.join(list(map(str, calc(n)))))
def stairs_rec(res, cube_count, max_first_step_width):
for first_step_width in range(max_first_step_width, -1, -1):
if first_step_width == cube_count:
res[0] += 1
elif first_step_width*(first_step_width-1)//2 < cube_count - first_step_width:
break
else:
stairs_rec(res, cube_count - first_step_width, first_step_width - 1)
#import numpy as np
def stairs_dp(n):
h = 1
while h*(h+1)//2 < n:
h += 1
#arr = np.zeros((h+1, n+1, n+1), dtype=int)
arr = [[[0]*(n+1) for _ in range(n+1)] for _ in range(h+1)]
for i in range(1, n+1):
#arr[1, i, i] = 1
arr[1][i][i] = 1
for height in range(2, h+1):
for width in range(height, n - height*(height - 1)//2+1):
for used_cubes in range(width + height*(height - 1)//2, min((2*width - height + 1)*height//2 + 1, n+1)):
for w in range(height-1, width):
#arr[height, width, used_cubes] += arr[height-1, w, used_cubes-width]
arr[height][width][used_cubes] += arr[height-1][w][used_cubes-width]
s = 0
for i in range(h+1):
for j in range(n+1):
s += arr[i][j][n]
#return sum(arr[:, :, n].flatten())
return s
def test_d():
for n in range(13, 20):
print(f"n={n}")
res = [0]
stairs_rec(res, n, n)
res1 = stairs_dp(n)
print(res[0], res1)
def run_d():
n = int(input())
res = [0]
#stairs_rec(res, n, n)
res1 = stairs_dp(n)
print(res1)
def nails_dp(arr):
if len(arr) < 4:
return arr[-1] - arr[0]
if len(arr) == 4:
return arr[-1] - arr[0] - (arr[2] - arr[1])
distances = [10**6]*len(arr)
distances[1:4] = arr[1] - arr[0], arr[2] - arr[0], arr[3] - arr[2] + arr[1] - arr[0]
for i in range(4, len(arr)):
distances[i] = min(distances[i-2] + arr[i] - arr[i-1], distances[i-3] + arr[i] - arr[i-2])
return distances[-1]
def nails_rec(arr):
if len(arr) < 4:
return arr[-1] - arr[0]
if len(arr) == 4:
return arr[-1] - arr[0] - (arr[2] - arr[1])
return min(nails_rec(arr[:-2]) + arr[-1] - arr[-2], nails_rec(arr[:-3]) + arr[-1] - arr[-3])
def test_e():
import random
while True:
n = random.randint(5, 7)
arr = sorted(set([random.randint(1,20) for _ in range(n)]))
print(arr)
res1 = nails_dp(arr)
res2 = nails_rec(arr)
if res1 != res2:
print(f'dp = {res1}, rec = {res2}')
break
def run_e():
n = int(input())
arr = sorted(list(map(int, input().split())))
print(nails_dp(arr))
def phone_knight(n):
phones_cnt = [1]*10
phones_cnt1 = [0] * 10
phones_cnt[0] = phones_cnt[8] = 0
for _ in range(n-1):
phones_cnt1[0] = phones_cnt[4] + phones_cnt[6]
phones_cnt1[1] = phones_cnt[8] + phones_cnt[6]
phones_cnt1[2] = phones_cnt[7] + phones_cnt[9]
phones_cnt1[3] = phones_cnt[4] + phones_cnt[8]
phones_cnt1[4] = phones_cnt[3] + phones_cnt[9] + phones_cnt[0]
phones_cnt1[5] = 0
phones_cnt1[6] = phones_cnt[1] + phones_cnt[7] + phones_cnt[0]
phones_cnt1[7] = phones_cnt[2] + phones_cnt[6]
phones_cnt1[8] = phones_cnt[1] + phones_cnt[3]
phones_cnt1[9] = phones_cnt[2] + phones_cnt[4]
phones_cnt = phones_cnt1[:]
#print(phones_cnt)
return sum(phones_cnt)
def run_f():
n = int(input())
print(phone_knight(n))
def knight_pass(n, m):
field = [[0]*(m + n + 2) for _ in range(m + n + 2)]
field[0][0] = 1
i = j = 0
k = n + m - 1
for i in range(n + m):
for j in range(m):
# i-j, j
if n > i - j > 0:
field[i - j - 1][j + 2] += field[i-j][j]
field[i-j+2][j+1] += field[i-j][j]
field[i-j+1][j+2] += field[i-j][j]
if m > j > 0:
field[i - j + 2][j - 1] += field[i - j][j]
return field[n-1][m-1]
def run_g():
n, m = map(int, input().split())
print(knight_pass(n, m))
def saw(n, k):
if n == 1:
return k
if k == 1:
return 0
seq_up = [i for i in range(k)]
seq_down = [k - 1 - i for i in range(k)]
seq_up_new = [0] * k
seq_down_new = [0] * k
for i in range(n-2):
sum_up = sum(seq_up[1:]) % module
sum_down = 0
for j in range(1, k+1):
sum_up -= seq_up[j - 1]
seq_down_new[j-1] = sum_up
seq_up_new[j-1] = sum_down
sum_down += seq_down[j-1] % module
seq_up = seq_up_new[:]
seq_down = seq_down_new[:]
return (sum(seq_up) + sum(seq_down)) % module
def run_i():
n, k = map(int, input().split())
print(saw(n, k))
def longest_increasing_subsequence(arr):
if len(arr) == 0:
return []
max_el = min(arr) - 1
dp = [(-1, 1)]*len(arr)
for i in range(len(arr)):
max_len = 1
i0 = -1
for j in range(i):
if arr[j] < arr[i] and dp[j][1] + 1 > max_len:
max_len = dp[j][1] + 1
i0 = j
dp[i] = (i0, max_len)
max_len = 0
n = len(arr)
for i in range(len(arr)):
if max_len < dp[i][1]:
max_len = dp[i][1]
n = i
seq = [arr[n]]
max_len -= 1
while max_len > 0:
seq.append(arr[dp[n][0]])
n = dp[n][0]
max_len -= 1
return seq[::-1]
def run_k():
n = int(input())
arr = list(map(int, input().split()))
seq = longest_increasing_subsequence(arr)
print(len(seq))
print(' '.join(list(map(str, seq))))
def turtle(field):
n = len(field)
m = len(field[0])
paths = [[-1]*m for _ in range(n)]
previous = [[0] * m for _ in range(n)]
paths[0][0] = field[0][0]
for i in range(n):
for j in range(m):
if i > 0:
if paths[i][j] < paths[i-1][j] + field[i][j]:
paths[i][j] = paths[i-1][j] + field[i][j]
previous[i][j] = 'D'
if j > 0:
if paths[i][j] < paths[i][j-1] + field[i][j]:
paths[i][j] = paths[i][j-1] + field[i][j]
previous[i][j] = 'R'
print(paths[-1][-1])
s = []
el = previous[-1][-1]
i = n-1
j = m-1
while i > 0 or j > 0:
s.append(el)
if el == 'D':
i -= 1
else:
j -= 1
el = previous[i][j]
print(' '.join(s[::-1]))
def run_m():
n, m = map(int, input().split())
field = []
for _ in range(n):
field.append(list(map(int, input().split())))
turtle(field)
def ones(n):
if n < 4:
return 2**n - int(n > 2)
seq = [4, 2, 1]
for _ in range(n-3):
seq = [sum(seq), seq[0], seq[1]]
return sum(seq)
def run_l():
n = int(input())
print(ones(n))
def longest_common_subsequence(s1, s2):
n1, n2 = len(s1), len(s2)
common = [[[] for _ in range(n2) ] for _ in range(n1)]
#common[0] = list(map(lambda x: [x] if x == s1[0] else [], s2))
#for i in range(n1):
# if s1[i] == s2[0]:
# common[i][0] = [s2[0]]
# else:
# common[i][0] = []
if s1[0] == s2[0]:
common[0][0] = [s1[0]]
for i1 in range(n1):
for i2 in range(n2):
if s1[i1] == s2[i2]:
if i1 > 0 and i2 > 0:
common[i1][i2] = common[i1 - 1][i2 - 1][:] + [s1[i1]]
else:
common[i1][i2] = [s1[i1]]
else:
if i1 > 0 and i2 > 0:
if len(common[i1-1][i2]) > len(common[i1][i2-1]):
common[i1][i2] = common[i1-1][i2][:]
else:
common[i1][i2] = common[i1][i2-1][:]
elif i1 == 0 and i2 > 0:
common[i1][i2] = common[i1][i2-1][:]
elif i1 > 0 and i2 == 0:
common[i1][i2] = common[i1-1][i2][:]
return common[-1][-1]
def longest_common_increasing_subsequence(s1, s2):
n1, n2 = len(s1), len(s2)
common = [[[] for _ in range(n2) ] for _ in range(n1)]
#common[0] = list(map(lambda x: [x] if x == s1[0] else [], s2))
#for i in range(n1):
# if s1[i] == s2[0]:
# common[i][0] = [s2[0]]
# else:
# common[i][0] = []
if s1[0] == s2[0]:
common[0][0] = [s1[0]]
for i1 in range(n1):
for i2 in range(n2):
if s1[i1] == s2[i2]:
if i1 > 0 and i2 > 0 and common[i1 - 1][i2 - 1] and common[i1 - 1][i2 - 1][-1] < s1[i1]:
common[i1][i2] = common[i1 - 1][i2 - 1][:] + [s1[i1]]
else:
common[i1][i2] = [s1[i1]]
else:
if i1 > 0 and i2 > 0:
if len(common[i1-1][i2]) > len(common[i1][i2-1]):
common[i1][i2] = common[i1-1][i2][:]
else:
common[i1][i2] = common[i1][i2-1][:]
elif i1 == 0 and i2 > 0:
common[i1][i2] = common[i1][i2-1][:]
elif i1 > 0 and i2 == 0:
common[i1][i2] = common[i1-1][i2][:]
return common[-1][-1]
def run_j():
n = int(input())
s1 = list(map(int, input().split()))
#s1 = input().strip().split()
n = int(input())
s2 = list(map(int, input().split()))
#s2 = input().strip().split()
s = longest_common_increasing_subsequence(s1, s2)
print(len(s))
print(' '.join(list(map(str, s))))
if __name__ == '__main__':
#test_f()
run_j()
```
| 0
|
558
|
A
|
Lala Land and Apple Trees
|
PROGRAMMING
| 1,100
|
[
"brute force",
"implementation",
"sortings"
] | null | null |
Amr lives in Lala Land. Lala Land is a very beautiful country that is located on a coordinate line. Lala Land is famous with its apple trees growing everywhere.
Lala Land has exactly *n* apple trees. Tree number *i* is located in a position *x**i* and has *a**i* apples growing on it. Amr wants to collect apples from the apple trees. Amr currently stands in *x*<==<=0 position. At the beginning, he can choose whether to go right or left. He'll continue in his direction until he meets an apple tree he didn't visit before. He'll take all of its apples and then reverse his direction, continue walking in this direction until he meets another apple tree he didn't visit before and so on. In the other words, Amr reverses his direction when visiting each new apple tree. Amr will stop collecting apples when there are no more trees he didn't visit in the direction he is facing.
What is the maximum number of apples he can collect?
|
The first line contains one number *n* (1<=≤<=*n*<=≤<=100), the number of apple trees in Lala Land.
The following *n* lines contains two integers each *x**i*, *a**i* (<=-<=105<=≤<=*x**i*<=≤<=105, *x**i*<=≠<=0, 1<=≤<=*a**i*<=≤<=105), representing the position of the *i*-th tree and number of apples on it.
It's guaranteed that there is at most one apple tree at each coordinate. It's guaranteed that no tree grows in point 0.
|
Output the maximum number of apples Amr can collect.
|
[
"2\n-1 5\n1 5\n",
"3\n-2 2\n1 4\n-1 3\n",
"3\n1 9\n3 5\n7 10\n"
] |
[
"10",
"9",
"9"
] |
In the first sample test it doesn't matter if Amr chose at first to go left or right. In both cases he'll get all the apples.
In the second sample test the optimal solution is to go left to *x* = - 1, collect apples from there, then the direction will be reversed, Amr has to go to *x* = 1, collect apples from there, then the direction will be reversed and Amr goes to the final tree *x* = - 2.
In the third sample test the optimal solution is to go right to *x* = 1, collect apples from there, then the direction will be reversed and Amr will not be able to collect anymore apples because there are no apple trees to his left.
| 500
|
[
{
"input": "2\n-1 5\n1 5",
"output": "10"
},
{
"input": "3\n-2 2\n1 4\n-1 3",
"output": "9"
},
{
"input": "3\n1 9\n3 5\n7 10",
"output": "9"
},
{
"input": "1\n1 1",
"output": "1"
},
{
"input": "4\n10000 100000\n-1000 100000\n-2 100000\n-1 100000",
"output": "300000"
},
{
"input": "1\n-1 1",
"output": "1"
},
{
"input": "27\n-30721 24576\n-6620 92252\n88986 24715\n-94356 10509\n-6543 29234\n-68554 69530\n39176 96911\n67266 99669\n95905 51002\n-94093 92134\n65382 23947\n-6525 79426\n-448 67531\n-70083 26921\n-86333 50029\n48924 8036\n-27228 5349\n6022 10691\n-13840 56735\n50398 58794\n-63258 45557\n-27792 77057\n98295 1203\n-51294 18757\n35037 61941\n-30112 13076\n82334 20463",
"output": "1036452"
},
{
"input": "18\n-18697 44186\n56333 51938\n-75688 49735\n77762 14039\n-43996 81060\n69700 49107\n74532 45568\n-94476 203\n-92347 90745\n58921 44650\n57563 63561\n44630 8486\n35750 5999\n3249 34202\n75358 68110\n-33245 60458\n-88148 2342\n87856 85532",
"output": "632240"
},
{
"input": "28\n49728 91049\n-42863 4175\n-89214 22191\n77977 16965\n-42960 87627\n-84329 97494\n89270 75906\n-13695 28908\n-72279 13607\n-97327 87062\n-58682 32094\n39108 99936\n29304 93784\n-63886 48237\n-77359 57648\n-87013 79017\n-41086 35033\n-60613 83555\n-48955 56816\n-20568 26802\n52113 25160\n-88885 45294\n22601 42971\n62693 65662\n-15985 5357\n86671 8522\n-59921 11271\n-79304 25044",
"output": "891593"
},
{
"input": "25\n5704 67795\n6766 31836\n-41715 89987\n76854 9848\n11648 90020\n-79763 10107\n96971 92636\n-64205 71937\n87997 38273\n-9782 57187\n22186 6905\n-41130 40258\n-28403 66579\n19578 43375\n35735 52929\n-52417 89388\n-89430 1939\n9401 43491\n-11228 10112\n-86859 16024\n-51486 33467\n-80578 65080\n-52820 98445\n-89165 7657\n-97106 79422",
"output": "1109655"
},
{
"input": "16\n-41732 47681\n44295 28942\n-75194 99827\n69982 18020\n-75378 22026\n80032 22908\n-34879 41113\n36257 48574\n-35882 84333\n29646 71151\n-86214 80886\n72724 39364\n-42529 60880\n29150 29921\n-8471 80781\n79387 70834",
"output": "847241"
},
{
"input": "3\n-94146 4473\n28707 99079\n-4153 8857",
"output": "112409"
},
{
"input": "3\n-3 3\n-2 2\n-1 1",
"output": "1"
},
{
"input": "2\n100000 3\n-100000 9",
"output": "12"
},
{
"input": "2\n-100000 100000\n100000 99999",
"output": "199999"
}
] | 1,470,540,117
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 43
| 77
| 4,608,000
|
import sys
n = int(input())
left = []
right = []
for i in range(n):
x, a = map(int, sys.stdin.readline().split())
if x < 0:
left.append((x, a))
else:
right.append((x, a))
left.sort(key=lambda x:x[0], reverse=True)
right.sort(key=lambda x:x[0])
ans = 0
length = min(len(left), len(right))
for i in range(length):
ans += left[i][1] + right[i][1]
if len(left) > len(right):
ans += left[length][1]
elif len(right) > len(left):
ans += right[length][1]
print(ans)
|
Title: Lala Land and Apple Trees
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Amr lives in Lala Land. Lala Land is a very beautiful country that is located on a coordinate line. Lala Land is famous with its apple trees growing everywhere.
Lala Land has exactly *n* apple trees. Tree number *i* is located in a position *x**i* and has *a**i* apples growing on it. Amr wants to collect apples from the apple trees. Amr currently stands in *x*<==<=0 position. At the beginning, he can choose whether to go right or left. He'll continue in his direction until he meets an apple tree he didn't visit before. He'll take all of its apples and then reverse his direction, continue walking in this direction until he meets another apple tree he didn't visit before and so on. In the other words, Amr reverses his direction when visiting each new apple tree. Amr will stop collecting apples when there are no more trees he didn't visit in the direction he is facing.
What is the maximum number of apples he can collect?
Input Specification:
The first line contains one number *n* (1<=≤<=*n*<=≤<=100), the number of apple trees in Lala Land.
The following *n* lines contains two integers each *x**i*, *a**i* (<=-<=105<=≤<=*x**i*<=≤<=105, *x**i*<=≠<=0, 1<=≤<=*a**i*<=≤<=105), representing the position of the *i*-th tree and number of apples on it.
It's guaranteed that there is at most one apple tree at each coordinate. It's guaranteed that no tree grows in point 0.
Output Specification:
Output the maximum number of apples Amr can collect.
Demo Input:
['2\n-1 5\n1 5\n', '3\n-2 2\n1 4\n-1 3\n', '3\n1 9\n3 5\n7 10\n']
Demo Output:
['10', '9', '9']
Note:
In the first sample test it doesn't matter if Amr chose at first to go left or right. In both cases he'll get all the apples.
In the second sample test the optimal solution is to go left to *x* = - 1, collect apples from there, then the direction will be reversed, Amr has to go to *x* = 1, collect apples from there, then the direction will be reversed and Amr goes to the final tree *x* = - 2.
In the third sample test the optimal solution is to go right to *x* = 1, collect apples from there, then the direction will be reversed and Amr will not be able to collect anymore apples because there are no apple trees to his left.
|
```python
import sys
n = int(input())
left = []
right = []
for i in range(n):
x, a = map(int, sys.stdin.readline().split())
if x < 0:
left.append((x, a))
else:
right.append((x, a))
left.sort(key=lambda x:x[0], reverse=True)
right.sort(key=lambda x:x[0])
ans = 0
length = min(len(left), len(right))
for i in range(length):
ans += left[i][1] + right[i][1]
if len(left) > len(right):
ans += left[length][1]
elif len(right) > len(left):
ans += right[length][1]
print(ans)
```
| 3
|
|
479
|
A
|
Expression
|
PROGRAMMING
| 1,000
|
[
"brute force",
"math"
] | null | null |
Petya studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers *a*, *b*, *c* on the blackboard. The task was to insert signs of operations '+' and '*', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets:
- 1+2*3=7 - 1*(2+3)=5 - 1*2*3=6 - (1+2)*3=9
Note that you can insert operation signs only between *a* and *b*, and between *b* and *c*, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2.
It's easy to see that the maximum value that you can obtain is 9.
Your task is: given *a*, *b* and *c* print the maximum value that you can get.
|
The input contains three integers *a*, *b* and *c*, each on a single line (1<=≤<=*a*,<=*b*,<=*c*<=≤<=10).
|
Print the maximum value of the expression that you can obtain.
|
[
"1\n2\n3\n",
"2\n10\n3\n"
] |
[
"9\n",
"60\n"
] |
none
| 500
|
[
{
"input": "1\n2\n3",
"output": "9"
},
{
"input": "2\n10\n3",
"output": "60"
},
{
"input": "1\n1\n1",
"output": "3"
},
{
"input": "1\n2\n1",
"output": "4"
},
{
"input": "10\n10\n10",
"output": "1000"
},
{
"input": "5\n1\n3",
"output": "20"
},
{
"input": "3\n1\n5",
"output": "20"
},
{
"input": "6\n7\n1",
"output": "48"
},
{
"input": "1\n8\n3",
"output": "27"
},
{
"input": "9\n7\n2",
"output": "126"
},
{
"input": "1\n1\n10",
"output": "20"
},
{
"input": "9\n1\n1",
"output": "18"
},
{
"input": "10\n5\n6",
"output": "300"
},
{
"input": "8\n9\n7",
"output": "504"
},
{
"input": "4\n2\n10",
"output": "80"
},
{
"input": "2\n8\n3",
"output": "48"
},
{
"input": "3\n5\n7",
"output": "105"
},
{
"input": "1\n10\n1",
"output": "12"
},
{
"input": "2\n2\n2",
"output": "8"
},
{
"input": "5\n6\n1",
"output": "35"
},
{
"input": "10\n1\n1",
"output": "20"
},
{
"input": "1\n6\n1",
"output": "8"
},
{
"input": "1\n9\n1",
"output": "11"
},
{
"input": "2\n1\n2",
"output": "6"
},
{
"input": "2\n6\n1",
"output": "14"
},
{
"input": "9\n2\n1",
"output": "27"
},
{
"input": "1\n9\n2",
"output": "20"
},
{
"input": "1\n3\n1",
"output": "5"
},
{
"input": "2\n1\n1",
"output": "4"
}
] | 1,685,626,483
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 2
| 171
| 13,721,600
|
from bisect import bisect_right, bisect_left
from math import inf, gcd, sqrt, ceil, log2
from collections import defaultdict, Counter
from functools import cache, lru_cache
from tkinter import W
rvar = lambda: map(int, input().split())
rarr = lambda: list(map(int, input().split()))
rstr = lambda: input().split()
rint = lambda: int(input())
'''Speed up'''
import sys
input = sys.stdin.readline
a = rint()
b = rint()
c = rint()
arr = sorted([a,b,c])
print(max((arr[0] + arr[1]) * arr[2], arr[0] * arr[1] * arr[2]))
|
Title: Expression
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Petya studies in a school and he adores Maths. His class has been studying arithmetic expressions. On the last class the teacher wrote three positive integers *a*, *b*, *c* on the blackboard. The task was to insert signs of operations '+' and '*', and probably brackets between the numbers so that the value of the resulting expression is as large as possible. Let's consider an example: assume that the teacher wrote numbers 1, 2 and 3 on the blackboard. Here are some ways of placing signs and brackets:
- 1+2*3=7 - 1*(2+3)=5 - 1*2*3=6 - (1+2)*3=9
Note that you can insert operation signs only between *a* and *b*, and between *b* and *c*, that is, you cannot swap integers. For instance, in the given sample you cannot get expression (1+3)*2.
It's easy to see that the maximum value that you can obtain is 9.
Your task is: given *a*, *b* and *c* print the maximum value that you can get.
Input Specification:
The input contains three integers *a*, *b* and *c*, each on a single line (1<=≤<=*a*,<=*b*,<=*c*<=≤<=10).
Output Specification:
Print the maximum value of the expression that you can obtain.
Demo Input:
['1\n2\n3\n', '2\n10\n3\n']
Demo Output:
['9\n', '60\n']
Note:
none
|
```python
from bisect import bisect_right, bisect_left
from math import inf, gcd, sqrt, ceil, log2
from collections import defaultdict, Counter
from functools import cache, lru_cache
from tkinter import W
rvar = lambda: map(int, input().split())
rarr = lambda: list(map(int, input().split()))
rstr = lambda: input().split()
rint = lambda: int(input())
'''Speed up'''
import sys
input = sys.stdin.readline
a = rint()
b = rint()
c = rint()
arr = sorted([a,b,c])
print(max((arr[0] + arr[1]) * arr[2], arr[0] * arr[1] * arr[2]))
```
| 0
|
|
313
|
B
|
Ilya and Queries
|
PROGRAMMING
| 1,100
|
[
"dp",
"implementation"
] | null | null |
Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
You've got string *s*<==<=*s*1*s*2... *s**n* (*n* is the length of the string), consisting only of characters "." and "#" and *m* queries. Each query is described by a pair of integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*). The answer to the query *l**i*,<=*r**i* is the number of such integers *i* (*l**i*<=≤<=*i*<=<<=*r**i*), that *s**i*<==<=*s**i*<=+<=1.
Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
|
The first line contains string *s* of length *n* (2<=≤<=*n*<=≤<=105). It is guaranteed that the given string only consists of characters "." and "#".
The next line contains integer *m* (1<=≤<=*m*<=≤<=105) — the number of queries. Each of the next *m* lines contains the description of the corresponding query. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*).
|
Print *m* integers — the answers to the queries in the order in which they are given in the input.
|
[
"......\n4\n3 4\n2 3\n1 6\n2 6\n",
"#..###\n5\n1 3\n5 6\n1 5\n3 6\n3 4\n"
] |
[
"1\n1\n5\n4\n",
"1\n1\n2\n2\n0\n"
] |
none
| 1,000
|
[
{
"input": "......\n4\n3 4\n2 3\n1 6\n2 6",
"output": "1\n1\n5\n4"
},
{
"input": "#..###\n5\n1 3\n5 6\n1 5\n3 6\n3 4",
"output": "1\n1\n2\n2\n0"
},
{
"input": ".#...#..\n6\n1 5\n2 3\n6 7\n2 4\n2 5\n1 3",
"output": "2\n0\n0\n1\n2\n0"
},
{
"input": "#.#.#..\n5\n3 4\n4 5\n5 7\n5 7\n1 3",
"output": "0\n0\n1\n1\n0"
},
{
"input": "#.##.##.\n7\n1 8\n2 6\n2 6\n6 8\n3 5\n2 4\n2 5",
"output": "2\n1\n1\n1\n1\n1\n1"
},
{
"input": "#..#\n1\n1 4",
"output": "1"
},
{
"input": "#..##...#.\n7\n5 9\n6 10\n1 7\n5 8\n3 5\n2 10\n3 4",
"output": "2\n2\n3\n2\n1\n4\n0"
},
{
"input": "#.#.#\n7\n1 2\n3 4\n3 5\n2 3\n3 5\n1 5\n1 3",
"output": "0\n0\n0\n0\n0\n0\n0"
},
{
"input": "###..#...#\n2\n2 4\n1 2",
"output": "1\n1"
},
{
"input": "..\n1\n1 2",
"output": "1"
},
{
"input": "##\n1\n1 2",
"output": "1"
},
{
"input": ".#\n1\n1 2",
"output": "0"
},
{
"input": "#.\n1\n1 2",
"output": "0"
},
{
"input": "...\n2\n1 2\n1 2",
"output": "1\n1"
}
] | 1,699,516,129
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 9
| 2,000
| 102,400
|
s=str(input())
m=int(input())
for i in range(m):
counter=0
li,ri=map(int,input().split())
for j in range(li,ri):
if s[j-1]==s[j]:
counter+=1
print(counter)
|
Title: Ilya and Queries
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
You've got string *s*<==<=*s*1*s*2... *s**n* (*n* is the length of the string), consisting only of characters "." and "#" and *m* queries. Each query is described by a pair of integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*). The answer to the query *l**i*,<=*r**i* is the number of such integers *i* (*l**i*<=≤<=*i*<=<<=*r**i*), that *s**i*<==<=*s**i*<=+<=1.
Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
Input Specification:
The first line contains string *s* of length *n* (2<=≤<=*n*<=≤<=105). It is guaranteed that the given string only consists of characters "." and "#".
The next line contains integer *m* (1<=≤<=*m*<=≤<=105) — the number of queries. Each of the next *m* lines contains the description of the corresponding query. The *i*-th line contains integers *l**i*,<=*r**i* (1<=≤<=*l**i*<=<<=*r**i*<=≤<=*n*).
Output Specification:
Print *m* integers — the answers to the queries in the order in which they are given in the input.
Demo Input:
['......\n4\n3 4\n2 3\n1 6\n2 6\n', '#..###\n5\n1 3\n5 6\n1 5\n3 6\n3 4\n']
Demo Output:
['1\n1\n5\n4\n', '1\n1\n2\n2\n0\n']
Note:
none
|
```python
s=str(input())
m=int(input())
for i in range(m):
counter=0
li,ri=map(int,input().split())
for j in range(li,ri):
if s[j-1]==s[j]:
counter+=1
print(counter)
```
| 0
|
|
125
|
B
|
Simple XML
|
PROGRAMMING
| 1,000
|
[
"implementation"
] | null | null |
Let's define a string <x> as an opening tag, where *x* is any small letter of the Latin alphabet. Each opening tag matches a closing tag of the type </x>, where *x* is the same letter.
Tegs can be nested into each other: in this case one opening and closing tag pair is located inside another pair.
Let's define the notion of a XML-text:
- an empty string is a XML-text - if *s* is a XML-text, then *s*'=<a>+*s*+</a> also is a XML-text, where *a* is any small Latin letter - if *s*1, *s*2 are XML-texts, then *s*1+*s*2 also is a XML-text
You are given a XML-text (it is guaranteed that the text is valid), your task is to print in the following form:
- each tag (opening and closing) is located on a single line - print before the tag 2<=*<=*h* spaces, where *h* is the level of the tag's nestedness.
|
The input data consists on the only non-empty string — the XML-text, its length does not exceed 1000 characters. It is guaranteed that the text is valid. The text contains no spaces.
|
Print the given XML-text according to the above-given rules.
|
[
"<a><b><c></c></b></a>\n",
"<a><b></b><d><c></c></d></a>\n"
] |
[
"<a>\n <b>\n <c>\n </c>\n </b>\n</a>\n",
"<a>\n <b>\n </b>\n <d>\n <c>\n </c>\n </d>\n</a>\n"
] |
none
| 1,500
|
[
{
"input": "<a><b><c></c></b></a>",
"output": "<a>\n <b>\n <c>\n </c>\n </b>\n</a>"
},
{
"input": "<a><b></b><d><c></c></d></a>",
"output": "<a>\n <b>\n </b>\n <d>\n <c>\n </c>\n </d>\n</a>"
},
{
"input": "<z></z>",
"output": "<z>\n</z>"
},
{
"input": "<u><d></d></u><j></j>",
"output": "<u>\n <d>\n </d>\n</u>\n<j>\n</j>"
},
{
"input": "<a></a><n></n><v><r></r></v><z></z>",
"output": "<a>\n</a>\n<n>\n</n>\n<v>\n <r>\n </r>\n</v>\n<z>\n</z>"
},
{
"input": "<c><l></l><b><w><f><t><m></m></t></f><w></w></w></b></c>",
"output": "<c>\n <l>\n </l>\n <b>\n <w>\n <f>\n <t>\n <m>\n </m>\n </t>\n </f>\n <w>\n </w>\n </w>\n </b>\n</c>"
},
{
"input": "<u><d><g><k><m><a><u><j><d></d></j></u></a></m><m></m></k></g></d></u>",
"output": "<u>\n <d>\n <g>\n <k>\n <m>\n <a>\n <u>\n <j>\n <d>\n </d>\n </j>\n </u>\n </a>\n </m>\n <m>\n </m>\n </k>\n </g>\n </d>\n</u>"
},
{
"input": "<x><a><l></l></a><g><v></v><d></d></g><z></z><y></y></x><q><h></h><s></s></q><c></c><w></w><q></q>",
"output": "<x>\n <a>\n <l>\n </l>\n </a>\n <g>\n <v>\n </v>\n <d>\n </d>\n </g>\n <z>\n </z>\n <y>\n </y>\n</x>\n<q>\n <h>\n </h>\n <s>\n </s>\n</q>\n<c>\n</c>\n<w>\n</w>\n<q>\n</q>"
},
{
"input": "<b><k><t></t></k><j></j><t></t><q></q></b><x><h></h></x><r></r><k></k><i></i><t><b></b></t><z></z><x></x><p></p><u></u>",
"output": "<b>\n <k>\n <t>\n </t>\n </k>\n <j>\n </j>\n <t>\n </t>\n <q>\n </q>\n</b>\n<x>\n <h>\n </h>\n</x>\n<r>\n</r>\n<k>\n</k>\n<i>\n</i>\n<t>\n <b>\n </b>\n</t>\n<z>\n</z>\n<x>\n</x>\n<p>\n</p>\n<u>\n</u>"
},
{
"input": "<c><l><i><h><z></z></h><y><k></k><o></o></y></i><a></a><x></x></l><r><y></y><k><s></s></k></r><j><a><f></f></a></j><h></h><p></p></c><h></h>",
"output": "<c>\n <l>\n <i>\n <h>\n <z>\n </z>\n </h>\n <y>\n <k>\n </k>\n <o>\n </o>\n </y>\n </i>\n <a>\n </a>\n <x>\n </x>\n </l>\n <r>\n <y>\n </y>\n <k>\n <s>\n </s>\n </k>\n </r>\n <j>\n <a>\n <f>\n </f>\n </a>\n </j>\n <h>\n </h>\n <p>\n </p>\n</c>\n<h>\n</h>"
},
{
"input": "<p><q><l></l><q><k><r><n></n></r></k></q></q><x><z></z><r><k></k></r><h></h></x><c><p></p><o></o></c><n></n><c></c></p><b><c><z></z></c><u><u><f><a><d></d><q></q></a><x><i></i></x><r></r></f></u></u></b><j></j>",
"output": "<p>\n <q>\n <l>\n </l>\n <q>\n <k>\n <r>\n <n>\n </n>\n </r>\n </k>\n </q>\n </q>\n <x>\n <z>\n </z>\n <r>\n <k>\n </k>\n </r>\n <h>\n </h>\n </x>\n <c>\n <p>\n </p>\n <o>\n </o>\n </c>\n <n>\n </n>\n <c>\n </c>\n</p>\n<b>\n <c>\n <z>\n </z>\n </c>\n <u>\n <u>\n <f>\n <a>\n <d>\n </d>\n <q>\n </q>\n </a>\n <x>\n <i>\n ..."
},
{
"input": "<w><q><x></x></q><r></r><o></o><u></u><o></o></w><d><z></z><n><x></x></n><y></y><s></s><k></k><q></q><a></a></d><h><u></u><s></s><y></y><t></t><f></f></h><v><w><q></q></w><s></s><h></h></v><q><o></o><k></k><w></w></q><c></c><p><j></j></p><c><u></u></c><s></s><x></x><b></b><i></i>",
"output": "<w>\n <q>\n <x>\n </x>\n </q>\n <r>\n </r>\n <o>\n </o>\n <u>\n </u>\n <o>\n </o>\n</w>\n<d>\n <z>\n </z>\n <n>\n <x>\n </x>\n </n>\n <y>\n </y>\n <s>\n </s>\n <k>\n </k>\n <q>\n </q>\n <a>\n </a>\n</d>\n<h>\n <u>\n </u>\n <s>\n </s>\n <y>\n </y>\n <t>\n </t>\n <f>\n </f>\n</h>\n<v>\n <w>\n <q>\n </q>\n </w>\n <s>\n </s>\n <h>\n </h>\n</v>\n<q>\n <o>\n </o>\n <k>\n </k>\n <w>\n </w>\n</q>\n<c>\n</c>\n<p>\n <j>\n </j>\n</p>\n<c>\n <u>\n </u..."
},
{
"input": "<g><t><m><x><f><w><z><b><d><j></j><g><z></z><q><l><j></j><l><k></k><l><n><d></d><m></m></n></l><i><m><j></j></m></i></l></l><w><t><h><r><h></h><b></b></r></h></t><d><j></j></d><x><w><r><s><s></s></s></r></w><x></x></x></w><m><m><d></d><x><r><x><o><v></v><d><n></n></d></o></x></r></x></m></m></q></g><y></y></d></b></z></w></f></x><a></a></m></t></g>",
"output": "<g>\n <t>\n <m>\n <x>\n <f>\n <w>\n <z>\n <b>\n <d>\n <j>\n </j>\n <g>\n <z>\n </z>\n <q>\n <l>\n <j>\n </j>\n <l>\n <k>\n </k>\n <l>\n <n>\n ..."
},
{
"input": "<d><d><w><v><g><m></m></g><b><u></u><j><h><n><q><q><c></c></q></q></n></h><c></c><l><r><l></l><b><d></d><x><k><o><w><q><x></x></q></w></o></k><p></p></x><g><m></m></g></b></r></l></j><k><l></l></k><c><v><g><p><p><d><e><z><x></x></z></e><v></v></d><u><o><u></u><k></k></o></u><m><x><h><z><f></f></z></h></x><w></w></m></p></p></g></v><t><n><u><b><h></h></b></u><r><m><k><z></z></k></m><j><e><w><s></s><e><s><p></p><o></o></s><g></g></e><u></u></w></e></j></r></n></t></c></b></v></w></d></d>",
"output": "<d>\n <d>\n <w>\n <v>\n <g>\n <m>\n </m>\n </g>\n <b>\n <u>\n </u>\n <j>\n <h>\n <n>\n <q>\n <q>\n <c>\n </c>\n </q>\n </q>\n </n>\n </h>\n <c>\n </c>\n <l>\n <r>\n <l>\n </l>\n <b>\n ..."
}
] | 1,584,541,195
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 0
| 248
| 0
|
text = input()
visited = []
spacing_level = 0
for i in range(len(text)):
letter = text[i]
if letter in "</>":
continue
if text[i-1] == '/':
spacing_level -= 1
print(" " * spacing_level + "</" + letter + ">")
else:
print(" " * spacing_level + "<" + letter + ">")
spacing_level += 1
|
Title: Simple XML
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let's define a string <x> as an opening tag, where *x* is any small letter of the Latin alphabet. Each opening tag matches a closing tag of the type </x>, where *x* is the same letter.
Tegs can be nested into each other: in this case one opening and closing tag pair is located inside another pair.
Let's define the notion of a XML-text:
- an empty string is a XML-text - if *s* is a XML-text, then *s*'=<a>+*s*+</a> also is a XML-text, where *a* is any small Latin letter - if *s*1, *s*2 are XML-texts, then *s*1+*s*2 also is a XML-text
You are given a XML-text (it is guaranteed that the text is valid), your task is to print in the following form:
- each tag (opening and closing) is located on a single line - print before the tag 2<=*<=*h* spaces, where *h* is the level of the tag's nestedness.
Input Specification:
The input data consists on the only non-empty string — the XML-text, its length does not exceed 1000 characters. It is guaranteed that the text is valid. The text contains no spaces.
Output Specification:
Print the given XML-text according to the above-given rules.
Demo Input:
['<a><b><c></c></b></a>\n', '<a><b></b><d><c></c></d></a>\n']
Demo Output:
['<a>\n <b>\n <c>\n </c>\n </b>\n</a>\n', '<a>\n <b>\n </b>\n <d>\n <c>\n </c>\n </d>\n</a>\n']
Note:
none
|
```python
text = input()
visited = []
spacing_level = 0
for i in range(len(text)):
letter = text[i]
if letter in "</>":
continue
if text[i-1] == '/':
spacing_level -= 1
print(" " * spacing_level + "</" + letter + ">")
else:
print(" " * spacing_level + "<" + letter + ">")
spacing_level += 1
```
| 0
|
|
990
|
E
|
Post Lamps
|
PROGRAMMING
| 2,100
|
[
"brute force",
"greedy"
] | null | null |
Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has $n$ positions to install lamps, they correspond to the integer numbers from $0$ to $n - 1$ on the OX axis. However, some positions are blocked and no post lamp can be placed there.
There are post lamps of different types which differ only by their power. When placed in position $x$, post lamp of power $l$ illuminates the segment $[x; x + l]$. The power of each post lamp is always a positive integer number.
The post lamp shop provides an infinite amount of lamps of each type from power $1$ to power $k$. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power $l$ cost $a_l$ each.
What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power $3$ in position $n - 1$ (even though its illumination zone doesn't completely belong to segment $[0; n]$).
|
The first line contains three integer numbers $n$, $m$ and $k$ ($1 \le k \le n \le 10^6$, $0 \le m \le n$) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.
The second line contains $m$ integer numbers $s_1, s_2, \dots, s_m$ ($0 \le s_1 < s_2 < \dots s_m < n$) — the blocked positions.
The third line contains $k$ integer numbers $a_1, a_2, \dots, a_k$ ($1 \le a_i \le 10^6$) — the costs of the post lamps.
|
Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street.
If illumintaing the entire segment $[0; n]$ is impossible, print -1.
|
[
"6 2 3\n1 3\n1 2 3\n",
"4 3 4\n1 2 3\n1 10 100 1000\n",
"5 1 5\n0\n3 3 3 3 3\n",
"7 4 3\n2 4 5 6\n3 14 15\n"
] |
[
"6\n",
"1000\n",
"-1\n",
"-1\n"
] |
none
| 0
|
[
{
"input": "6 2 3\n1 3\n1 2 3",
"output": "6"
},
{
"input": "4 3 4\n1 2 3\n1 10 100 1000",
"output": "1000"
},
{
"input": "5 1 5\n0\n3 3 3 3 3",
"output": "-1"
},
{
"input": "7 4 3\n2 4 5 6\n3 14 15",
"output": "-1"
},
{
"input": "1 0 1\n\n1000000",
"output": "1000000"
},
{
"input": "1 1 1\n0\n1000",
"output": "-1"
},
{
"input": "3 2 3\n1 2\n1 1 1000000",
"output": "1000000"
},
{
"input": "3 0 3\n\n333 500 1001",
"output": "999"
},
{
"input": "3 0 3\n\n334 500 1001",
"output": "1000"
},
{
"input": "6 2 3\n2 3\n1 1 3",
"output": "9"
},
{
"input": "9 4 3\n3 4 7 8\n1 1 1",
"output": "4"
},
{
"input": "11 4 6\n3 4 5 6\n1000000 1000000 1000000 1000000 1000000 1",
"output": "3"
},
{
"input": "1000000 0 1\n\n999999",
"output": "999999000000"
},
{
"input": "1000000 0 1\n\n1000000",
"output": "1000000000000"
},
{
"input": "2 1 2\n1\n1 2",
"output": "2"
},
{
"input": "2 1 1\n1\n1",
"output": "-1"
},
{
"input": "4 1 3\n3\n3 2 9",
"output": "4"
},
{
"input": "3 1 2\n1\n8 61",
"output": "122"
},
{
"input": "20 2 10\n9 16\n109 58 165 715 341 620 574 732 653 675",
"output": "638"
},
{
"input": "4 0 4\n\n1 4 4 3",
"output": "3"
},
{
"input": "20 16 16\n1 2 3 4 5 6 8 9 10 11 13 14 15 16 18 19\n2 1 1 1 1 1 3 3 2 2 1 3 3 3 3 2",
"output": "3"
},
{
"input": "10 3 2\n2 3 8\n2 4",
"output": "-1"
},
{
"input": "4 1 3\n3\n838 185 210",
"output": "370"
},
{
"input": "3 1 2\n2\n1 1",
"output": "2"
},
{
"input": "3 1 1\n2\n1",
"output": "-1"
}
] | 1,528,631,753
| 6,653
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 4
| 2,000
| 61,235,200
|
s=input().split()
n,m,k=int(s[0]),int(s[1]), int(s[2])
block=input().split()
block=list(map(int,block))
kold=k
tecprod=1
maxprod=0
for i in range(1,len(block)):
if block[i]==block[i-1]+1:
tecprod+=1
else:
maxprod=max(maxprod,tecprod)
tecprod=1
maxprod=max(maxprod,tecprod)
maxprod+=1
kmin=max(1, maxprod)
price=input().split()
price=list(map(int,price))
minprice=10**19
#print(block)
for m in range(kmin, k+1):
tp=price[m-1] #tec price
tecosv=0 # ������� ���������� �������
# m - ��������
k=1# ���-�� �������
tecosv+=m
# print('K: '+str(m))
while tecosv<n:
# print(tecosv)
if tecosv not in block:
tecosv+=m
else:
next=tecosv
while next in block:
next-=1
tecosv=next+m
k+=1
myprice=k*tp
minprice=min(minprice, myprice)
if kmin>kold or 0 in block:
minprice=-1
print(minprice)
|
Title: Post Lamps
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has $n$ positions to install lamps, they correspond to the integer numbers from $0$ to $n - 1$ on the OX axis. However, some positions are blocked and no post lamp can be placed there.
There are post lamps of different types which differ only by their power. When placed in position $x$, post lamp of power $l$ illuminates the segment $[x; x + l]$. The power of each post lamp is always a positive integer number.
The post lamp shop provides an infinite amount of lamps of each type from power $1$ to power $k$. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power $l$ cost $a_l$ each.
What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power $3$ in position $n - 1$ (even though its illumination zone doesn't completely belong to segment $[0; n]$).
Input Specification:
The first line contains three integer numbers $n$, $m$ and $k$ ($1 \le k \le n \le 10^6$, $0 \le m \le n$) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.
The second line contains $m$ integer numbers $s_1, s_2, \dots, s_m$ ($0 \le s_1 < s_2 < \dots s_m < n$) — the blocked positions.
The third line contains $k$ integer numbers $a_1, a_2, \dots, a_k$ ($1 \le a_i \le 10^6$) — the costs of the post lamps.
Output Specification:
Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment $[0; n]$ of the street.
If illumintaing the entire segment $[0; n]$ is impossible, print -1.
Demo Input:
['6 2 3\n1 3\n1 2 3\n', '4 3 4\n1 2 3\n1 10 100 1000\n', '5 1 5\n0\n3 3 3 3 3\n', '7 4 3\n2 4 5 6\n3 14 15\n']
Demo Output:
['6\n', '1000\n', '-1\n', '-1\n']
Note:
none
|
```python
s=input().split()
n,m,k=int(s[0]),int(s[1]), int(s[2])
block=input().split()
block=list(map(int,block))
kold=k
tecprod=1
maxprod=0
for i in range(1,len(block)):
if block[i]==block[i-1]+1:
tecprod+=1
else:
maxprod=max(maxprod,tecprod)
tecprod=1
maxprod=max(maxprod,tecprod)
maxprod+=1
kmin=max(1, maxprod)
price=input().split()
price=list(map(int,price))
minprice=10**19
#print(block)
for m in range(kmin, k+1):
tp=price[m-1] #tec price
tecosv=0 # ������� ���������� �������
# m - ��������
k=1# ���-�� �������
tecosv+=m
# print('K: '+str(m))
while tecosv<n:
# print(tecosv)
if tecosv not in block:
tecosv+=m
else:
next=tecosv
while next in block:
next-=1
tecosv=next+m
k+=1
myprice=k*tp
minprice=min(minprice, myprice)
if kmin>kold or 0 in block:
minprice=-1
print(minprice)
```
| 0
|
|
551
|
A
|
GukiZ and Contest
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation",
"sortings"
] | null | null |
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, *n* students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to *n*. Let's denote the rating of *i*-th student as *a**i*. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to . In particular, if student *A* has rating strictly lower then student *B*, *A* will get the strictly better position than *B*, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
|
The first line contains integer *n* (1<=≤<=*n*<=≤<=2000), number of GukiZ's students.
The second line contains *n* numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=2000) where *a**i* is the rating of *i*-th student (1<=≤<=*i*<=≤<=*n*).
|
In a single line, print the position after the end of the contest for each of *n* students in the same order as they appear in the input.
|
[
"3\n1 3 3\n",
"1\n1\n",
"5\n3 5 3 4 5\n"
] |
[
"3 1 1\n",
"1\n",
"4 1 4 3 1\n"
] |
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.
| 500
|
[
{
"input": "3\n1 3 3",
"output": "3 1 1"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "5\n3 5 3 4 5",
"output": "4 1 4 3 1"
},
{
"input": "7\n1 3 5 4 2 2 1",
"output": "6 3 1 2 4 4 6"
},
{
"input": "11\n5 6 4 2 9 7 6 6 6 6 7",
"output": "9 4 10 11 1 2 4 4 4 4 2"
},
{
"input": "1\n2000",
"output": "1"
},
{
"input": "2\n2000 2000",
"output": "1 1"
},
{
"input": "3\n500 501 502",
"output": "3 2 1"
},
{
"input": "10\n105 106 1 1 1 11 1000 999 1000 999",
"output": "6 5 8 8 8 7 1 3 1 3"
},
{
"input": "6\n1 2 3 4 5 6",
"output": "6 5 4 3 2 1"
},
{
"input": "7\n6 5 4 3 2 1 1",
"output": "1 2 3 4 5 6 6"
},
{
"input": "8\n153 100 87 14 10 8 6 5",
"output": "1 2 3 4 5 6 7 8"
},
{
"input": "70\n11 54 37 62 1 46 13 17 38 47 28 15 63 5 61 34 49 66 32 59 3 41 58 28 23 62 41 64 20 5 14 41 10 37 51 32 65 46 61 8 15 19 16 44 31 42 19 46 66 25 26 58 60 5 19 18 69 53 20 40 45 27 24 41 32 23 57 56 62 10",
"output": "62 18 35 7 70 23 61 56 34 22 42 58 6 66 10 37 21 2 38 13 69 29 14 42 48 7 29 5 50 66 60 29 63 35 20 38 4 23 10 65 58 52 57 27 41 28 52 23 2 46 45 14 12 66 52 55 1 19 50 33 26 44 47 29 38 48 16 17 7 63"
},
{
"input": "5\n1 2000 1 1 2000",
"output": "3 1 3 3 1"
}
] | 1,588,531,148
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 36
| 187
| 2,867,200
|
n = int(input())
l = list(map(int, input().split()))
for i in range(n):
c = 0
for j in range(n):
if(l[i] < l[j]):
c += 1
print(c + 1, end=' ')
|
Title: GukiZ and Contest
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, *n* students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to *n*. Let's denote the rating of *i*-th student as *a**i*. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to . In particular, if student *A* has rating strictly lower then student *B*, *A* will get the strictly better position than *B*, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input Specification:
The first line contains integer *n* (1<=≤<=*n*<=≤<=2000), number of GukiZ's students.
The second line contains *n* numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=2000) where *a**i* is the rating of *i*-th student (1<=≤<=*i*<=≤<=*n*).
Output Specification:
In a single line, print the position after the end of the contest for each of *n* students in the same order as they appear in the input.
Demo Input:
['3\n1 3 3\n', '1\n1\n', '5\n3 5 3 4 5\n']
Demo Output:
['3 1 1\n', '1\n', '4 1 4 3 1\n']
Note:
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.
|
```python
n = int(input())
l = list(map(int, input().split()))
for i in range(n):
c = 0
for j in range(n):
if(l[i] < l[j]):
c += 1
print(c + 1, end=' ')
```
| 3
|
|
394
|
A
|
Counting Sticks
|
PROGRAMMING
| 0
|
[
"brute force",
"implementation"
] | null | null |
When new students come to the Specialized Educational and Scientific Centre (SESC) they need to start many things from the beginning. Sometimes the teachers say (not always unfairly) that we cannot even count. So our teachers decided to teach us arithmetics from the start. And what is the best way to teach students add and subtract? — That's right, using counting sticks! An here's our new task:
An expression of counting sticks is an expression of type:
Sign + consists of two crossed sticks: one vertical and one horizontal. Sign = consists of two horizontal sticks. The expression is arithmetically correct if *A*<=+<=*B*<==<=*C*.
We've got an expression that looks like *A*<=+<=*B*<==<=*C* given by counting sticks. Our task is to shift at most one stick (or we can shift nothing) so that the expression became arithmetically correct. Note that we cannot remove the sticks from the expression, also we cannot shift the sticks from the signs + and =.
We really aren't fabulous at arithmetics. Can you help us?
|
The single line contains the initial expression. It is guaranteed that the expression looks like *A*<=+<=*B*<==<=*C*, where 1<=≤<=*A*,<=*B*,<=*C*<=≤<=100.
|
If there isn't a way to shift the stick so the expression becomes correct, print on a single line "Impossible" (without the quotes). If there is a way, print the resulting expression. Follow the format of the output from the test samples. Don't print extra space characters.
If there are multiple correct answers, print any of them. For clarifications, you are recommended to see the test samples.
|
[
"||+|=|||||\n",
"|||||+||=||\n",
"|+|=||||||\n",
"||||+||=||||||\n"
] |
[
"|||+|=||||\n",
"Impossible\n",
"Impossible\n",
"||||+||=||||||\n"
] |
In the first sample we can shift stick from the third group of sticks to the first one.
In the second sample we cannot shift vertical stick from + sign to the second group of sticks. So we cannot make a - sign.
There is no answer in the third sample because we cannot remove sticks from the expression.
In the forth sample the initial expression is already arithmetically correct and that is why we don't have to shift sticks.
| 500
|
[
{
"input": "||+|=|||||",
"output": "|||+|=||||"
},
{
"input": "|||||+||=||",
"output": "Impossible"
},
{
"input": "|+|=||||||",
"output": "Impossible"
},
{
"input": "||||+||=||||||",
"output": "||||+||=||||||"
},
{
"input": "||||||||||||+|||||||||||=||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "||||||||||||||||||+||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||=|||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+|=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+|=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "|+|=|",
"output": "Impossible"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||||||||||||||||||||=|",
"output": "Impossible"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=|",
"output": "Impossible"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||||=|",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||||||||||||||||||||||||||=|",
"output": "Impossible"
},
{
"input": "||+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||+|=|",
"output": "|+|=||"
},
{
"input": "|+||=|",
"output": "|+|=||"
},
{
"input": "|+|=||",
"output": "|+|=||"
},
{
"input": "|||+|=|",
"output": "Impossible"
},
{
"input": "|||+|=|",
"output": "Impossible"
},
{
"input": "|||||||||||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "||||||||||||||||||||||||||||||||||||||||||||||||||+|||||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
},
{
"input": "|+|=|||",
"output": "Impossible"
},
{
"input": "|+|=||||",
"output": "||+|=|||"
},
{
"input": "|+||=|",
"output": "|+|=||"
},
{
"input": "|+||||||=|||||",
"output": "|+|||||=||||||"
},
{
"input": "|+|||=||",
"output": "|+||=|||"
},
{
"input": "|+||||=|||",
"output": "|+|||=||||"
},
{
"input": "|+|||||=||||",
"output": "|+||||=|||||"
},
{
"input": "||+||=||",
"output": "|+||=|||"
},
{
"input": "||+|||=|||",
"output": "|+|||=||||"
},
{
"input": "|||||+||=||||||||||",
"output": "Impossible"
},
{
"input": "|||+|||=||||",
"output": "||+|||=|||||"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "|||||+|||||=||||||||||||",
"output": "||||||+|||||=|||||||||||"
},
{
"input": "||+|||||||=|||||||",
"output": "|+|||||||=||||||||"
},
{
"input": "||||+||||=||||||",
"output": "|||+||||=|||||||"
},
{
"input": "||||+|||=|||||",
"output": "|||+|||=||||||"
},
{
"input": "||+|||=|||||||",
"output": "|||+|||=||||||"
},
{
"input": "||+|=|",
"output": "|+|=||"
},
{
"input": "|||+|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "||+|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||"
},
{
"input": "||+|=||||||",
"output": "Impossible"
},
{
"input": "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||+||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||=||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||",
"output": "Impossible"
}
] | 1,552,911,095
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 49
| 109
| 307,200
|
def crum(x):
y=''
for i in range(x):
y+='|'
return y
a,b = input().split('+')
s=a+"+"+b
b,c=b.split('=')
x = a.count('|')
y = b.count('|')
z = c.count('|')
if x+y==z:
print(s)
else:
if (x-1)+(y+1) == z and (x-1)>0:
print(crum(x-1)+'+'+crum(y+1)+'='+crum(z))
elif (x-1)+y == (z+1) and (x-1)>0:
print(crum(x-1)+'+'+crum(y)+'='+crum(z+1))
elif (x+1)+(y-1) == z and (y-1)>0:
print(crum(x+1)+'+'+crum(y-1)+'='+crum(z))
elif x+(y-1) == (z+1) and (y-1)>0:
print(crum(x)+'+'+crum(y-1)+'='+crum(z+1))
elif (x+1)+y == (z-1) and (z-1)>0:
print(crum(x+1)+'+'+crum(y)+'='+crum(z-1))
elif x+(y+1) == (z-1) and (z-1)>0:
print(crum(x)+'+'+crum(y+1)+'='+crum(z-1))
else:
print("Impossible")
|
Title: Counting Sticks
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
When new students come to the Specialized Educational and Scientific Centre (SESC) they need to start many things from the beginning. Sometimes the teachers say (not always unfairly) that we cannot even count. So our teachers decided to teach us arithmetics from the start. And what is the best way to teach students add and subtract? — That's right, using counting sticks! An here's our new task:
An expression of counting sticks is an expression of type:
Sign + consists of two crossed sticks: one vertical and one horizontal. Sign = consists of two horizontal sticks. The expression is arithmetically correct if *A*<=+<=*B*<==<=*C*.
We've got an expression that looks like *A*<=+<=*B*<==<=*C* given by counting sticks. Our task is to shift at most one stick (or we can shift nothing) so that the expression became arithmetically correct. Note that we cannot remove the sticks from the expression, also we cannot shift the sticks from the signs + and =.
We really aren't fabulous at arithmetics. Can you help us?
Input Specification:
The single line contains the initial expression. It is guaranteed that the expression looks like *A*<=+<=*B*<==<=*C*, where 1<=≤<=*A*,<=*B*,<=*C*<=≤<=100.
Output Specification:
If there isn't a way to shift the stick so the expression becomes correct, print on a single line "Impossible" (without the quotes). If there is a way, print the resulting expression. Follow the format of the output from the test samples. Don't print extra space characters.
If there are multiple correct answers, print any of them. For clarifications, you are recommended to see the test samples.
Demo Input:
['||+|=|||||\n', '|||||+||=||\n', '|+|=||||||\n', '||||+||=||||||\n']
Demo Output:
['|||+|=||||\n', 'Impossible\n', 'Impossible\n', '||||+||=||||||\n']
Note:
In the first sample we can shift stick from the third group of sticks to the first one.
In the second sample we cannot shift vertical stick from + sign to the second group of sticks. So we cannot make a - sign.
There is no answer in the third sample because we cannot remove sticks from the expression.
In the forth sample the initial expression is already arithmetically correct and that is why we don't have to shift sticks.
|
```python
def crum(x):
y=''
for i in range(x):
y+='|'
return y
a,b = input().split('+')
s=a+"+"+b
b,c=b.split('=')
x = a.count('|')
y = b.count('|')
z = c.count('|')
if x+y==z:
print(s)
else:
if (x-1)+(y+1) == z and (x-1)>0:
print(crum(x-1)+'+'+crum(y+1)+'='+crum(z))
elif (x-1)+y == (z+1) and (x-1)>0:
print(crum(x-1)+'+'+crum(y)+'='+crum(z+1))
elif (x+1)+(y-1) == z and (y-1)>0:
print(crum(x+1)+'+'+crum(y-1)+'='+crum(z))
elif x+(y-1) == (z+1) and (y-1)>0:
print(crum(x)+'+'+crum(y-1)+'='+crum(z+1))
elif (x+1)+y == (z-1) and (z-1)>0:
print(crum(x+1)+'+'+crum(y)+'='+crum(z-1))
elif x+(y+1) == (z-1) and (z-1)>0:
print(crum(x)+'+'+crum(y+1)+'='+crum(z-1))
else:
print("Impossible")
```
| 3
|
|
952
|
B
|
A Map of the Cat
|
PROGRAMMING
| 1,900
|
[
"brute force",
"interactive"
] | null | null |
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
You have met a cat. Can you figure out whether it's normal or grumpy?
|
none
|
none
|
[] |
[] |
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
| 0
|
[
{
"input": "5 0 1 2 5 3 5 4 5 5",
"output": "Correct answer 'normal'"
},
{
"input": "5 5 5 6 6 7 8 9 10 11",
"output": "Correct answer 'grumpy'"
},
{
"input": "10 6 5 7 5 6 11 5 8 9",
"output": "Correct answer 'grumpy'"
},
{
"input": "7 10 8 9 6 5 5 11 5 6",
"output": "Correct answer 'grumpy'"
},
{
"input": "5 5 4 5 2 5 5 0 1 3",
"output": "Correct answer 'normal'"
},
{
"input": "0 4 3 5 5 5 2 1 5 5",
"output": "Correct answer 'normal'"
},
{
"input": "3 5 5 0 5 5 2 5 4 1",
"output": "Correct answer 'normal'"
},
{
"input": "5 4 5 1 5 5 0 5 2 3",
"output": "Correct answer 'normal'"
},
{
"input": "5 5 1 2 5 5 4 3 0 5",
"output": "Correct answer 'normal'"
},
{
"input": "7 10 5 5 11 6 5 9 6 8",
"output": "Correct answer 'grumpy'"
},
{
"input": "6 5 10 5 5 7 8 11 9 6",
"output": "Correct answer 'grumpy'"
},
{
"input": "5 5 5 5 5 0 4 2 3 1",
"output": "Correct answer 'normal'"
},
{
"input": "11 5 6 5 9 5 10 8 7 6",
"output": "Correct answer 'grumpy'"
},
{
"input": "5 9 8 10 7 11 5 6 5 6",
"output": "Correct answer 'grumpy'"
},
{
"input": "5 8 10 11 5 6 5 6 7 9",
"output": "Correct answer 'grumpy'"
},
{
"input": "5 5 6 11 6 10 9 5 8 7",
"output": "Correct answer 'grumpy'"
},
{
"input": "1 5 5 2 5 0 3 5 5 4",
"output": "Correct answer 'normal'"
},
{
"input": "5 5 2 5 4 5 3 1 0 5",
"output": "Correct answer 'normal'"
}
] | 1,554,126,124
| 2,147,483,647
|
Python 3
|
COMPILATION_ERROR
|
TESTS
| 0
| 0
| 0
|
import sys
normal = ["great!", "don't think so", "cool", "not bad", "don't touch me!"]
for i in range(10):
print(i)
response = input()
if response in normal:
print("normal")
sys.exit(0)
elif response != "no":
print("grumpy")
sys.exit(0)
|
Title: A Map of the Cat
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
You have met a cat. Can you figure out whether it's normal or grumpy?
Input Specification:
none
Output Specification:
none
Note:
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
|
```python
import sys
normal = ["great!", "don't think so", "cool", "not bad", "don't touch me!"]
for i in range(10):
print(i)
response = input()
if response in normal:
print("normal")
sys.exit(0)
elif response != "no":
print("grumpy")
sys.exit(0)
```
| -1
|
|
828
|
A
|
Restaurant Tables
|
PROGRAMMING
| 1,200
|
[
"implementation"
] | null | 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,501,449,954
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 11
| 155
| 7,987,200
|
#!usr/bin/python 3
def main():
a=input().split(' ')
a=[int(x) for x in a]
lst=input().split(' ')
lst=[int(x) for x in lst]
rejected=0
for x in lst:
if a[1]>0 or a[2]>0:
if x==1:
if a[1]==0:
a[2]-=1
a[1]+=1
else:
a[1]-=1
elif x==2:
if a[2]==0:
rejected+=2
else:
a[2]-=1
else:
rejected+=x
print(rejected)
if __name__=='__main__':
main()
|
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
#!usr/bin/python 3
def main():
a=input().split(' ')
a=[int(x) for x in a]
lst=input().split(' ')
lst=[int(x) for x in lst]
rejected=0
for x in lst:
if a[1]>0 or a[2]>0:
if x==1:
if a[1]==0:
a[2]-=1
a[1]+=1
else:
a[1]-=1
elif x==2:
if a[2]==0:
rejected+=2
else:
a[2]-=1
else:
rejected+=x
print(rejected)
if __name__=='__main__':
main()
```
| 0
|
|
519
|
B
|
A and B and Compilation Errors
|
PROGRAMMING
| 1,100
|
[
"data structures",
"implementation",
"sortings"
] | null | null |
A and B are preparing themselves for programming contests.
B loves to debug his code. But before he runs the solution and starts debugging, he has to first compile the code.
Initially, the compiler displayed *n* compilation errors, each of them is represented as a positive integer. After some effort, B managed to fix some mistake and then another one mistake.
However, despite the fact that B is sure that he corrected the two errors, he can not understand exactly what compilation errors disappeared — the compiler of the language which B uses shows errors in the new order every time! B is sure that unlike many other programming languages, compilation errors for his programming language do not depend on each other, that is, if you correct one error, the set of other error does not change.
Can you help B find out exactly what two errors he corrected?
|
The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=105) — the initial number of compilation errors.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the errors the compiler displayed for the first time.
The third line contains *n*<=-<=1 space-separated integers *b*1,<=*b*2,<=...,<=*b**n*<=-<=1 — the errors displayed at the second compilation. It is guaranteed that the sequence in the third line contains all numbers of the second string except for exactly one.
The fourth line contains *n*<=-<=2 space-separated integers *с*1,<=*с*2,<=...,<=*с**n*<=-<=2 — the errors displayed at the third compilation. It is guaranteed that the sequence in the fourth line contains all numbers of the third line except for exactly one.
|
Print two numbers on a single line: the numbers of the compilation errors that disappeared after B made the first and the second correction, respectively.
|
[
"5\n1 5 8 123 7\n123 7 5 1\n5 1 7\n",
"6\n1 4 3 3 5 7\n3 7 5 4 3\n4 3 7 5\n"
] |
[
"8\n123\n",
"1\n3\n"
] |
In the first test sample B first corrects the error number 8, then the error number 123.
In the second test sample B first corrects the error number 1, then the error number 3. Note that if there are multiple errors with the same number, B can correct only one of them in one step.
| 1,000
|
[
{
"input": "5\n1 5 8 123 7\n123 7 5 1\n5 1 7",
"output": "8\n123"
},
{
"input": "6\n1 4 3 3 5 7\n3 7 5 4 3\n4 3 7 5",
"output": "1\n3"
},
{
"input": "3\n1 2 3\n3 2\n2",
"output": "1\n3"
},
{
"input": "10\n460626451 802090732 277246428 661369649 388684428 784303821 376287098 656422756 9301599 25720377\n277246428 388684428 661369649 460626451 656422756 802090732 9301599 784303821 376287098\n376287098 802090732 388684428 9301599 656422756 784303821 460626451 277246428",
"output": "25720377\n661369649"
},
{
"input": "3\n796067435 964699482 819602309\n964699482 796067435\n964699482",
"output": "819602309\n796067435"
},
{
"input": "3\n374054998 726316780 902899520\n902899520 726316780\n726316780",
"output": "374054998\n902899520"
},
{
"input": "3\n168638990 939116221 323703261\n168638990 323703261\n168638990",
"output": "939116221\n323703261"
},
{
"input": "3\n77 77 77\n77 77\n77",
"output": "77\n77"
},
{
"input": "3\n84 30 9\n9 84\n9",
"output": "30\n84"
},
{
"input": "6\n5 4 3 3 5 5\n3 5 5 4 3\n3 5 4 3",
"output": "5\n5"
},
{
"input": "4\n1 5 7 8\n1 5 7\n1 5",
"output": "8\n7"
}
] | 1,652,628,999
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 31
| 4,300,800
|
int(input())
a = set(input().split())
b = set(input().split())
c = set(input().split())
print(''.join(a - b), ''.join(b - c), sep='\n')
|
Title: A and B and Compilation Errors
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A and B are preparing themselves for programming contests.
B loves to debug his code. But before he runs the solution and starts debugging, he has to first compile the code.
Initially, the compiler displayed *n* compilation errors, each of them is represented as a positive integer. After some effort, B managed to fix some mistake and then another one mistake.
However, despite the fact that B is sure that he corrected the two errors, he can not understand exactly what compilation errors disappeared — the compiler of the language which B uses shows errors in the new order every time! B is sure that unlike many other programming languages, compilation errors for his programming language do not depend on each other, that is, if you correct one error, the set of other error does not change.
Can you help B find out exactly what two errors he corrected?
Input Specification:
The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=105) — the initial number of compilation errors.
The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=109) — the errors the compiler displayed for the first time.
The third line contains *n*<=-<=1 space-separated integers *b*1,<=*b*2,<=...,<=*b**n*<=-<=1 — the errors displayed at the second compilation. It is guaranteed that the sequence in the third line contains all numbers of the second string except for exactly one.
The fourth line contains *n*<=-<=2 space-separated integers *с*1,<=*с*2,<=...,<=*с**n*<=-<=2 — the errors displayed at the third compilation. It is guaranteed that the sequence in the fourth line contains all numbers of the third line except for exactly one.
Output Specification:
Print two numbers on a single line: the numbers of the compilation errors that disappeared after B made the first and the second correction, respectively.
Demo Input:
['5\n1 5 8 123 7\n123 7 5 1\n5 1 7\n', '6\n1 4 3 3 5 7\n3 7 5 4 3\n4 3 7 5\n']
Demo Output:
['8\n123\n', '1\n3\n']
Note:
In the first test sample B first corrects the error number 8, then the error number 123.
In the second test sample B first corrects the error number 1, then the error number 3. Note that if there are multiple errors with the same number, B can correct only one of them in one step.
|
```python
int(input())
a = set(input().split())
b = set(input().split())
c = set(input().split())
print(''.join(a - b), ''.join(b - c), sep='\n')
```
| 0
|
|
231
|
A
|
Team
|
PROGRAMMING
| 800
|
[
"brute force",
"greedy"
] | null | null |
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
This contest offers *n* problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
|
The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of problems in the contest. Then *n* lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
|
Print a single integer — the number of problems the friends will implement on the contest.
|
[
"3\n1 1 0\n1 1 1\n1 0 0\n",
"2\n1 0 0\n0 1 1\n"
] |
[
"2\n",
"1\n"
] |
In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
| 500
|
[
{
"input": "3\n1 1 0\n1 1 1\n1 0 0",
"output": "2"
},
{
"input": "2\n1 0 0\n0 1 1",
"output": "1"
},
{
"input": "1\n1 0 0",
"output": "0"
},
{
"input": "2\n1 0 0\n1 1 1",
"output": "1"
},
{
"input": "5\n1 0 0\n0 1 0\n1 1 1\n0 0 1\n0 0 0",
"output": "1"
},
{
"input": "10\n0 1 0\n0 1 0\n1 1 0\n1 0 0\n0 0 1\n0 1 1\n1 1 1\n1 1 0\n0 0 0\n0 0 0",
"output": "4"
},
{
"input": "15\n0 1 0\n1 0 0\n1 1 0\n1 1 1\n0 1 0\n0 0 1\n1 0 1\n1 0 1\n1 0 1\n0 0 0\n1 1 1\n1 1 0\n0 1 1\n1 1 0\n1 1 1",
"output": "10"
},
{
"input": "50\n0 0 0\n0 1 1\n1 1 1\n0 1 0\n1 0 1\n1 1 1\n0 0 1\n1 0 0\n1 1 0\n1 0 1\n0 1 0\n0 0 1\n1 1 0\n0 1 0\n1 1 0\n0 0 0\n1 1 1\n1 0 1\n0 0 1\n1 1 0\n1 1 1\n0 1 1\n1 1 0\n0 0 0\n0 0 0\n1 1 1\n0 0 0\n1 1 1\n0 1 1\n0 0 1\n0 0 0\n0 0 0\n1 1 0\n1 1 0\n1 0 1\n1 0 0\n1 0 1\n1 0 1\n0 1 1\n1 1 0\n1 1 0\n0 1 0\n1 0 1\n0 0 0\n0 0 0\n0 0 0\n0 0 1\n1 1 1\n0 1 1\n1 0 1",
"output": "29"
},
{
"input": "1\n1 1 1",
"output": "1"
},
{
"input": "8\n0 0 0\n0 0 1\n0 0 0\n0 1 1\n1 0 0\n1 0 1\n1 1 0\n1 1 1",
"output": "4"
},
{
"input": "16\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1",
"output": "16"
}
] | 1,696,421,956
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 21
| 278
| 1,740,800
|
loops = int(input())
li_full = []
flag = 0
for i in range(loops):
a, b, c = input().split()
li = [a,b,c]
if li.count('1') >= 2:
flag+=1
print('{}'.format(flag))
|
Title: Team
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
This contest offers *n* problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
Input Specification:
The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of problems in the contest. Then *n* lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
Output Specification:
Print a single integer — the number of problems the friends will implement on the contest.
Demo Input:
['3\n1 1 0\n1 1 1\n1 0 0\n', '2\n1 0 0\n0 1 1\n']
Demo Output:
['2\n', '1\n']
Note:
In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
|
```python
loops = int(input())
li_full = []
flag = 0
for i in range(loops):
a, b, c = input().split()
li = [a,b,c]
if li.count('1') >= 2:
flag+=1
print('{}'.format(flag))
```
| 3
|
|
278
|
A
|
Circle Line
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
The circle line of the Berland subway has *n* stations. We know the distances between all pairs of neighboring stations:
- *d*1 is the distance between the 1-st and the 2-nd station;- *d*2 is the distance between the 2-nd and the 3-rd station;...- *d**n*<=-<=1 is the distance between the *n*<=-<=1-th and the *n*-th station;- *d**n* is the distance between the *n*-th and the 1-st station.
The trains go along the circle line in both directions. Find the shortest distance between stations with numbers *s* and *t*.
|
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — the number of stations on the circle line. The second line contains *n* integers *d*1,<=*d*2,<=...,<=*d**n* (1<=≤<=*d**i*<=≤<=100) — the distances between pairs of neighboring stations. The third line contains two integers *s* and *t* (1<=≤<=*s*,<=*t*<=≤<=*n*) — the numbers of stations, between which you need to find the shortest distance. These numbers can be the same.
The numbers in the lines are separated by single spaces.
|
Print a single number — the length of the shortest path between stations number *s* and *t*.
|
[
"4\n2 3 4 9\n1 3\n",
"4\n5 8 2 100\n4 1\n",
"3\n1 1 1\n3 1\n",
"3\n31 41 59\n1 1\n"
] |
[
"5\n",
"15\n",
"1\n",
"0\n"
] |
In the first sample the length of path 1 → 2 → 3 equals 5, the length of path 1 → 4 → 3 equals 13.
In the second sample the length of path 4 → 1 is 100, the length of path 4 → 3 → 2 → 1 is 15.
In the third sample the length of path 3 → 1 is 1, the length of path 3 → 2 → 1 is 2.
In the fourth sample the numbers of stations are the same, so the shortest distance equals 0.
| 500
|
[
{
"input": "4\n2 3 4 9\n1 3",
"output": "5"
},
{
"input": "4\n5 8 2 100\n4 1",
"output": "15"
},
{
"input": "3\n1 1 1\n3 1",
"output": "1"
},
{
"input": "3\n31 41 59\n1 1",
"output": "0"
},
{
"input": "5\n16 13 10 30 15\n4 2",
"output": "23"
},
{
"input": "6\n89 82 87 32 67 33\n4 4",
"output": "0"
},
{
"input": "7\n2 3 17 10 2 2 2\n4 2",
"output": "18"
},
{
"input": "3\n4 37 33\n3 3",
"output": "0"
},
{
"input": "8\n87 40 96 7 86 86 72 97\n6 8",
"output": "158"
},
{
"input": "10\n91 94 75 99 100 91 79 86 79 92\n2 8",
"output": "348"
},
{
"input": "19\n1 1 1 1 2 1 1 1 1 1 2 1 3 2 2 1 1 1 2\n7 7",
"output": "0"
},
{
"input": "34\n96 65 24 99 74 76 97 93 99 69 94 82 92 91 98 83 95 97 96 81 90 95 86 87 43 78 88 86 82 62 76 99 83 96\n21 16",
"output": "452"
},
{
"input": "50\n75 98 65 75 99 89 84 65 9 53 62 61 61 53 80 7 6 47 86 1 89 27 67 1 31 39 53 92 19 20 76 41 60 15 29 94 76 82 87 89 93 38 42 6 87 36 100 97 93 71\n2 6",
"output": "337"
},
{
"input": "99\n1 15 72 78 23 22 26 98 7 2 75 58 100 98 45 79 92 69 79 72 33 88 62 9 15 87 17 73 68 54 34 89 51 91 28 44 20 11 74 7 85 61 30 46 95 72 36 18 48 22 42 46 29 46 86 53 96 55 98 34 60 37 75 54 1 81 20 68 84 19 18 18 75 84 86 57 73 34 23 43 81 87 47 96 57 41 69 1 52 44 54 7 85 35 5 1 19 26 7\n4 64",
"output": "1740"
},
{
"input": "100\n33 63 21 27 49 82 86 93 43 55 4 72 89 85 5 34 80 7 23 13 21 49 22 73 89 65 81 25 6 92 82 66 58 88 48 96 1 1 16 48 67 96 84 63 87 76 20 100 36 4 31 41 35 62 55 76 74 70 68 41 4 16 39 81 2 41 34 73 66 57 41 89 78 93 68 96 87 47 92 60 40 58 81 12 19 74 56 83 56 61 83 97 26 92 62 52 39 57 89 95\n71 5",
"output": "2127"
},
{
"input": "100\n95 98 99 81 98 96 100 92 96 90 99 91 98 98 91 78 97 100 96 98 87 93 96 99 91 92 96 92 90 97 85 83 99 95 66 91 87 89 100 95 100 88 99 84 96 79 99 100 94 100 99 99 92 89 99 91 100 94 98 97 91 92 90 87 84 99 97 98 93 100 90 85 75 95 86 71 98 93 91 87 92 95 98 94 95 94 100 98 96 100 97 96 95 95 86 86 94 97 98 96\n67 57",
"output": "932"
},
{
"input": "100\n100 100 100 100 100 100 100 100 100 100 97 100 100 100 100 100 99 100 100 99 99 100 99 100 100 100 100 100 100 100 100 100 97 99 98 98 100 98 98 100 99 100 100 100 100 99 100 98 100 99 98 99 98 98 100 100 100 100 100 100 100 100 100 100 99 100 100 100 100 100 98 100 99 99 100 96 100 96 100 99 100 100 99 100 99 100 100 100 99 100 100 100 100 98 98 97 100 100 99 98\n16 6",
"output": "997"
},
{
"input": "100\n3 6 23 4 23 1 2 14 2 3 3 9 17 8 10 5 1 14 8 5 7 4 13 8 5 6 24 3 12 3 4 9 2 8 2 1 2 1 3 2 1 6 14 23 8 6 3 5 7 8 18 9 2 5 22 6 13 16 2 4 31 20 4 3 3 6 6 1 1 18 5 11 1 14 4 16 6 37 11 1 8 3 7 11 21 14 3 3 12 2 5 1 9 16 3 1 3 4 4 2\n98 24",
"output": "195"
},
{
"input": "100\n1 1 3 1 1 2 1 2 1 1 2 2 2 1 1 1 1 1 1 3 1 1 1 3 1 3 3 1 1 2 1 1 1 1 1 2 1 1 1 4 1 1 3 3 2 1 1 1 1 1 2 2 1 3 1 1 1 2 4 1 1 2 5 2 1 1 2 1 1 1 2 3 1 1 1 1 2 1 1 1 1 2 1 1 1 1 1 2 2 3 1 7 3 1 3 1 2 1 2 1\n49 10",
"output": "60"
},
{
"input": "100\n75 62 31 96 62 76 93 96 72 67 88 35 67 34 60 56 95 86 82 48 64 61 74 100 56 98 76 98 78 55 53 10 12 78 58 45 86 90 93 77 69 73 88 66 92 88 33 50 95 69 89 12 93 57 93 89 59 53 71 86 15 13 61 93 24 100 58 76 46 95 76 82 50 20 79 38 5 72 99 81 55 90 90 65 85 44 63 39 6 34 98 72 88 30 59 73 84 61 25 67\n86 25",
"output": "2523"
},
{
"input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100\n1 51",
"output": "5000"
},
{
"input": "4\n1 1 1 1\n2 4",
"output": "2"
},
{
"input": "4\n1 1 2 1\n2 4",
"output": "2"
}
] | 1,676,464,514
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 23
| 122
| 0
|
n = int(input())
l = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
print(min(sum(l[:x[0] - 1]) + sum(l[x[1] - 1:]), sum(l[x[0] - 1:x[1] - 1])))
|
Title: Circle Line
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The circle line of the Berland subway has *n* stations. We know the distances between all pairs of neighboring stations:
- *d*1 is the distance between the 1-st and the 2-nd station;- *d*2 is the distance between the 2-nd and the 3-rd station;...- *d**n*<=-<=1 is the distance between the *n*<=-<=1-th and the *n*-th station;- *d**n* is the distance between the *n*-th and the 1-st station.
The trains go along the circle line in both directions. Find the shortest distance between stations with numbers *s* and *t*.
Input Specification:
The first line contains integer *n* (3<=≤<=*n*<=≤<=100) — the number of stations on the circle line. The second line contains *n* integers *d*1,<=*d*2,<=...,<=*d**n* (1<=≤<=*d**i*<=≤<=100) — the distances between pairs of neighboring stations. The third line contains two integers *s* and *t* (1<=≤<=*s*,<=*t*<=≤<=*n*) — the numbers of stations, between which you need to find the shortest distance. These numbers can be the same.
The numbers in the lines are separated by single spaces.
Output Specification:
Print a single number — the length of the shortest path between stations number *s* and *t*.
Demo Input:
['4\n2 3 4 9\n1 3\n', '4\n5 8 2 100\n4 1\n', '3\n1 1 1\n3 1\n', '3\n31 41 59\n1 1\n']
Demo Output:
['5\n', '15\n', '1\n', '0\n']
Note:
In the first sample the length of path 1 → 2 → 3 equals 5, the length of path 1 → 4 → 3 equals 13.
In the second sample the length of path 4 → 1 is 100, the length of path 4 → 3 → 2 → 1 is 15.
In the third sample the length of path 3 → 1 is 1, the length of path 3 → 2 → 1 is 2.
In the fourth sample the numbers of stations are the same, so the shortest distance equals 0.
|
```python
n = int(input())
l = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
print(min(sum(l[:x[0] - 1]) + sum(l[x[1] - 1:]), sum(l[x[0] - 1:x[1] - 1])))
```
| 3
|
|
785
|
A
|
Anton and Polyhedrons
|
PROGRAMMING
| 800
|
[
"implementation",
"strings"
] | null | null |
Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons:
- Tetrahedron. Tetrahedron has 4 triangular faces. - Cube. Cube has 6 square faces. - Octahedron. Octahedron has 8 triangular faces. - Dodecahedron. Dodecahedron has 12 pentagonal faces. - Icosahedron. Icosahedron has 20 triangular faces.
All five kinds of polyhedrons are shown on the picture below:
Anton has a collection of *n* polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!
|
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of polyhedrons in Anton's collection.
Each of the following *n* lines of the input contains a string *s**i* — the name of the *i*-th polyhedron in Anton's collection. The string can look like this:
- "Tetrahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is a tetrahedron. - "Cube" (without quotes), if the *i*-th polyhedron in Anton's collection is a cube. - "Octahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is an octahedron. - "Dodecahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is a dodecahedron. - "Icosahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is an icosahedron.
|
Output one number — the total number of faces in all the polyhedrons in Anton's collection.
|
[
"4\nIcosahedron\nCube\nTetrahedron\nDodecahedron\n",
"3\nDodecahedron\nOctahedron\nOctahedron\n"
] |
[
"42\n",
"28\n"
] |
In the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.
| 500
|
[
{
"input": "4\nIcosahedron\nCube\nTetrahedron\nDodecahedron",
"output": "42"
},
{
"input": "3\nDodecahedron\nOctahedron\nOctahedron",
"output": "28"
},
{
"input": "25\nIcosahedron\nOctahedron\nTetrahedron\nDodecahedron\nCube\nIcosahedron\nOctahedron\nCube\nTetrahedron\nIcosahedron\nIcosahedron\nTetrahedron\nOctahedron\nDodecahedron\nIcosahedron\nOctahedron\nIcosahedron\nTetrahedron\nDodecahedron\nTetrahedron\nOctahedron\nCube\nCube\nDodecahedron\nTetrahedron",
"output": "256"
},
{
"input": "1\nTetrahedron",
"output": "4"
},
{
"input": "1\nCube",
"output": "6"
},
{
"input": "1\nOctahedron",
"output": "8"
},
{
"input": "1\nDodecahedron",
"output": "12"
},
{
"input": "1\nIcosahedron",
"output": "20"
},
{
"input": "28\nOctahedron\nDodecahedron\nOctahedron\nOctahedron\nDodecahedron\nIcosahedron\nIcosahedron\nDodecahedron\nDodecahedron\nDodecahedron\nCube\nDodecahedron\nCube\nTetrahedron\nCube\nCube\nTetrahedron\nDodecahedron\nDodecahedron\nDodecahedron\nIcosahedron\nIcosahedron\nDodecahedron\nIcosahedron\nDodecahedron\nDodecahedron\nIcosahedron\nIcosahedron",
"output": "340"
}
] | 1,683,312,649
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 30
| 233
| 0
|
x = int(input())
counter = 0
for poly in range(x):
p = str(input())
if p == "Tetrahedron":
counter += 4
elif p == "Cube":
counter +=6
elif p == "Octahedron":
counter += 8
elif p == "Dodecahedron":
counter += 12
elif p == "Icosahedron":
counter += 20
print(counter)
|
Title: Anton and Polyhedrons
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Anton's favourite geometric figures are regular polyhedrons. Note that there are five kinds of regular polyhedrons:
- Tetrahedron. Tetrahedron has 4 triangular faces. - Cube. Cube has 6 square faces. - Octahedron. Octahedron has 8 triangular faces. - Dodecahedron. Dodecahedron has 12 pentagonal faces. - Icosahedron. Icosahedron has 20 triangular faces.
All five kinds of polyhedrons are shown on the picture below:
Anton has a collection of *n* polyhedrons. One day he decided to know, how many faces his polyhedrons have in total. Help Anton and find this number!
Input Specification:
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=200<=000) — the number of polyhedrons in Anton's collection.
Each of the following *n* lines of the input contains a string *s**i* — the name of the *i*-th polyhedron in Anton's collection. The string can look like this:
- "Tetrahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is a tetrahedron. - "Cube" (without quotes), if the *i*-th polyhedron in Anton's collection is a cube. - "Octahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is an octahedron. - "Dodecahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is a dodecahedron. - "Icosahedron" (without quotes), if the *i*-th polyhedron in Anton's collection is an icosahedron.
Output Specification:
Output one number — the total number of faces in all the polyhedrons in Anton's collection.
Demo Input:
['4\nIcosahedron\nCube\nTetrahedron\nDodecahedron\n', '3\nDodecahedron\nOctahedron\nOctahedron\n']
Demo Output:
['42\n', '28\n']
Note:
In the first sample Anton has one icosahedron, one cube, one tetrahedron and one dodecahedron. Icosahedron has 20 faces, cube has 6 faces, tetrahedron has 4 faces and dodecahedron has 12 faces. In total, they have 20 + 6 + 4 + 12 = 42 faces.
|
```python
x = int(input())
counter = 0
for poly in range(x):
p = str(input())
if p == "Tetrahedron":
counter += 4
elif p == "Cube":
counter +=6
elif p == "Octahedron":
counter += 8
elif p == "Dodecahedron":
counter += 12
elif p == "Icosahedron":
counter += 20
print(counter)
```
| 3
|
|
488
|
A
|
Giga Tower
|
PROGRAMMING
| 1,100
|
[
"brute force"
] | null | null |
Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view.
In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?).
Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.
|
The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).
|
Print the minimum *b* in a line.
|
[
"179\n",
"-1\n",
"18\n"
] |
[
"1\n",
"9\n",
"10\n"
] |
For the first sample, he has to arrive at the floor numbered 180.
For the second sample, he will arrive at 8.
Note that *b* should be positive, so the answer for the third sample is 10, not 0.
| 500
|
[
{
"input": "179",
"output": "1"
},
{
"input": "-1",
"output": "9"
},
{
"input": "18",
"output": "10"
},
{
"input": "-410058385",
"output": "1"
},
{
"input": "-586825624",
"output": "1"
},
{
"input": "852318890",
"output": "1"
},
{
"input": "919067153",
"output": "5"
},
{
"input": "690422411",
"output": "7"
},
{
"input": "-408490162",
"output": "1"
},
{
"input": "-8",
"output": "16"
},
{
"input": "-6",
"output": "14"
},
{
"input": "-4",
"output": "12"
},
{
"input": "-2",
"output": "10"
},
{
"input": "0",
"output": "8"
},
{
"input": "2",
"output": "6"
},
{
"input": "4",
"output": "4"
},
{
"input": "6",
"output": "2"
},
{
"input": "8",
"output": "10"
},
{
"input": "1000000000",
"output": "8"
},
{
"input": "-1000000000",
"output": "2"
},
{
"input": "88888",
"output": "1"
},
{
"input": "89",
"output": "9"
},
{
"input": "-80000000",
"output": "2"
},
{
"input": "-8888",
"output": "1"
},
{
"input": "-17",
"output": "9"
},
{
"input": "78",
"output": "2"
},
{
"input": "-19",
"output": "1"
},
{
"input": "-999999998",
"output": "9"
},
{
"input": "-999999997",
"output": "8"
},
{
"input": "999999997",
"output": "1"
},
{
"input": "811111111",
"output": "1"
},
{
"input": "-8",
"output": "16"
},
{
"input": "-5",
"output": "13"
},
{
"input": "-7",
"output": "15"
},
{
"input": "1000000000",
"output": "8"
}
] | 1,462,162,748
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 35
| 77
| 4,915,200
|
a, b = int(input()), 1
while str(a+b).find('8') == -1:
b += 1
print(b)
|
Title: Giga Tower
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view.
In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?).
Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.
Input Specification:
The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).
Output Specification:
Print the minimum *b* in a line.
Demo Input:
['179\n', '-1\n', '18\n']
Demo Output:
['1\n', '9\n', '10\n']
Note:
For the first sample, he has to arrive at the floor numbered 180.
For the second sample, he will arrive at 8.
Note that *b* should be positive, so the answer for the third sample is 10, not 0.
|
```python
a, b = int(input()), 1
while str(a+b).find('8') == -1:
b += 1
print(b)
```
| 3
|
|
486
|
A
|
Calculating Function
|
PROGRAMMING
| 800
|
[
"implementation",
"math"
] | null | null |
For a positive integer *n* let's define a function *f*:
*f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n*
Your task is to calculate *f*(*n*) for a given integer *n*.
|
The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015).
|
Print *f*(*n*) in a single line.
|
[
"4\n",
"5\n"
] |
[
"2\n",
"-3\n"
] |
*f*(4) = - 1 + 2 - 3 + 4 = 2
*f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3
| 500
|
[
{
"input": "4",
"output": "2"
},
{
"input": "5",
"output": "-3"
},
{
"input": "1000000000",
"output": "500000000"
},
{
"input": "1000000001",
"output": "-500000001"
},
{
"input": "1000000000000000",
"output": "500000000000000"
},
{
"input": "100",
"output": "50"
},
{
"input": "101",
"output": "-51"
},
{
"input": "102",
"output": "51"
},
{
"input": "103",
"output": "-52"
},
{
"input": "104",
"output": "52"
},
{
"input": "105",
"output": "-53"
},
{
"input": "106",
"output": "53"
},
{
"input": "107",
"output": "-54"
},
{
"input": "108",
"output": "54"
},
{
"input": "109",
"output": "-55"
},
{
"input": "208170109961052",
"output": "104085054980526"
},
{
"input": "46017661651072",
"output": "23008830825536"
},
{
"input": "4018154546667",
"output": "-2009077273334"
},
{
"input": "288565475053",
"output": "-144282737527"
},
{
"input": "3052460231",
"output": "-1526230116"
},
{
"input": "29906716",
"output": "14953358"
},
{
"input": "87897701693326",
"output": "43948850846663"
},
{
"input": "8240",
"output": "4120"
},
{
"input": "577935",
"output": "-288968"
},
{
"input": "62",
"output": "31"
},
{
"input": "1",
"output": "-1"
},
{
"input": "2",
"output": "1"
},
{
"input": "9999999999999",
"output": "-5000000000000"
},
{
"input": "1000000000000",
"output": "500000000000"
},
{
"input": "99999999999999",
"output": "-50000000000000"
},
{
"input": "999999999999999",
"output": "-500000000000000"
},
{
"input": "42191359342",
"output": "21095679671"
},
{
"input": "100000000000000",
"output": "50000000000000"
},
{
"input": "145645214654154",
"output": "72822607327077"
},
{
"input": "4294967296",
"output": "2147483648"
},
{
"input": "3037000499",
"output": "-1518500250"
},
{
"input": "10000000000001",
"output": "-5000000000001"
},
{
"input": "100000017040846",
"output": "50000008520423"
},
{
"input": "98979894985999",
"output": "-49489947493000"
}
] | 1,697,335,468
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 2
| 1,000
| 0
|
n = int(input())
final = 0
x = 1
for i in range(1, n+1):
if (x % 2 == 0):
final += i
else:
final -= i
x += 1
print(final)
|
Title: Calculating Function
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
For a positive integer *n* let's define a function *f*:
*f*(*n*)<==<=<=-<=1<=+<=2<=-<=3<=+<=..<=+<=(<=-<=1)*n**n*
Your task is to calculate *f*(*n*) for a given integer *n*.
Input Specification:
The single line contains the positive integer *n* (1<=≤<=*n*<=≤<=1015).
Output Specification:
Print *f*(*n*) in a single line.
Demo Input:
['4\n', '5\n']
Demo Output:
['2\n', '-3\n']
Note:
*f*(4) = - 1 + 2 - 3 + 4 = 2
*f*(5) = - 1 + 2 - 3 + 4 - 5 = - 3
|
```python
n = int(input())
final = 0
x = 1
for i in range(1, n+1):
if (x % 2 == 0):
final += i
else:
final -= i
x += 1
print(final)
```
| 0
|
|
897
|
B
|
Chtholly's request
|
PROGRAMMING
| 1,300
|
[
"brute force"
] | null | null |
— I experienced so many great things.
— You gave me memories like dreams... But I have to leave now...
— One last request, can you...
— Help me solve a Codeforces problem?
— ......
— What?
Chtholly has been thinking about a problem for days:
If a number is palindrome and length of its decimal representation without leading zeros is even, we call it a zcy number. A number is palindrome means when written in decimal representation, it contains no leading zeros and reads the same forwards and backwards. For example 12321 and 1221 are palindromes and 123 and 12451 are not. Moreover, 1221 is zcy number and 12321 is not.
Given integers *k* and *p*, calculate the sum of the *k* smallest zcy numbers and output this sum modulo *p*.
Unfortunately, Willem isn't good at solving this kind of problems, so he asks you for help!
|
The first line contains two integers *k* and *p* (1<=≤<=*k*<=≤<=105,<=1<=≤<=*p*<=≤<=109).
|
Output single integer — answer to the problem.
|
[
"2 100\n",
"5 30\n"
] |
[
"33\n",
"15\n"
] |
In the first example, the smallest zcy number is 11, and the second smallest zcy number is 22.
In the second example, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/68fffad54395f7d920ad0384e07c6215ddc64141.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
| 1,000
|
[
{
"input": "2 100",
"output": "33"
},
{
"input": "5 30",
"output": "15"
},
{
"input": "42147 412393322",
"output": "251637727"
},
{
"input": "77809 868097296",
"output": "440411873"
},
{
"input": "5105 443422097",
"output": "363192634"
},
{
"input": "75615 376679484",
"output": "373089399"
},
{
"input": "22951 23793302",
"output": "1898631"
},
{
"input": "12785 993582106",
"output": "286204743"
},
{
"input": "60276 428978808",
"output": "376477293"
},
{
"input": "84776 104860385",
"output": "10209596"
},
{
"input": "41984 653766991",
"output": "17823101"
},
{
"input": "100000 1000000000",
"output": "495495496"
},
{
"input": "41163 472310076",
"output": "207304047"
},
{
"input": "6983 765352180",
"output": "586866999"
},
{
"input": "33493 967727004",
"output": "305705165"
},
{
"input": "90898 94010922",
"output": "65928728"
},
{
"input": "67298 349286579",
"output": "156435206"
},
{
"input": "92452 296773064",
"output": "229486976"
},
{
"input": "58832 563860457",
"output": "16775206"
},
{
"input": "90234 156145441",
"output": "44023160"
},
{
"input": "91454 977186148",
"output": "681779748"
},
{
"input": "11108 444095250",
"output": "188075844"
},
{
"input": "46304 584475527",
"output": "275627129"
},
{
"input": "1 1",
"output": "0"
},
{
"input": "1 1000000000",
"output": "11"
},
{
"input": "100000 1",
"output": "0"
}
] | 1,512,724,024
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 26
| 156
| 5,529,600
|
n, m = map(int, input().split())
sm = 0
for i in range(1, n + 1):
s = str(i)
sm += int(s + s[::-1])
print(sm % m)
|
Title: Chtholly's request
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
— I experienced so many great things.
— You gave me memories like dreams... But I have to leave now...
— One last request, can you...
— Help me solve a Codeforces problem?
— ......
— What?
Chtholly has been thinking about a problem for days:
If a number is palindrome and length of its decimal representation without leading zeros is even, we call it a zcy number. A number is palindrome means when written in decimal representation, it contains no leading zeros and reads the same forwards and backwards. For example 12321 and 1221 are palindromes and 123 and 12451 are not. Moreover, 1221 is zcy number and 12321 is not.
Given integers *k* and *p*, calculate the sum of the *k* smallest zcy numbers and output this sum modulo *p*.
Unfortunately, Willem isn't good at solving this kind of problems, so he asks you for help!
Input Specification:
The first line contains two integers *k* and *p* (1<=≤<=*k*<=≤<=105,<=1<=≤<=*p*<=≤<=109).
Output Specification:
Output single integer — answer to the problem.
Demo Input:
['2 100\n', '5 30\n']
Demo Output:
['33\n', '15\n']
Note:
In the first example, the smallest zcy number is 11, and the second smallest zcy number is 22.
In the second example, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/68fffad54395f7d920ad0384e07c6215ddc64141.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
|
```python
n, m = map(int, input().split())
sm = 0
for i in range(1, n + 1):
s = str(i)
sm += int(s + s[::-1])
print(sm % m)
```
| 3
|
|
92
|
B
|
Binary Number
|
PROGRAMMING
| 1,300
|
[
"greedy"
] |
B. Binary Number
|
1
|
256
|
Little walrus Fangy loves math very much. That's why when he is bored he plays with a number performing some operations.
Fangy takes some positive integer *x* and wants to get a number one from it. While *x* is not equal to 1, Fangy repeats the following action: if *x* is odd, then he adds 1 to it, otherwise he divides *x* by 2. Fangy knows that for any positive integer number the process ends in finite time.
How many actions should Fangy perform to get a number one from number *x*?
|
The first line contains a positive integer *x* in a binary system. It is guaranteed that the first digit of *x* is different from a zero and the number of its digits does not exceed 106.
|
Print the required number of actions.
|
[
"1\n",
"1001001\n",
"101110\n"
] |
[
"0\n",
"12\n",
"8\n"
] |
Let's consider the third sample. Number 101110 is even, which means that we should divide it by 2. After the dividing Fangy gets an odd number 10111 and adds one to it. Number 11000 can be divided by 2 three times in a row and get number 11. All that's left is to increase the number by one (we get 100), and then divide it by 2 two times in a row. As a result, we get 1.
| 1,000
|
[
{
"input": "1",
"output": "0"
},
{
"input": "1001001",
"output": "12"
},
{
"input": "101110",
"output": "8"
},
{
"input": "11",
"output": "3"
},
{
"input": "11110001101",
"output": "16"
},
{
"input": "1010101001001111000111110011111000010101011111101010",
"output": "74"
},
{
"input": "1100000010010100111011100011110101111",
"output": "55"
},
{
"input": "11000111111110110110100110110101111100010100110110010",
"output": "74"
},
{
"input": "11100000110100011110101001101111100000011001111000011110000000111110111",
"output": "106"
},
{
"input": "1000101100110000000001111010110000000010001001111110011011000011101011001001010010111",
"output": "133"
},
{
"input": "1000000000000000000000000000000000000000000000000000000000000000000000000",
"output": "72"
},
{
"input": "10000100000",
"output": "16"
}
] | 1,608,449,043
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 8
| 108
| 0
|
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 20 15:08:58 2020
@author: user
Link :https://codeforces.com/contest/92/problem/Bhttps://codeforces.com/contest/92/problem/B
"""
b = int(input(),2)
cnt = 0
while b != 1:
if b %2 == 0:
b/=2
cnt+=1
else:
b += 1
cnt+=1
print(cnt)
|
Title: Binary Number
Time Limit: 1 seconds
Memory Limit: 256 megabytes
Problem Description:
Little walrus Fangy loves math very much. That's why when he is bored he plays with a number performing some operations.
Fangy takes some positive integer *x* and wants to get a number one from it. While *x* is not equal to 1, Fangy repeats the following action: if *x* is odd, then he adds 1 to it, otherwise he divides *x* by 2. Fangy knows that for any positive integer number the process ends in finite time.
How many actions should Fangy perform to get a number one from number *x*?
Input Specification:
The first line contains a positive integer *x* in a binary system. It is guaranteed that the first digit of *x* is different from a zero and the number of its digits does not exceed 106.
Output Specification:
Print the required number of actions.
Demo Input:
['1\n', '1001001\n', '101110\n']
Demo Output:
['0\n', '12\n', '8\n']
Note:
Let's consider the third sample. Number 101110 is even, which means that we should divide it by 2. After the dividing Fangy gets an odd number 10111 and adds one to it. Number 11000 can be divided by 2 three times in a row and get number 11. All that's left is to increase the number by one (we get 100), and then divide it by 2 two times in a row. As a result, we get 1.
|
```python
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 20 15:08:58 2020
@author: user
Link :https://codeforces.com/contest/92/problem/Bhttps://codeforces.com/contest/92/problem/B
"""
b = int(input(),2)
cnt = 0
while b != 1:
if b %2 == 0:
b/=2
cnt+=1
else:
b += 1
cnt+=1
print(cnt)
```
| 0
|
681
|
A
|
A Good Contest
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Codeforces user' handle color depends on his rating — it is red if his rating is greater or equal to 2400; it is orange if his rating is less than 2400 but greater or equal to 2200, etc. Each time participant takes part in a rated contest, his rating is changed depending on his performance.
Anton wants the color of his handle to become red. He considers his performance in the rated contest to be good if he outscored some participant, whose handle was colored red before the contest and his rating has increased after it.
Anton has written a program that analyses contest results and determines whether he performed good or not. Are you able to do the same?
|
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of participants Anton has outscored in this contest .
The next *n* lines describe participants results: the *i*-th of them consists of a participant handle *name**i* and two integers *before**i* and *after**i* (<=-<=4000<=≤<=*before**i*,<=*after**i*<=≤<=4000) — participant's rating before and after the contest, respectively. Each handle is a non-empty string, consisting of no more than 10 characters, which might be lowercase and uppercase English letters, digits, characters «_» and «-» characters.
It is guaranteed that all handles are distinct.
|
Print «YES» (quotes for clarity), if Anton has performed good in the contest and «NO» (quotes for clarity) otherwise.
|
[
"3\nBurunduk1 2526 2537\nBudAlNik 2084 2214\nsubscriber 2833 2749\n",
"3\nApplejack 2400 2400\nFluttershy 2390 2431\nPinkie_Pie -2500 -2450\n"
] |
[
"YES",
"NO"
] |
In the first sample, Anton has outscored user with handle Burunduk1, whose handle was colored red before the contest and his rating has increased after the contest.
In the second sample, Applejack's rating has not increased after the contest, while both Fluttershy's and Pinkie_Pie's handles were not colored red before the contest.
| 500
|
[
{
"input": "3\nBurunduk1 2526 2537\nBudAlNik 2084 2214\nsubscriber 2833 2749",
"output": "YES"
},
{
"input": "3\nApplejack 2400 2400\nFluttershy 2390 2431\nPinkie_Pie -2500 -2450",
"output": "NO"
},
{
"input": "1\nDb -3373 3591",
"output": "NO"
},
{
"input": "5\nQ2bz 960 2342\nhmX 2710 -1348\ngbAe -1969 -963\nE -160 196\npsi 2665 -3155",
"output": "NO"
},
{
"input": "9\nmwAz9lQ 1786 -1631\nnYgYFXZQfY -1849 -1775\nKU4jF -1773 -3376\nopR 3752 2931\nGl -1481 -1002\nR -1111 3778\n0i9B21DC 3650 289\nQ8L2dS0 358 -3305\ng -2662 3968",
"output": "NO"
},
{
"input": "5\nzMSBcOUf -2883 -2238\nYN -3314 -1480\nfHpuccQn06 -1433 -589\naM1NVEPQi 399 3462\n_L 2516 -3290",
"output": "NO"
},
{
"input": "1\na 2400 2401",
"output": "YES"
},
{
"input": "1\nfucker 4000 4000",
"output": "NO"
},
{
"input": "1\nJora 2400 2401",
"output": "YES"
},
{
"input": "1\nACA 2400 2420",
"output": "YES"
},
{
"input": "1\nAca 2400 2420",
"output": "YES"
},
{
"input": "1\nSub_d 2401 2402",
"output": "YES"
},
{
"input": "2\nHack 2400 2401\nDum 1243 555",
"output": "YES"
},
{
"input": "1\nXXX 2400 2500",
"output": "YES"
},
{
"input": "1\nfucker 2400 2401",
"output": "YES"
},
{
"input": "1\nX 2400 2500",
"output": "YES"
},
{
"input": "1\nvineet 2400 2401",
"output": "YES"
},
{
"input": "1\nabc 2400 2500",
"output": "YES"
},
{
"input": "1\naaaaa 2400 2401",
"output": "YES"
},
{
"input": "1\nhoge 2400 2401",
"output": "YES"
},
{
"input": "1\nInfinity 2400 2468",
"output": "YES"
},
{
"input": "1\nBurunduk1 2400 2401",
"output": "YES"
},
{
"input": "1\nFuck 2400 2401",
"output": "YES"
},
{
"input": "1\nfuck 2400 2401",
"output": "YES"
},
{
"input": "3\nApplejack 2400 2401\nFluttershy 2390 2431\nPinkie_Pie -2500 -2450",
"output": "YES"
},
{
"input": "1\nalex 2400 2401",
"output": "YES"
},
{
"input": "1\nA 2400 2401",
"output": "YES"
},
{
"input": "1\na 2400 2455",
"output": "YES"
},
{
"input": "1\nlol 2400 2401",
"output": "YES"
},
{
"input": "2\nBurunduk1 2400 2537\nBudAlNik 2084 2214",
"output": "YES"
},
{
"input": "1\naaaaaa 2400 2401",
"output": "YES"
},
{
"input": "1\nBurunduk1 2400 2500",
"output": "YES"
},
{
"input": "1\nds 2400 2410",
"output": "YES"
},
{
"input": "1\nas 2400 2401",
"output": "YES"
},
{
"input": "1\nabc 2400 2401",
"output": "YES"
},
{
"input": "3\nBudAlNik 2084 2214\nsubscriber 2833 2749\nBurunduk1 2526 2537",
"output": "YES"
},
{
"input": "1\ncaonima 2400 2401",
"output": "YES"
},
{
"input": "1\narr 2400 2500",
"output": "YES"
},
{
"input": "1\nx 2400 2401",
"output": "YES"
},
{
"input": "1\narrr 2400 2500",
"output": "YES"
},
{
"input": "1\nabc 2400 2405",
"output": "YES"
},
{
"input": "3\nBurunduk1 2400 2420\nBudAlNik 2084 2214\nsubscriber 2833 2749",
"output": "YES"
},
{
"input": "1\nBurunduk1 2400 2537",
"output": "YES"
},
{
"input": "1\nHELLO 2400 2401",
"output": "YES"
},
{
"input": "1\neatmore 2400 2500",
"output": "YES"
},
{
"input": "1\nb 2400 2401",
"output": "YES"
},
{
"input": "3\nBurunduk1 2400 2537\nBudAlNik 2084 2214\nsubscriber 2833 2749",
"output": "YES"
},
{
"input": "1\nApplejack 2400 2410",
"output": "YES"
},
{
"input": "1\nabacaba 2400 2451",
"output": "YES"
},
{
"input": "1\nrekt_n00b 2500 2600",
"output": "YES"
}
] | 1,663,637,014
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 60
| 46
| 0
|
n = int(input())
res = "NO"
for _ in range(n):
_, b, a = (x if i == 0 else int(x) for i, x in enumerate(input().split()))
if a > b >= 2400:
res = "YES"
print(res)
|
Title: A Good Contest
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Codeforces user' handle color depends on his rating — it is red if his rating is greater or equal to 2400; it is orange if his rating is less than 2400 but greater or equal to 2200, etc. Each time participant takes part in a rated contest, his rating is changed depending on his performance.
Anton wants the color of his handle to become red. He considers his performance in the rated contest to be good if he outscored some participant, whose handle was colored red before the contest and his rating has increased after it.
Anton has written a program that analyses contest results and determines whether he performed good or not. Are you able to do the same?
Input Specification:
The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of participants Anton has outscored in this contest .
The next *n* lines describe participants results: the *i*-th of them consists of a participant handle *name**i* and two integers *before**i* and *after**i* (<=-<=4000<=≤<=*before**i*,<=*after**i*<=≤<=4000) — participant's rating before and after the contest, respectively. Each handle is a non-empty string, consisting of no more than 10 characters, which might be lowercase and uppercase English letters, digits, characters «_» and «-» characters.
It is guaranteed that all handles are distinct.
Output Specification:
Print «YES» (quotes for clarity), if Anton has performed good in the contest and «NO» (quotes for clarity) otherwise.
Demo Input:
['3\nBurunduk1 2526 2537\nBudAlNik 2084 2214\nsubscriber 2833 2749\n', '3\nApplejack 2400 2400\nFluttershy 2390 2431\nPinkie_Pie -2500 -2450\n']
Demo Output:
['YES', 'NO']
Note:
In the first sample, Anton has outscored user with handle Burunduk1, whose handle was colored red before the contest and his rating has increased after the contest.
In the second sample, Applejack's rating has not increased after the contest, while both Fluttershy's and Pinkie_Pie's handles were not colored red before the contest.
|
```python
n = int(input())
res = "NO"
for _ in range(n):
_, b, a = (x if i == 0 else int(x) for i, x in enumerate(input().split()))
if a > b >= 2400:
res = "YES"
print(res)
```
| 3
|
|
895
|
A
|
Pizza Separation
|
PROGRAMMING
| 1,200
|
[
"brute force",
"implementation"
] | null | null |
Students Vasya and Petya are studying at the BSU (Byteland State University). At one of the breaks they decided to order a pizza. In this problem pizza is a circle of some radius. The pizza was delivered already cut into *n* pieces. The *i*-th piece is a sector of angle equal to *a**i*. Vasya and Petya want to divide all pieces of pizza into two continuous sectors in such way that the difference between angles of these sectors is minimal. Sector angle is sum of angles of all pieces in it. Pay attention, that one of sectors can be empty.
|
The first line contains one integer *n* (1<=≤<=*n*<=≤<=360) — the number of pieces into which the delivered pizza was cut.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=360) — the angles of the sectors into which the pizza was cut. The sum of all *a**i* is 360.
|
Print one integer — the minimal difference between angles of sectors that will go to Vasya and Petya.
|
[
"4\n90 90 90 90\n",
"3\n100 100 160\n",
"1\n360\n",
"4\n170 30 150 10\n"
] |
[
"0\n",
"40\n",
"360\n",
"0\n"
] |
In first sample Vasya can take 1 and 2 pieces, Petya can take 3 and 4 pieces. Then the answer is |(90 + 90) - (90 + 90)| = 0.
In third sample there is only one piece of pizza that can be taken by only one from Vasya and Petya. So the answer is |360 - 0| = 360.
In fourth sample Vasya can take 1 and 4 pieces, then Petya will take 2 and 3 pieces. So the answer is |(170 + 10) - (30 + 150)| = 0.
Picture explaning fourth sample:
<img class="tex-graphics" src="https://espresso.codeforces.com/4bb3450aca241f92fedcba5479bf1b6d22cf813d.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Both red and green sectors consist of two adjacent pieces of pizza. So Vasya can take green sector, then Petya will take red sector.
| 500
|
[
{
"input": "4\n90 90 90 90",
"output": "0"
},
{
"input": "3\n100 100 160",
"output": "40"
},
{
"input": "1\n360",
"output": "360"
},
{
"input": "4\n170 30 150 10",
"output": "0"
},
{
"input": "5\n10 10 10 10 320",
"output": "280"
},
{
"input": "8\n45 45 45 45 45 45 45 45",
"output": "0"
},
{
"input": "3\n120 120 120",
"output": "120"
},
{
"input": "5\n110 90 70 50 40",
"output": "40"
},
{
"input": "2\n170 190",
"output": "20"
},
{
"input": "15\n25 25 25 25 25 25 25 25 25 25 25 25 25 25 10",
"output": "10"
},
{
"input": "5\n30 60 180 60 30",
"output": "0"
},
{
"input": "2\n359 1",
"output": "358"
},
{
"input": "5\n100 100 30 100 30",
"output": "40"
},
{
"input": "5\n36 34 35 11 244",
"output": "128"
},
{
"input": "5\n96 94 95 71 4",
"output": "18"
},
{
"input": "2\n85 275",
"output": "190"
},
{
"input": "3\n281 67 12",
"output": "202"
},
{
"input": "5\n211 113 25 9 2",
"output": "62"
},
{
"input": "13\n286 58 6 1 1 1 1 1 1 1 1 1 1",
"output": "212"
},
{
"input": "15\n172 69 41 67 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "20\n226 96 2 20 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "92"
},
{
"input": "50\n148 53 32 11 4 56 8 2 5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "3\n1 1 358",
"output": "356"
},
{
"input": "20\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 341",
"output": "322"
},
{
"input": "33\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 328",
"output": "296"
},
{
"input": "70\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 291",
"output": "222"
},
{
"input": "130\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 231",
"output": "102"
},
{
"input": "200\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 161",
"output": "0"
},
{
"input": "222\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 139",
"output": "0"
},
{
"input": "10\n8 3 11 4 1 10 10 1 8 304",
"output": "248"
},
{
"input": "12\n8 7 7 3 11 2 10 1 10 8 10 283",
"output": "206"
},
{
"input": "13\n10 8 9 10 5 9 4 1 10 11 1 7 275",
"output": "190"
},
{
"input": "14\n1 6 3 11 9 5 9 8 5 6 7 3 7 280",
"output": "200"
},
{
"input": "15\n10 11 5 4 11 5 4 1 5 4 5 5 9 6 275",
"output": "190"
},
{
"input": "30\n8 7 5 8 3 7 2 4 3 8 11 3 9 11 2 4 1 4 5 6 11 5 8 3 6 3 11 2 11 189",
"output": "18"
},
{
"input": "70\n5 3 6 8 9 2 8 9 11 5 2 8 9 11 7 6 6 9 7 11 7 6 3 8 2 4 4 8 4 3 2 2 3 5 6 5 11 2 7 7 5 8 10 5 2 1 10 9 4 10 7 1 8 10 9 1 5 1 1 1 2 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "29\n2 10 1 5 7 2 9 11 9 9 10 8 4 11 2 5 4 1 4 9 6 10 8 3 1 3 8 9 189",
"output": "18"
},
{
"input": "35\n3 4 11 4 4 2 3 4 3 9 7 10 2 7 8 3 11 3 6 4 6 7 11 10 8 7 6 7 2 8 5 3 2 2 168",
"output": "0"
},
{
"input": "60\n4 10 3 10 6 3 11 8 11 9 3 5 9 2 6 5 6 9 4 10 1 1 3 7 2 10 5 5 3 10 5 2 1 2 9 11 11 9 11 4 11 7 5 6 10 9 3 4 7 8 7 3 6 7 8 5 1 1 1 5",
"output": "0"
},
{
"input": "71\n3 11 8 1 10 1 7 9 6 4 11 10 11 2 4 1 11 7 9 10 11 4 8 7 11 3 8 4 1 8 4 2 9 9 7 10 10 9 5 7 9 7 2 1 7 6 5 11 5 9 4 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "63\n2 11 5 8 7 9 9 8 10 5 9 10 11 8 10 2 3 5 3 7 5 10 2 9 4 8 1 8 5 9 7 7 1 8 7 7 9 10 10 10 8 7 7 2 2 8 9 7 10 8 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "81\n5 8 7 11 2 7 1 1 5 8 7 2 3 11 4 9 7 6 4 4 2 1 1 7 9 4 1 8 3 1 4 10 7 9 9 8 11 3 4 3 10 8 6 4 7 2 4 3 6 11 11 10 7 10 2 10 8 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "47\n5 3 7 4 2 7 8 1 9 10 5 11 10 7 7 5 1 3 2 11 3 8 6 1 6 10 8 3 2 10 5 6 8 6 9 7 10 9 7 4 8 11 10 1 5 11 68",
"output": "0"
},
{
"input": "100\n5 8 9 3 2 3 9 8 11 10 4 8 1 1 1 1 6 5 10 9 5 3 7 7 2 11 10 2 3 2 2 8 7 3 5 5 10 9 2 5 10 6 7 7 4 7 7 8 2 8 9 9 2 4 1 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "120\n9 11 3 7 3 7 9 1 10 7 11 4 1 5 3 5 6 3 1 11 8 8 11 7 3 5 1 9 1 7 10 10 10 10 9 5 4 8 2 8 2 1 4 5 3 11 3 5 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "200\n7 7 9 8 2 8 5 8 3 9 7 10 2 9 11 8 11 7 5 2 6 3 11 9 5 1 10 2 1 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "220\n3 2 8 1 3 5 5 11 1 5 2 6 9 2 2 6 8 10 7 1 3 2 10 9 10 10 4 10 9 5 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1",
"output": "0"
},
{
"input": "6\n27 15 28 34 41 215",
"output": "70"
},
{
"input": "7\n41 38 41 31 22 41 146",
"output": "14"
},
{
"input": "8\n24 27 34 23 29 23 30 170",
"output": "20"
},
{
"input": "9\n11 11 20 20 33 32 35 26 172",
"output": "6"
},
{
"input": "10\n36 13 28 13 33 34 23 25 34 121",
"output": "0"
},
{
"input": "11\n19 37 13 41 37 15 32 12 19 35 100",
"output": "10"
},
{
"input": "12\n37 25 34 38 21 24 34 38 11 29 28 41",
"output": "2"
},
{
"input": "13\n24 40 20 26 25 29 39 29 35 28 19 18 28",
"output": "2"
},
{
"input": "14\n11 21 40 19 28 34 13 16 23 30 34 22 25 44",
"output": "4"
},
{
"input": "3\n95 91 174",
"output": "12"
},
{
"input": "4\n82 75 78 125",
"output": "46"
},
{
"input": "6\n87 75 88 94 15 1",
"output": "4"
},
{
"input": "10\n27 52 58 64 45 64 1 19 2 28",
"output": "12"
},
{
"input": "50\n14 12 11 8 1 6 11 6 7 8 4 11 4 5 7 3 5 4 7 24 10 2 3 4 6 13 2 1 8 7 5 13 10 8 5 20 1 2 23 7 14 3 4 4 2 8 8 2 6 1",
"output": "0"
},
{
"input": "100\n3 3 4 3 3 6 3 2 8 2 13 3 1 1 2 1 3 4 1 7 1 2 2 6 3 2 10 3 1 2 5 6 2 3 3 2 3 11 8 3 2 6 1 3 3 4 7 7 2 2 1 2 6 3 3 2 3 1 3 8 2 6 4 2 1 12 2 2 2 1 4 1 4 1 3 1 3 1 5 2 6 6 7 1 2 3 2 4 4 2 5 9 8 2 4 6 5 1 1 3",
"output": "0"
},
{
"input": "150\n1 5 1 2 2 2 1 4 2 2 2 3 1 2 1 2 2 2 2 1 2 2 2 1 5 3 4 1 3 4 5 2 4 2 1 2 2 1 1 2 3 2 4 2 2 3 3 1 1 5 2 3 2 1 9 2 1 1 2 1 4 1 1 3 2 2 2 1 2 2 2 1 3 3 4 2 2 1 3 3 3 1 4 3 4 1 2 2 1 1 1 2 2 5 4 1 1 1 2 1 2 3 2 2 6 3 3 3 1 2 1 1 2 8 2 2 4 3 4 5 3 1 4 2 2 2 2 1 4 4 1 1 2 2 4 9 6 3 1 1 2 1 3 4 1 3 2 2 2 1",
"output": "0"
},
{
"input": "200\n1 2 1 3 1 3 1 2 1 4 6 1 2 2 2 2 1 1 1 1 3 2 1 2 2 2 1 2 2 2 2 1 1 1 3 2 3 1 1 2 1 1 2 1 1 1 1 1 1 2 1 2 2 4 1 3 1 2 1 2 2 1 2 1 3 1 1 2 2 1 1 1 1 2 4 1 2 1 1 1 2 1 3 1 1 3 1 2 2 4 1 1 2 1 2 1 2 2 2 2 1 1 2 1 2 1 3 3 1 1 1 2 1 3 3 1 2 1 3 1 3 3 1 2 2 1 4 1 2 2 1 2 2 4 2 5 1 2 2 1 2 1 2 1 5 2 1 2 2 1 2 4 1 2 2 4 2 3 2 3 1 2 1 1 2 2 2 1 1 2 1 4 1 2 1 1 2 1 2 3 1 1 1 2 2 3 1 3 2 2 3 1 2 1 2 1 1 2 1 2",
"output": "0"
},
{
"input": "5\n35 80 45 100 100",
"output": "40"
},
{
"input": "4\n90 179 90 1",
"output": "2"
},
{
"input": "5\n50 50 20 160 80",
"output": "0"
},
{
"input": "5\n30 175 30 5 120",
"output": "10"
},
{
"input": "4\n170 30 10 150",
"output": "20"
},
{
"input": "6\n90 30 90 30 90 30",
"output": "60"
},
{
"input": "4\n70 80 110 100",
"output": "20"
},
{
"input": "7\n35 45 70 100 10 10 90",
"output": "0"
},
{
"input": "6\n50 90 10 90 20 100",
"output": "20"
},
{
"input": "6\n10 155 162 1 26 6",
"output": "18"
},
{
"input": "7\n80 90 80 45 10 10 45",
"output": "20"
},
{
"input": "4\n18 36 162 144",
"output": "36"
},
{
"input": "5\n20 50 50 160 80",
"output": "40"
},
{
"input": "5\n10 30 140 20 160",
"output": "0"
},
{
"input": "6\n90 80 60 50 40 40",
"output": "20"
},
{
"input": "9\n40 20 20 20 20 20 20 40 160",
"output": "40"
},
{
"input": "4\n90 54 90 126",
"output": "72"
},
{
"input": "4\n150 170 30 10",
"output": "20"
},
{
"input": "8\n130 12 13 85 41 67 5 7",
"output": "26"
},
{
"input": "7\n70 170 20 10 30 30 30",
"output": "20"
},
{
"input": "8\n100 100 50 50 15 15 15 15",
"output": "40"
},
{
"input": "4\n100 70 80 110",
"output": "20"
},
{
"input": "5\n160 130 40 20 10",
"output": "20"
},
{
"input": "4\n20 149 151 40",
"output": "22"
},
{
"input": "4\n100 10 100 150",
"output": "60"
},
{
"input": "6\n19 64 105 168 1 3",
"output": "16"
},
{
"input": "8\n10 10 70 70 90 90 10 10",
"output": "0"
}
] | 1,511,856,015
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 49
| 62
| 5,529,600
|
n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
sumr=a[0]
suml=0
for i in range(1,n):
#print(sumr,suml)
if sumr>suml:
suml+=a[i]
else:
sumr+=a[i]
print(abs(sumr-suml))
|
Title: Pizza Separation
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Students Vasya and Petya are studying at the BSU (Byteland State University). At one of the breaks they decided to order a pizza. In this problem pizza is a circle of some radius. The pizza was delivered already cut into *n* pieces. The *i*-th piece is a sector of angle equal to *a**i*. Vasya and Petya want to divide all pieces of pizza into two continuous sectors in such way that the difference between angles of these sectors is minimal. Sector angle is sum of angles of all pieces in it. Pay attention, that one of sectors can be empty.
Input Specification:
The first line contains one integer *n* (1<=≤<=*n*<=≤<=360) — the number of pieces into which the delivered pizza was cut.
The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=360) — the angles of the sectors into which the pizza was cut. The sum of all *a**i* is 360.
Output Specification:
Print one integer — the minimal difference between angles of sectors that will go to Vasya and Petya.
Demo Input:
['4\n90 90 90 90\n', '3\n100 100 160\n', '1\n360\n', '4\n170 30 150 10\n']
Demo Output:
['0\n', '40\n', '360\n', '0\n']
Note:
In first sample Vasya can take 1 and 2 pieces, Petya can take 3 and 4 pieces. Then the answer is |(90 + 90) - (90 + 90)| = 0.
In third sample there is only one piece of pizza that can be taken by only one from Vasya and Petya. So the answer is |360 - 0| = 360.
In fourth sample Vasya can take 1 and 4 pieces, then Petya will take 2 and 3 pieces. So the answer is |(170 + 10) - (30 + 150)| = 0.
Picture explaning fourth sample:
<img class="tex-graphics" src="https://espresso.codeforces.com/4bb3450aca241f92fedcba5479bf1b6d22cf813d.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Both red and green sectors consist of two adjacent pieces of pizza. So Vasya can take green sector, then Petya will take red sector.
|
```python
n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
sumr=a[0]
suml=0
for i in range(1,n):
#print(sumr,suml)
if sumr>suml:
suml+=a[i]
else:
sumr+=a[i]
print(abs(sumr-suml))
```
| 0
|
|
556
|
A
|
Case of the Zeros and Ones
|
PROGRAMMING
| 900
|
[
"greedy"
] | null | null |
Andrewid the Android is a galaxy-famous detective. In his free time he likes to think about strings containing zeros and ones.
Once he thought about a string of length *n* consisting of zeroes and ones. Consider the following operation: we choose any two adjacent positions in the string, and if one them contains 0, and the other contains 1, then we are allowed to remove these two digits from the string, obtaining a string of length *n*<=-<=2 as a result.
Now Andreid thinks about what is the minimum length of the string that can remain after applying the described operation several times (possibly, zero)? Help him to calculate this number.
|
First line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=2·105), the length of the string that Andreid has.
The second line contains the string of length *n* consisting only from zeros and ones.
|
Output the minimum length of the string that may remain after applying the described operations several times.
|
[
"4\n1100\n",
"5\n01010\n",
"8\n11101111\n"
] |
[
"0\n",
"1\n",
"6\n"
] |
In the first sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/10df55364c21c6e8d5da31b6ab6f6294c4fc26b3.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/19ec5dcd85f0b5cf757aa076ace72df39634de2d.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the third sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/dc34a159e4230375fa325555527ebc748811f188.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
| 250
|
[
{
"input": "4\n1100",
"output": "0"
},
{
"input": "5\n01010",
"output": "1"
},
{
"input": "8\n11101111",
"output": "6"
},
{
"input": "1\n0",
"output": "1"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "2\n00",
"output": "2"
},
{
"input": "2\n01",
"output": "0"
},
{
"input": "2\n10",
"output": "0"
},
{
"input": "2\n11",
"output": "2"
},
{
"input": "3\n001",
"output": "1"
},
{
"input": "6\n110110",
"output": "2"
},
{
"input": "7\n0000011",
"output": "3"
},
{
"input": "6\n110010",
"output": "0"
},
{
"input": "6\n110100",
"output": "0"
},
{
"input": "3\n100",
"output": "1"
},
{
"input": "6\n010111",
"output": "2"
},
{
"input": "8\n01011100",
"output": "0"
},
{
"input": "6\n001011",
"output": "0"
},
{
"input": "7\n1110000",
"output": "1"
},
{
"input": "9\n011111101",
"output": "5"
}
] | 1,668,092,832
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 49
| 124
| 2,867,200
|
n=int(input())
s=input()
s1=list(map(int,str(s)))
c0=0
c1=0
for i in range(n):
if s1[i]==0:
c0+=1
c1=n-c0
if c0==c1:
print("0")
elif c1>c0:
print(c1-c0)
else:
print(c0-c1)
|
Title: Case of the Zeros and Ones
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Andrewid the Android is a galaxy-famous detective. In his free time he likes to think about strings containing zeros and ones.
Once he thought about a string of length *n* consisting of zeroes and ones. Consider the following operation: we choose any two adjacent positions in the string, and if one them contains 0, and the other contains 1, then we are allowed to remove these two digits from the string, obtaining a string of length *n*<=-<=2 as a result.
Now Andreid thinks about what is the minimum length of the string that can remain after applying the described operation several times (possibly, zero)? Help him to calculate this number.
Input Specification:
First line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=2·105), the length of the string that Andreid has.
The second line contains the string of length *n* consisting only from zeros and ones.
Output Specification:
Output the minimum length of the string that may remain after applying the described operations several times.
Demo Input:
['4\n1100\n', '5\n01010\n', '8\n11101111\n']
Demo Output:
['0\n', '1\n', '6\n']
Note:
In the first sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/10df55364c21c6e8d5da31b6ab6f6294c4fc26b3.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the second sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/19ec5dcd85f0b5cf757aa076ace72df39634de2d.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
In the third sample test it is possible to change the string like the following: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/dc34a159e4230375fa325555527ebc748811f188.png" style="max-width: 100.0%;max-height: 100.0%;"/>.
|
```python
n=int(input())
s=input()
s1=list(map(int,str(s)))
c0=0
c1=0
for i in range(n):
if s1[i]==0:
c0+=1
c1=n-c0
if c0==c1:
print("0")
elif c1>c0:
print(c1-c0)
else:
print(c0-c1)
```
| 3
|
|
546
|
A
|
Soldier and Bananas
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation",
"math"
] | null | null |
A soldier wants to buy *w* bananas in the shop. He has to pay *k* dollars for the first banana, 2*k* dollars for the second one and so on (in other words, he has to pay *i*·*k* dollars for the *i*-th banana).
He has *n* dollars. How many dollars does he have to borrow from his friend soldier to buy *w* bananas?
|
The first line contains three positive integers *k*,<=*n*,<=*w* (1<=<=≤<=<=*k*,<=*w*<=<=≤<=<=1000, 0<=≤<=*n*<=≤<=109), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants.
|
Output one integer — the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.
|
[
"3 17 4\n"
] |
[
"13"
] |
none
| 500
|
[
{
"input": "3 17 4",
"output": "13"
},
{
"input": "1 2 1",
"output": "0"
},
{
"input": "1 1 1",
"output": "0"
},
{
"input": "1 5 6",
"output": "16"
},
{
"input": "1 1000000000 1",
"output": "0"
},
{
"input": "1000 0 1000",
"output": "500500000"
},
{
"input": "859 453892 543",
"output": "126416972"
},
{
"input": "1000 1000000000 1000",
"output": "0"
},
{
"input": "1000 500500000 1000",
"output": "0"
},
{
"input": "1000 500500001 1000",
"output": "0"
},
{
"input": "1000 500499999 1000",
"output": "1"
},
{
"input": "634 87973 214",
"output": "14497197"
},
{
"input": "432 10000 241",
"output": "12587552"
},
{
"input": "111 111111111 111",
"output": "0"
},
{
"input": "20 43 3",
"output": "77"
}
] | 1,697,373,453
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 15
| 46
| 0
|
k, n, w = map(int,input().split())
a = 0
for i in range(1,w+1):
a += i * k
if n >= a:
print('0')
else:
print(a - n)
|
Title: Soldier and Bananas
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
A soldier wants to buy *w* bananas in the shop. He has to pay *k* dollars for the first banana, 2*k* dollars for the second one and so on (in other words, he has to pay *i*·*k* dollars for the *i*-th banana).
He has *n* dollars. How many dollars does he have to borrow from his friend soldier to buy *w* bananas?
Input Specification:
The first line contains three positive integers *k*,<=*n*,<=*w* (1<=<=≤<=<=*k*,<=*w*<=<=≤<=<=1000, 0<=≤<=*n*<=≤<=109), the cost of the first banana, initial number of dollars the soldier has and number of bananas he wants.
Output Specification:
Output one integer — the amount of dollars that the soldier must borrow from his friend. If he doesn't have to borrow money, output 0.
Demo Input:
['3 17 4\n']
Demo Output:
['13']
Note:
none
|
```python
k, n, w = map(int,input().split())
a = 0
for i in range(1,w+1):
a += i * k
if n >= a:
print('0')
else:
print(a - n)
```
| 3
|
|
445
|
A
|
DZY Loves Chessboard
|
PROGRAMMING
| 1,200
|
[
"dfs and similar",
"implementation"
] | null | 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,631,363,436
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 37
| 171
| 24,576,000
|
from collections import deque
r, c = list(map(lambda x: int(x), input().split()))
dr = [(-1, 0), (0, -1), (1, 0), (0, 1)]
board = []
for i in range(r):
t = input()
board.append(list(map(lambda x:x, t)))
for i in range(r):
for j in range(c):
if board[i][j] == '.':
q = deque()
q.append((i, j))
board[i][j] = 'B'
while(len(q)):
row, col = q.popleft()
if board[row][col] == 'B':
ch = 'W'
else:
ch = 'B'
for d in range(4):
currR, currC = row + dr[d][0], col + dr[d][1]
if currR >= 0 and currR < r and currC >= 0 and currC < c and board[currR][currC] == '.':
board[currR][currC] = ch
q.append((currR, currC))
for i in range(r):
for j in range(c):
print(board[i][j], end = "")
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
from collections import deque
r, c = list(map(lambda x: int(x), input().split()))
dr = [(-1, 0), (0, -1), (1, 0), (0, 1)]
board = []
for i in range(r):
t = input()
board.append(list(map(lambda x:x, t)))
for i in range(r):
for j in range(c):
if board[i][j] == '.':
q = deque()
q.append((i, j))
board[i][j] = 'B'
while(len(q)):
row, col = q.popleft()
if board[row][col] == 'B':
ch = 'W'
else:
ch = 'B'
for d in range(4):
currR, currC = row + dr[d][0], col + dr[d][1]
if currR >= 0 and currR < r and currC >= 0 and currC < c and board[currR][currC] == '.':
board[currR][currC] = ch
q.append((currR, currC))
for i in range(r):
for j in range(c):
print(board[i][j], end = "")
print()
```
| 3
|
|
228
|
A
|
Is your horseshoe on the other hoof?
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Valera the Horse is going to the party with friends. He has been following the fashion trends for a while, and he knows that it is very popular to wear all horseshoes of different color. Valera has got four horseshoes left from the last year, but maybe some of them have the same color. In this case he needs to go to the store and buy some few more horseshoes, not to lose face in front of his stylish comrades.
Fortunately, the store sells horseshoes of all colors under the sun and Valera has enough money to buy any four of them. However, in order to save the money, he would like to spend as little money as possible, so you need to help Valera and determine what is the minimum number of horseshoes he needs to buy to wear four horseshoes of different colors to a party.
|
The first line contains four space-separated integers *s*1,<=*s*2,<=*s*3,<=*s*4 (1<=≤<=*s*1,<=*s*2,<=*s*3,<=*s*4<=≤<=109) — the colors of horseshoes Valera has.
Consider all possible colors indexed with integers.
|
Print a single integer — the minimum number of horseshoes Valera needs to buy.
|
[
"1 7 3 3\n",
"7 7 7 7\n"
] |
[
"1\n",
"3\n"
] |
none
| 500
|
[
{
"input": "1 7 3 3",
"output": "1"
},
{
"input": "7 7 7 7",
"output": "3"
},
{
"input": "81170865 673572653 756938629 995577259",
"output": "0"
},
{
"input": "3491663 217797045 522540872 715355328",
"output": "0"
},
{
"input": "251590420 586975278 916631563 586975278",
"output": "1"
},
{
"input": "259504825 377489979 588153796 377489979",
"output": "1"
},
{
"input": "652588203 931100304 931100304 652588203",
"output": "2"
},
{
"input": "391958720 651507265 391958720 651507265",
"output": "2"
},
{
"input": "90793237 90793237 90793237 90793237",
"output": "3"
},
{
"input": "551651653 551651653 551651653 551651653",
"output": "3"
},
{
"input": "156630260 609654355 668943582 973622757",
"output": "0"
},
{
"input": "17061017 110313588 434481173 796661222",
"output": "0"
},
{
"input": "24975422 256716298 337790533 690960249",
"output": "0"
},
{
"input": "255635360 732742923 798648949 883146723",
"output": "0"
},
{
"input": "133315691 265159773 734556507 265159773",
"output": "1"
},
{
"input": "28442865 741657755 978106882 978106882",
"output": "1"
},
{
"input": "131245479 174845575 497483467 131245479",
"output": "1"
},
{
"input": "139159884 616215581 958341883 616215581",
"output": "1"
},
{
"input": "147784432 947653080 947653080 947653080",
"output": "2"
},
{
"input": "94055790 756126496 756126496 94055790",
"output": "2"
},
{
"input": "240458500 511952208 240458500 511952208",
"output": "2"
},
{
"input": "681828506 972810624 972810624 681828506",
"output": "2"
},
{
"input": "454961014 454961014 454961014 454961014",
"output": "3"
},
{
"input": "915819430 915819430 915819430 915819430",
"output": "3"
},
{
"input": "671645142 671645142 671645142 671645142",
"output": "3"
},
{
"input": "132503558 132503558 132503558 132503558",
"output": "3"
},
{
"input": "5 5 999999 6",
"output": "1"
},
{
"input": "1 1 2 5",
"output": "1"
},
{
"input": "2 1 2 3",
"output": "1"
},
{
"input": "1 1 3 5",
"output": "1"
},
{
"input": "1 1 3 3",
"output": "2"
},
{
"input": "2 2 2 1",
"output": "2"
},
{
"input": "3 1 1 1",
"output": "2"
},
{
"input": "1 2 2 2",
"output": "2"
}
] | 1,697,144,414
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 34
| 92
| 0
|
s = list(map(int,input().split()))
n = []
ans = 0
for i in s:
if s.count(i) != 0 and i not in n:
ans += s.count(i) - 1
n.append(i)
print(ans)
|
Title: Is your horseshoe on the other hoof?
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Valera the Horse is going to the party with friends. He has been following the fashion trends for a while, and he knows that it is very popular to wear all horseshoes of different color. Valera has got four horseshoes left from the last year, but maybe some of them have the same color. In this case he needs to go to the store and buy some few more horseshoes, not to lose face in front of his stylish comrades.
Fortunately, the store sells horseshoes of all colors under the sun and Valera has enough money to buy any four of them. However, in order to save the money, he would like to spend as little money as possible, so you need to help Valera and determine what is the minimum number of horseshoes he needs to buy to wear four horseshoes of different colors to a party.
Input Specification:
The first line contains four space-separated integers *s*1,<=*s*2,<=*s*3,<=*s*4 (1<=≤<=*s*1,<=*s*2,<=*s*3,<=*s*4<=≤<=109) — the colors of horseshoes Valera has.
Consider all possible colors indexed with integers.
Output Specification:
Print a single integer — the minimum number of horseshoes Valera needs to buy.
Demo Input:
['1 7 3 3\n', '7 7 7 7\n']
Demo Output:
['1\n', '3\n']
Note:
none
|
```python
s = list(map(int,input().split()))
n = []
ans = 0
for i in s:
if s.count(i) != 0 and i not in n:
ans += s.count(i) - 1
n.append(i)
print(ans)
```
| 3
|
|
75
|
A
|
Life Without Zeros
|
PROGRAMMING
| 1,000
|
[
"implementation"
] |
A. Life Without Zeros
|
2
|
256
|
Can you imagine our life if we removed all zeros from it? For sure we will have many problems.
In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assume you are given this equation *a*<=+<=*b*<==<=*c*, where *a* and *b* are positive integers, and *c* is the sum of *a* and *b*. Now let's remove all zeros from this equation. Will the equation remain correct after removing all zeros?
For example if the equation is 101<=+<=102<==<=203, if we removed all zeros it will be 11<=+<=12<==<=23 which is still a correct equation.
But if the equation is 105<=+<=106<==<=211, if we removed all zeros it will be 15<=+<=16<==<=211 which is not a correct equation.
|
The input will consist of two lines, the first line will contain the integer *a*, and the second line will contain the integer *b* which are in the equation as described above (1<=≤<=*a*,<=*b*<=≤<=109). There won't be any leading zeros in both. The value of *c* should be calculated as *c*<==<=*a*<=+<=*b*.
|
The output will be just one line, you should print "YES" if the equation will remain correct after removing all zeros, and print "NO" otherwise.
|
[
"101\n102\n",
"105\n106\n"
] |
[
"YES\n",
"NO\n"
] |
none
| 500
|
[
{
"input": "101\n102",
"output": "YES"
},
{
"input": "105\n106",
"output": "NO"
},
{
"input": "544\n397",
"output": "YES"
},
{
"input": "822\n280",
"output": "NO"
},
{
"input": "101\n413",
"output": "NO"
},
{
"input": "309\n139",
"output": "NO"
},
{
"input": "693\n970",
"output": "NO"
},
{
"input": "981\n1",
"output": "YES"
},
{
"input": "352\n276",
"output": "YES"
},
{
"input": "164\n691",
"output": "YES"
},
{
"input": "110036\n43",
"output": "YES"
},
{
"input": "100\n1000",
"output": "NO"
},
{
"input": "1000000000\n1000000000",
"output": "YES"
},
{
"input": "999999999\n999999999",
"output": "YES"
},
{
"input": "6\n4",
"output": "NO"
},
{
"input": "123456\n876543",
"output": "YES"
},
{
"input": "1234567\n9876543",
"output": "NO"
},
{
"input": "1111111\n1119111",
"output": "NO"
},
{
"input": "10502405\n40403403",
"output": "YES"
},
{
"input": "1\n1",
"output": "YES"
},
{
"input": "5\n4",
"output": "YES"
},
{
"input": "1\n6",
"output": "YES"
},
{
"input": "40\n17",
"output": "NO"
},
{
"input": "35\n81",
"output": "YES"
},
{
"input": "347\n908",
"output": "NO"
},
{
"input": "2081\n7450",
"output": "NO"
},
{
"input": "84355694\n373629503",
"output": "NO"
},
{
"input": "885992048\n510468672",
"output": "NO"
},
{
"input": "540144752\n647307841",
"output": "NO"
},
{
"input": "341781108\n784147010",
"output": "NO"
},
{
"input": "960440938\n572334653",
"output": "NO"
},
{
"input": "657414510\n768771903",
"output": "NO"
},
{
"input": "501871728\n725074574",
"output": "NO"
},
{
"input": "968\n851",
"output": "YES"
},
{
"input": "943\n939",
"output": "YES"
},
{
"input": "347\n908",
"output": "NO"
},
{
"input": "611\n41",
"output": "YES"
},
{
"input": "737\n289",
"output": "NO"
},
{
"input": "168\n571",
"output": "YES"
},
{
"input": "868\n463",
"output": "YES"
},
{
"input": "815732007\n913882008",
"output": "NO"
},
{
"input": "459039901\n453033850",
"output": "NO"
},
{
"input": "975305404\n484601256",
"output": "NO"
}
] | 1,622,990,496
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 186
| 0
|
a=input()
b=input()
k=0
for i in range(len(a)):
if (int(a[i])+int(b[i]))>9 and k>0:
print("NO")
break
if int(a[i])==0 or int(b[i])==0:
k+=1
else:
print("YES")
|
Title: Life Without Zeros
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
Can you imagine our life if we removed all zeros from it? For sure we will have many problems.
In this problem we will have a simple example if we removed all zeros from our life, it's the addition operation. Let's assume you are given this equation *a*<=+<=*b*<==<=*c*, where *a* and *b* are positive integers, and *c* is the sum of *a* and *b*. Now let's remove all zeros from this equation. Will the equation remain correct after removing all zeros?
For example if the equation is 101<=+<=102<==<=203, if we removed all zeros it will be 11<=+<=12<==<=23 which is still a correct equation.
But if the equation is 105<=+<=106<==<=211, if we removed all zeros it will be 15<=+<=16<==<=211 which is not a correct equation.
Input Specification:
The input will consist of two lines, the first line will contain the integer *a*, and the second line will contain the integer *b* which are in the equation as described above (1<=≤<=*a*,<=*b*<=≤<=109). There won't be any leading zeros in both. The value of *c* should be calculated as *c*<==<=*a*<=+<=*b*.
Output Specification:
The output will be just one line, you should print "YES" if the equation will remain correct after removing all zeros, and print "NO" otherwise.
Demo Input:
['101\n102\n', '105\n106\n']
Demo Output:
['YES\n', 'NO\n']
Note:
none
|
```python
a=input()
b=input()
k=0
for i in range(len(a)):
if (int(a[i])+int(b[i]))>9 and k>0:
print("NO")
break
if int(a[i])==0 or int(b[i])==0:
k+=1
else:
print("YES")
```
| 0
|
982
|
E
|
Billiard
|
PROGRAMMING
| 2,600
|
[
"geometry",
"number theory"
] | null | null |
Consider a [billiard table](https://en.wikipedia.org/wiki/Billiard_table) of rectangular size $n \times m$ with four pockets. Let's introduce a coordinate system with the origin at the lower left corner (see the picture).
There is one ball at the point $(x, y)$ currently. Max comes to the table and strikes the ball. The ball starts moving along a line that is parallel to one of the axes or that makes a $45^{\circ}$ angle with them. We will assume that:
1. the angles between the directions of the ball before and after a collision with a side are equal, 1. the ball moves indefinitely long, it only stops when it falls into a pocket, 1. the ball can be considered as a point, it falls into a pocket if and only if its coordinates coincide with one of the pockets, 1. initially the ball is not in a pocket.
Note that the ball can move along some side, in this case the ball will just fall into the pocket at the end of the side.
Your task is to determine whether the ball will fall into a pocket eventually, and if yes, which of the four pockets it will be.
|
The only line contains $6$ integers $n$, $m$, $x$, $y$, $v_x$, $v_y$ ($1 \leq n, m \leq 10^9$, $0 \leq x \leq n$; $0 \leq y \leq m$; $-1 \leq v_x, v_y \leq 1$; $(v_x, v_y) \neq (0, 0)$) — the width of the table, the length of the table, the $x$-coordinate of the initial position of the ball, the $y$-coordinate of the initial position of the ball, the $x$-component of its initial speed and the $y$-component of its initial speed, respectively. It is guaranteed that the ball is not initially in a pocket.
|
Print the coordinates of the pocket the ball will fall into, or $-1$ if the ball will move indefinitely.
|
[
"4 3 2 2 -1 1\n",
"4 4 2 0 1 1\n",
"10 10 10 1 -1 0\n"
] |
[
"0 0",
"-1",
"-1"
] |
The first sample:
The second sample:
In the third sample the ball will never change its $y$ coordinate, so the ball will never fall into a pocket.
| 2,500
|
[
{
"input": "4 3 2 2 -1 1",
"output": "0 0"
},
{
"input": "4 4 2 0 1 1",
"output": "-1"
},
{
"input": "10 10 10 1 -1 0",
"output": "-1"
},
{
"input": "1000000000 1000000000 1 1000000000 0 1",
"output": "-1"
},
{
"input": "2 1 1 0 -1 -1",
"output": "0 1"
},
{
"input": "4 2 1 2 1 1",
"output": "-1"
},
{
"input": "5 3 4 3 1 -1",
"output": "0 3"
},
{
"input": "15 9 1 1 1 1",
"output": "15 9"
},
{
"input": "15 9 1 1 -1 -1",
"output": "0 0"
},
{
"input": "15 9 2 1 1 1",
"output": "-1"
},
{
"input": "15 9 2 1 -1 1",
"output": "15 0"
},
{
"input": "1000000000 999999999 999999998 999999999 -1 -1",
"output": "1000000000 999999999"
},
{
"input": "1000000000 999999999 999999998 999999999 -1 1",
"output": "1000000000 999999999"
},
{
"input": "15 9 3 2 1 1",
"output": "-1"
},
{
"input": "15 9 3 2 1 -1",
"output": "-1"
},
{
"input": "4 4 0 1 0 1",
"output": "0 4"
},
{
"input": "4 4 4 2 0 -1",
"output": "4 0"
},
{
"input": "1000000000 999999999 999999999 999999999 1 1",
"output": "1000000000 0"
},
{
"input": "1000000000 999999999 999999998 999999999 1 1",
"output": "0 999999999"
},
{
"input": "1000000000 999999999 999999998 999999999 1 -1",
"output": "0 999999999"
},
{
"input": "1000000000 999999999 999999998 999999999 0 1",
"output": "-1"
},
{
"input": "1000000000 999999999 999999998 999999999 -1 0",
"output": "0 999999999"
},
{
"input": "1 99 0 16 -1 1",
"output": "1 99"
},
{
"input": "6 8 1 1 1 1",
"output": "0 8"
},
{
"input": "6 10 1 1 1 1",
"output": "6 10"
},
{
"input": "8 6 7 1 -1 1",
"output": "0 0"
},
{
"input": "10009 10007 1 1 1 1",
"output": "10009 10007"
},
{
"input": "10007 10009 10006 10008 -1 -1",
"output": "0 0"
},
{
"input": "1000 999 1 998 1 -1",
"output": "1000 999"
},
{
"input": "500 500 250 250 -1 1",
"output": "0 500"
},
{
"input": "2705444 415131525 949293 337120042 1 -1",
"output": "2705444 415131525"
},
{
"input": "603278410 844534002 499505824 32181172 1 -1",
"output": "603278410 844534002"
},
{
"input": "316347709 122791181 255721626 19148895 -1 1",
"output": "316347709 0"
},
{
"input": "226591495 303844168 64300938 148467902 -1 -1",
"output": "0 303844168"
},
{
"input": "682138812 116415655 516825996 73682791 -1 1",
"output": "0 116415655"
},
{
"input": "305675046 505376350 144451750 295580797 -1 1",
"output": "-1"
},
{
"input": "313157692 571680270 238352863 235464142 1 -1",
"output": "-1"
},
{
"input": "120717601 973035857 103171773 511250918 -1 1",
"output": "120717601 0"
},
{
"input": "41373770 597127671 31867608 404367855 -1 1",
"output": "41373770 597127671"
},
{
"input": "827285013 307724101 775951207 175683367 -1 -1",
"output": "827285013 307724101"
},
{
"input": "110474424 613900860 31471099 442410471 -1 1",
"output": "-1"
},
{
"input": "84035810 39157280 10865763 24269978 1 -1",
"output": "-1"
},
{
"input": "75744115 329085002 22395692 81831548 -1 1",
"output": "0 0"
},
{
"input": "20597226 82154419 5899110 71189386 1 1",
"output": "0 0"
},
{
"input": "550269655 264187669 141601786 53516425 1 -1",
"output": "550269655 0"
},
{
"input": "224819588 978615384 68538326 805268586 1 1",
"output": "224819588 978615384"
},
{
"input": "979444430 110858783 607921615 88320790 1 -1",
"output": "979444430 110858783"
},
{
"input": "853950494 911554949 428001551 108479491 1 1",
"output": "853950494 0"
},
{
"input": "810387002 412176212 187695958 236085023 1 1",
"output": "-1"
},
{
"input": "20877471 722211317 8457280 75966699 -1 -1",
"output": "0 722211317"
},
{
"input": "542708351 3475408 103232934 399149 1 1",
"output": "542708351 3475408"
},
{
"input": "30609041 976052297 4229728 158676967 -1 1",
"output": "30609041 0"
},
{
"input": "495082283 937762241 250777046 412284609 1 1",
"output": "495082283 0"
},
{
"input": "68076815 985943633 40657983 165191148 1 -1",
"output": "0 985943633"
},
{
"input": "209408006 202717192 115684862 96677080 -1 -1",
"output": "209408006 202717192"
},
{
"input": "651520659 433737829 645844796 133999548 1 -1",
"output": "0 0"
},
{
"input": "835624982 341676615 379293679 54053933 1 -1",
"output": "835624982 0"
},
{
"input": "943609111 405753192 556398014 348647907 1 -1",
"output": "943609111 0"
},
{
"input": "590709848 332238455 546245223 240305069 -1 1",
"output": "0 0"
},
{
"input": "320049957 92820858 176731509 15650804 1 1",
"output": "-1"
},
{
"input": "233140029 827954502 99465884 170396111 1 1",
"output": "233140029 827954502"
},
{
"input": "760904646 962606170 641547160 113696561 -1 1",
"output": "-1"
},
{
"input": "584801838 775270595 121061956 644380885 -1 1",
"output": "0 775270595"
},
{
"input": "141190266 126518281 76515989 109124404 1 1",
"output": "0 126518281"
},
{
"input": "225067174 487662889 175063389 447988824 1 1",
"output": "225067174 487662889"
},
{
"input": "814170008 703690544 6953086 439080555 -1 1",
"output": "-1"
},
{
"input": "12671644 216092609 3707378 92213588 1 1",
"output": "12671644 0"
},
{
"input": "686521539 766868053 668178904 36804229 1 1",
"output": "686521539 0"
},
{
"input": "43760214 59779641 32562470 43565961 -1 1",
"output": "-1"
},
{
"input": "281776735 833828834 271604381 491447288 -1 1",
"output": "281776735 833828834"
},
{
"input": "362762211 732244195 63812822 258610562 -1 1",
"output": "362762211 732244195"
},
{
"input": "312319019 933972106 103989975 544805243 1 -1",
"output": "0 0"
},
{
"input": "142096067 231234738 40134344 206132422 -1 1",
"output": "0 231234738"
},
{
"input": "289285219 692430999 249276742 628721059 1 -1",
"output": "0 692430999"
},
{
"input": "490696330 492707826 183410939 115542637 -1 -1",
"output": "490696330 0"
},
{
"input": "916524063 555774494 499847875 268662592 -1 1",
"output": "916524063 555774494"
},
{
"input": "101123973 722433301 46988094 586973439 -1 1",
"output": "101123973 0"
},
{
"input": "808357574 854008109 9323335 342356143 -1 -1",
"output": "0 0"
},
{
"input": "257447593 468889343 162885112 15431794 1 1",
"output": "-1"
},
{
"input": "688226257 305863798 134250684 285725084 -1 -1",
"output": "0 305863798"
},
{
"input": "836255310 741706431 648685681 396741892 1 -1",
"output": "-1"
},
{
"input": "480678700 670120443 423401724 177051387 1 1",
"output": "480678700 670120443"
},
{
"input": "35550087 590484118 10858303 37118846 1 1",
"output": "35550087 590484118"
},
{
"input": "491475453 334831307 136826756 228553610 1 -1",
"output": "491475453 334831307"
},
{
"input": "172057628 368934073 117631597 83410362 1 1",
"output": "172057628 368934073"
},
{
"input": "611927194 869083092 295778083 541333563 -1 -1",
"output": "0 869083092"
},
{
"input": "329666407 901295668 90510437 485008861 1 -1",
"output": "-1"
},
{
"input": "978089453 426264909 388420346 53798427 -1 1",
"output": "0 426264909"
},
{
"input": "242449067 548221648 24810672 63078584 1 1",
"output": "0 548221648"
},
{
"input": "583053442 353408 240939980 17207 -1 1",
"output": "-1"
},
{
"input": "10 9 8 9 -1 1",
"output": "10 9"
},
{
"input": "999999997 999999999 500 500 -1 1",
"output": "0 0"
},
{
"input": "1000000000 1000000000 999 100 -1 -1",
"output": "-1"
},
{
"input": "7 5 2 3 1 0",
"output": "-1"
},
{
"input": "11 13 5 7 -1 -1",
"output": "0 0"
},
{
"input": "500 1000 200 200 1 1",
"output": "0 1000"
},
{
"input": "500 995 1 1 1 1",
"output": "500 0"
},
{
"input": "1 100 0 1 1 1",
"output": "1 100"
},
{
"input": "1 100 0 1 1 0",
"output": "-1"
},
{
"input": "999999999 999999998 2 3 -1 1",
"output": "999999999 0"
},
{
"input": "500000000 499999999 499999999 499999999 1 1",
"output": "500000000 0"
}
] | 1,689,529,248
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 31
| 62
| 1,433,600
|
def gcd(a, b):
return gcd(b, a % b) if b else a
def ppow(n, p, m):
if p == 0:
return 1
rt = ppow(n, p // 2, m)
return (rt * rt % m) * (n if p % 2 else 1) % m
def phi(n):
if n == 1:
return 1
ans, i = 1, 2
while i * i <= n:
if n % i == 0:
p = 1
while n % i == 0:
p *= i
n /= i
ans *= (i - 1) * (p / i)
i += 1
if n > 1:
ans *= n - 1
return ans
def inv(x, m):
return ppow(x, phi(m) - 1, m)
def solve():
n, m, x, y, vx, vy = [int(x) for x in input().split()]
# edge case
if vx == 0:
if x % n == 0:
print(x, 0 if vy == -1 else m)
else:
print(-1)
return
# edge case
if vy == 0:
if y % m == 0:
print(0 if vx == -1 else n, y)
else:
print(-1)
return
a = (n - x) * inv((n + vx) % n, n) % n # t = a mod n
b = (m - y) * inv((m + vy) % m, m) % m # t = b mod m
g = gcd(n, m)
# edge case
if g > 1 and a % g != b % g:
print(-1)
return
t = 0
# straight forward case
if g == 1:
t = (a * m * inv(m, n) + b * n * inv(n, m)) % (n * m)
# edge case
else:
lcm = n * m / g
t = (a + (inv(n / g, m / g) * (b - a + lcm) % lcm) * n / g) % lcm
p = (x + vx * t) / n
q = (y + vy * t) / m
print(int(abs(p % 2) * n), int(abs(q % 2) * m))
if __name__ == '__main__':
solve()
|
Title: Billiard
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Consider a [billiard table](https://en.wikipedia.org/wiki/Billiard_table) of rectangular size $n \times m$ with four pockets. Let's introduce a coordinate system with the origin at the lower left corner (see the picture).
There is one ball at the point $(x, y)$ currently. Max comes to the table and strikes the ball. The ball starts moving along a line that is parallel to one of the axes or that makes a $45^{\circ}$ angle with them. We will assume that:
1. the angles between the directions of the ball before and after a collision with a side are equal, 1. the ball moves indefinitely long, it only stops when it falls into a pocket, 1. the ball can be considered as a point, it falls into a pocket if and only if its coordinates coincide with one of the pockets, 1. initially the ball is not in a pocket.
Note that the ball can move along some side, in this case the ball will just fall into the pocket at the end of the side.
Your task is to determine whether the ball will fall into a pocket eventually, and if yes, which of the four pockets it will be.
Input Specification:
The only line contains $6$ integers $n$, $m$, $x$, $y$, $v_x$, $v_y$ ($1 \leq n, m \leq 10^9$, $0 \leq x \leq n$; $0 \leq y \leq m$; $-1 \leq v_x, v_y \leq 1$; $(v_x, v_y) \neq (0, 0)$) — the width of the table, the length of the table, the $x$-coordinate of the initial position of the ball, the $y$-coordinate of the initial position of the ball, the $x$-component of its initial speed and the $y$-component of its initial speed, respectively. It is guaranteed that the ball is not initially in a pocket.
Output Specification:
Print the coordinates of the pocket the ball will fall into, or $-1$ if the ball will move indefinitely.
Demo Input:
['4 3 2 2 -1 1\n', '4 4 2 0 1 1\n', '10 10 10 1 -1 0\n']
Demo Output:
['0 0', '-1', '-1']
Note:
The first sample:
The second sample:
In the third sample the ball will never change its $y$ coordinate, so the ball will never fall into a pocket.
|
```python
def gcd(a, b):
return gcd(b, a % b) if b else a
def ppow(n, p, m):
if p == 0:
return 1
rt = ppow(n, p // 2, m)
return (rt * rt % m) * (n if p % 2 else 1) % m
def phi(n):
if n == 1:
return 1
ans, i = 1, 2
while i * i <= n:
if n % i == 0:
p = 1
while n % i == 0:
p *= i
n /= i
ans *= (i - 1) * (p / i)
i += 1
if n > 1:
ans *= n - 1
return ans
def inv(x, m):
return ppow(x, phi(m) - 1, m)
def solve():
n, m, x, y, vx, vy = [int(x) for x in input().split()]
# edge case
if vx == 0:
if x % n == 0:
print(x, 0 if vy == -1 else m)
else:
print(-1)
return
# edge case
if vy == 0:
if y % m == 0:
print(0 if vx == -1 else n, y)
else:
print(-1)
return
a = (n - x) * inv((n + vx) % n, n) % n # t = a mod n
b = (m - y) * inv((m + vy) % m, m) % m # t = b mod m
g = gcd(n, m)
# edge case
if g > 1 and a % g != b % g:
print(-1)
return
t = 0
# straight forward case
if g == 1:
t = (a * m * inv(m, n) + b * n * inv(n, m)) % (n * m)
# edge case
else:
lcm = n * m / g
t = (a + (inv(n / g, m / g) * (b - a + lcm) % lcm) * n / g) % lcm
p = (x + vx * t) / n
q = (y + vy * t) / m
print(int(abs(p % 2) * n), int(abs(q % 2) * m))
if __name__ == '__main__':
solve()
```
| 0
|
|
362
|
B
|
Petya and Staircases
|
PROGRAMMING
| 1,100
|
[
"implementation",
"sortings"
] | null | null |
Little boy Petya loves stairs very much. But he is bored from simple going up and down them — he loves jumping over several stairs at a time. As he stands on some stair, he can either jump to the next one or jump over one or two stairs at a time. But some stairs are too dirty and Petya doesn't want to step on them.
Now Petya is on the first stair of the staircase, consisting of *n* stairs. He also knows the numbers of the dirty stairs of this staircase. Help Petya find out if he can jump through the entire staircase and reach the last stair number *n* without touching a dirty stair once.
One has to note that anyway Petya should step on the first and last stairs, so if the first or the last stair is dirty, then Petya cannot choose a path with clean steps only.
|
The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=109, 0<=≤<=*m*<=≤<=3000) — the number of stairs in the staircase and the number of dirty stairs, correspondingly. The second line contains *m* different space-separated integers *d*1,<=*d*2,<=...,<=*d**m* (1<=≤<=*d**i*<=≤<=*n*) — the numbers of the dirty stairs (in an arbitrary order).
|
Print "YES" if Petya can reach stair number *n*, stepping only on the clean stairs. Otherwise print "NO".
|
[
"10 5\n2 4 8 3 6\n",
"10 5\n2 4 5 7 9\n"
] |
[
"NO",
"YES"
] |
none
| 500
|
[
{
"input": "10 5\n2 4 8 3 6",
"output": "NO"
},
{
"input": "10 5\n2 4 5 7 9",
"output": "YES"
},
{
"input": "10 9\n2 3 4 5 6 7 8 9 10",
"output": "NO"
},
{
"input": "5 2\n4 5",
"output": "NO"
},
{
"input": "123 13\n36 73 111 2 92 5 47 55 48 113 7 78 37",
"output": "YES"
},
{
"input": "10 10\n7 6 4 2 5 10 8 3 9 1",
"output": "NO"
},
{
"input": "12312 0",
"output": "YES"
},
{
"input": "9817239 1\n6323187",
"output": "YES"
},
{
"input": "1 1\n1",
"output": "NO"
},
{
"input": "5 4\n4 2 5 1",
"output": "NO"
},
{
"input": "5 3\n4 3 5",
"output": "NO"
},
{
"input": "500 3\n18 62 445",
"output": "YES"
},
{
"input": "500 50\n72 474 467 241 442 437 336 234 410 120 438 164 405 177 142 114 27 20 445 235 46 176 88 488 242 391 28 414 145 92 206 334 152 343 367 254 100 243 155 348 148 450 461 483 97 34 471 69 416 362",
"output": "NO"
},
{
"input": "500 8\n365 313 338 410 482 417 325 384",
"output": "YES"
},
{
"input": "1000000000 10\n2 3 5 6 8 9 123 874 1230 1000000000",
"output": "NO"
},
{
"input": "1000000000 10\n1 2 3 5 6 8 9 123 874 1230",
"output": "NO"
},
{
"input": "10 1\n1",
"output": "NO"
},
{
"input": "10 4\n1 2 4 5",
"output": "NO"
},
{
"input": "50 20\n22 33 17 23 27 5 26 31 41 20 8 24 6 3 4 29 40 25 13 16",
"output": "NO"
},
{
"input": "50 40\n14 27 19 30 31 20 28 11 37 29 23 33 7 26 22 16 1 6 18 3 47 36 38 2 48 9 41 8 5 50 4 45 44 25 39 12 43 42 40 46",
"output": "NO"
},
{
"input": "123 12\n35 95 47 99 79 122 58 94 31 57 18 10",
"output": "YES"
},
{
"input": "10 5\n1 3 5 7 9",
"output": "NO"
},
{
"input": "100 7\n2 3 5 6 8 9 100",
"output": "NO"
},
{
"input": "100 3\n98 99 100",
"output": "NO"
},
{
"input": "100 3\n97 98 99",
"output": "NO"
},
{
"input": "100 3\n96 98 99",
"output": "YES"
},
{
"input": "10 6\n2 3 5 6 8 9",
"output": "YES"
},
{
"input": "1000000000 10\n2 4 10 18 40 42 49 58 59 60",
"output": "NO"
},
{
"input": "10 3\n1 4 6",
"output": "NO"
},
{
"input": "8 3\n2 3 4",
"output": "NO"
},
{
"input": "100 3\n4 5 6",
"output": "NO"
},
{
"input": "10 2\n10 1",
"output": "NO"
},
{
"input": "10 1\n10",
"output": "NO"
},
{
"input": "4 2\n2 3",
"output": "YES"
},
{
"input": "2 1\n1",
"output": "NO"
},
{
"input": "2 0",
"output": "YES"
},
{
"input": "4 3\n2 3 4",
"output": "NO"
},
{
"input": "5 3\n4 2 3",
"output": "NO"
}
] | 1,682,167,159
| 2,147,483,647
|
PyPy 3
|
WRONG_ANSWER
|
TESTS
| 3
| 108
| 0
|
n,d=map(int,input().split())
lis=list(map(int,input().split()))
lis.sort()
if lis[0]==1 and lis[-1]==n:
print("NO")
else:
ans=True
for i in range(2,len(lis)):
if lis[i]-lis[i-2]==2:
print("NO")
ans=False
break
if ans:print("YES")
|
Title: Petya and Staircases
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Little boy Petya loves stairs very much. But he is bored from simple going up and down them — he loves jumping over several stairs at a time. As he stands on some stair, he can either jump to the next one or jump over one or two stairs at a time. But some stairs are too dirty and Petya doesn't want to step on them.
Now Petya is on the first stair of the staircase, consisting of *n* stairs. He also knows the numbers of the dirty stairs of this staircase. Help Petya find out if he can jump through the entire staircase and reach the last stair number *n* without touching a dirty stair once.
One has to note that anyway Petya should step on the first and last stairs, so if the first or the last stair is dirty, then Petya cannot choose a path with clean steps only.
Input Specification:
The first line contains two integers *n* and *m* (1<=≤<=*n*<=≤<=109, 0<=≤<=*m*<=≤<=3000) — the number of stairs in the staircase and the number of dirty stairs, correspondingly. The second line contains *m* different space-separated integers *d*1,<=*d*2,<=...,<=*d**m* (1<=≤<=*d**i*<=≤<=*n*) — the numbers of the dirty stairs (in an arbitrary order).
Output Specification:
Print "YES" if Petya can reach stair number *n*, stepping only on the clean stairs. Otherwise print "NO".
Demo Input:
['10 5\n2 4 8 3 6\n', '10 5\n2 4 5 7 9\n']
Demo Output:
['NO', 'YES']
Note:
none
|
```python
n,d=map(int,input().split())
lis=list(map(int,input().split()))
lis.sort()
if lis[0]==1 and lis[-1]==n:
print("NO")
else:
ans=True
for i in range(2,len(lis)):
if lis[i]-lis[i-2]==2:
print("NO")
ans=False
break
if ans:print("YES")
```
| 0
|
|
793
|
C
|
Mice problem
|
PROGRAMMING
| 2,300
|
[
"geometry",
"implementation",
"math",
"sortings"
] | null | null |
Igor the analyst fell asleep on the work and had a strange dream. In the dream his desk was crowded with computer mice, so he bought a mousetrap to catch them.
The desk can be considered as an infinite plane, then the mousetrap is a rectangle which sides are parallel to the axes, and which opposite sides are located in points (*x*1,<=*y*1) and (*x*2,<=*y*2).
Igor wants to catch all mice. Igor has analysed their behavior and discovered that each mouse is moving along a straight line with constant speed, the speed of the *i*-th mouse is equal to (*v**i**x*,<=*v**i**y*), that means that the *x* coordinate of the mouse increases by *v**i**x* units per second, while the *y* coordinates increases by *v**i**y* units. The mousetrap is open initially so that the mice are able to move freely on the desk. Igor can close the mousetrap at any moment catching all the mice that are strictly inside the mousetrap.
Igor works a lot, so he is busy in the dream as well, and he asks you to write a program that by given mousetrap's coordinates, the initial coordinates of the mice and their speeds determines the earliest time moment in which he is able to catch all the mice. Please note that Igor can close the mousetrap only once.
|
The first line contains single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of computer mice on the desk.
The second line contains four integers *x*1, *y*1, *x*2 and *y*2 (0<=≤<=*x*1<=≤<=*x*2<=≤<=100<=000), (0<=≤<=*y*1<=≤<=*y*2<=≤<=100<=000) — the coordinates of the opposite corners of the mousetrap.
The next *n* lines contain the information about mice.
The *i*-th of these lines contains four integers *r**i**x*, *r**i**y*, *v**i**x* and *v**i**y*, (0<=≤<=*r**i**x*,<=*r**i**y*<=≤<=100<=000, <=-<=100<=000<=≤<=*v**i**x*,<=*v**i**y*<=≤<=100<=000), where (*r**i**x*,<=*r**i**y*) is the initial position of the mouse, and (*v**i**x*,<=*v**i**y*) is its speed.
|
In the only line print minimum possible non-negative number *t* such that if Igor closes the mousetrap at *t* seconds from the beginning, then all the mice are strictly inside the mousetrap. If there is no such *t*, print -1.
Your answer is considered correct if its absolute or relative error doesn't exceed 10<=-<=6.
Formally, let your answer be *a*, and the jury's answer be *b*. Your answer is considered correct if .
|
[
"4\n7 7 9 8\n3 5 7 5\n7 5 2 4\n3 3 7 8\n6 6 3 2\n",
"4\n7 7 9 8\n0 3 -5 4\n5 0 5 4\n9 9 -1 -6\n10 5 -7 -10\n"
] |
[
"0.57142857142857139685\n",
"-1\n"
] |
Here is a picture of the first sample
Points A, B, C, D - start mice positions, segments are their paths.
<img class="tex-graphics" src="https://espresso.codeforces.com/9b2a39ff850b63eb3f41de7ce9efc61a192e99b5.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Then, at first time when all mice will be in rectangle it will be looks like this:
<img class="tex-graphics" src="https://espresso.codeforces.com/bfdaed392636d2b1790e7986ca711c1c3ebe298c.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Here is a picture of the second sample
<img class="tex-graphics" src="https://espresso.codeforces.com/a49c381e9f3e453fe5be91a972128def69042e45.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Points A, D, B will never enter rectangle.
| 1,500
|
[
{
"input": "4\n7 7 9 8\n3 5 7 5\n7 5 2 4\n3 3 7 8\n6 6 3 2",
"output": "0.57142857142857139685"
},
{
"input": "4\n7 7 9 8\n0 3 -5 4\n5 0 5 4\n9 9 -1 -6\n10 5 -7 -10",
"output": "-1"
},
{
"input": "4\n8 42 60 54\n9 54 -58 -62\n46 47 52 -76\n15 50 -37 -40\n54 51 78 64",
"output": "0.00000000000000000000"
},
{
"input": "4\n17501 63318 51967 74514\n1305 84026 79493 -78504\n41159 81000 -44104 -42722\n31063 65435 25578 33487\n18330 79949 83467 -74531",
"output": "0.20374120991785441004"
},
{
"input": "7\n24 38 44 47\n44 45 -50 -36\n33 48 -11 -39\n43 44 13 15\n42 47 24 -21\n40 41 19 7\n26 41 -20 -15\n42 40 43 19",
"output": "0.02564102564102564014"
},
{
"input": "1\n0 0 100000 100000\n0 0 1 0",
"output": "-1"
},
{
"input": "1\n0 0 100000 100000\n0 0 0 1",
"output": "-1"
},
{
"input": "1\n0 0 100000 100000\n0 0 -1 -1",
"output": "-1"
},
{
"input": "1\n0 0 100000 100000\n1 1 1 1",
"output": "0.00000000000000000000"
},
{
"input": "1\n0 0 10000 10000\n20000 2 -1 0",
"output": "10000.00000000000000000000"
},
{
"input": "1\n0 0 10000 10000\n20000 2 1 0",
"output": "-1"
},
{
"input": "1\n0 0 10000 10000\n10001 10001 -1 -1",
"output": "1.00000000000000000000"
},
{
"input": "1\n0 0 10000 10000\n10001 9999 -1 1",
"output": "-1"
},
{
"input": "1\n1 1 1 1\n1 1 1 1",
"output": "-1"
},
{
"input": "1\n0 0 10 10\n5 5 0 0",
"output": "0.00000000000000000000"
},
{
"input": "1\n0 0 10 10\n5 5 5 5",
"output": "0.00000000000000000000"
},
{
"input": "1\n0 1 2 1\n0 0 1 1",
"output": "-1"
},
{
"input": "1\n1 1 5 5\n1 0 0 1",
"output": "-1"
},
{
"input": "1\n1 1 2 2\n1 1 1 0",
"output": "-1"
},
{
"input": "2\n2 2 5 5\n3 3 1 1\n10 3 -1 0",
"output": "-1"
},
{
"input": "1\n99998 99998 99999 99999\n0 0 99999 100000",
"output": "0.99998999989999903804"
},
{
"input": "1\n1 1 3 3\n2 2 0 0",
"output": "0.00000000000000000000"
},
{
"input": "2\n99999 99999 100000 100000\n1 1 100000 100000\n1 1 99999 99999",
"output": "0.99998999989999903804"
},
{
"input": "1\n0 0 2 2\n1 1 0 0",
"output": "0.00000000000000000000"
},
{
"input": "1\n0 0 1 1\n0 0 0 0",
"output": "-1"
},
{
"input": "1\n0 0 1 1\n0 0 1 0",
"output": "-1"
},
{
"input": "1\n7 7 8 8\n7 7 0 0",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n4 4 0 0",
"output": "-1"
},
{
"input": "1\n0 0 2 2\n1 0 0 0",
"output": "-1"
},
{
"input": "1\n0 0 99999 1\n0 99999 100000 -99999",
"output": "0.99998999989999903804"
},
{
"input": "1\n1 0 2 0\n0 0 1 0",
"output": "-1"
},
{
"input": "1\n1 1 11 11\n5 5 0 0",
"output": "0.00000000000000000000"
},
{
"input": "1\n1 1 1 1\n1 1 0 0",
"output": "-1"
},
{
"input": "4\n0 49998 2 50002\n1 50000 0 0\n1 50000 0 0\n1 0 0 1\n1 100000 0 -1",
"output": "49998.00000000000000000000"
},
{
"input": "1\n0 0 10 10\n0 0 0 0",
"output": "-1"
},
{
"input": "1\n1 1 11 11\n1 2 0 1",
"output": "-1"
},
{
"input": "1\n0 0 100 100\n0 0 1 0",
"output": "-1"
},
{
"input": "1\n1 0 1 2\n0 0 1 1",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n1 1 0 0",
"output": "-1"
},
{
"input": "2\n0 0 5 5\n5 3 0 1\n3 3 1 1",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n1 1 1 0",
"output": "-1"
},
{
"input": "1\n10 10 20 20\n0 10 1 1",
"output": "-1"
},
{
"input": "1\n5 5 10 10\n4 6 1 0",
"output": "1.00000000000000000000"
},
{
"input": "1\n0 0 5 5\n2 5 0 0",
"output": "-1"
},
{
"input": "1\n1 1 2 2\n0 2 1 0",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n0 1 1 0",
"output": "-1"
},
{
"input": "1\n1 1 2 2\n1 1 0 0",
"output": "-1"
},
{
"input": "2\n10 0 12 2\n9 1 1 0\n7 1 1 0",
"output": "-1"
},
{
"input": "1\n2 2 4 4\n3 1 1 1",
"output": "-1"
},
{
"input": "2\n1 1 3 3\n2 10 0 -1\n10000 2 -1 0",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n2 0 1 1",
"output": "-1"
},
{
"input": "2\n0 0 2 100000\n1 1 0 100000\n100000 1 -99999 0",
"output": "0.99998999989999903804"
},
{
"input": "2\n1 1 2 2\n0 0 1 1\n1 1 1 1",
"output": "-1"
},
{
"input": "1\n0 0 2 2\n0 1 0 0",
"output": "-1"
},
{
"input": "1\n1 1 2 2\n0 0 0 0",
"output": "-1"
},
{
"input": "1\n0 0 10 10\n0 0 0 1337",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n1 1 0 1",
"output": "-1"
},
{
"input": "1\n0 0 2 2\n0 1 0 1",
"output": "-1"
},
{
"input": "1\n1 1 3 3\n2 1 0 0",
"output": "-1"
},
{
"input": "1\n0 0 3 3\n1 3 1 0",
"output": "-1"
},
{
"input": "1\n0 0 100 100\n0 0 100 0",
"output": "-1"
}
] | 1,493,882,355
| 2,147,483,647
|
PyPy 3
|
RUNTIME_ERROR
|
TESTS
| 6
| 93
| 0
|
n = int(input())
x1, y1, x2, y2 = list(map(int, input().split()))
span = [0, 10000000]
for _ in range(n):
m = list(map(int, input().split()))
x_range = sorted([(x1-m[0])/m[2], (x2-m[0])/m[2]])
y_range = sorted([(y1-m[1])/m[3], (y2-m[1])/m[3]])
if x_range[1] < 0 or y_range[1] < 0:
span = []
break
r = [max(x_range[0], y_range[0]), min(x_range[1], y_range[1])]
span = [max(r[0], span[0]), min(r[1], span[1])]
#print(span)
if len(span) == 0 or span[1] <= span[0]:
print('-1')
else:
print('%.8f' % (span[0]+0.00000001))
|
Title: Mice problem
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Igor the analyst fell asleep on the work and had a strange dream. In the dream his desk was crowded with computer mice, so he bought a mousetrap to catch them.
The desk can be considered as an infinite plane, then the mousetrap is a rectangle which sides are parallel to the axes, and which opposite sides are located in points (*x*1,<=*y*1) and (*x*2,<=*y*2).
Igor wants to catch all mice. Igor has analysed their behavior and discovered that each mouse is moving along a straight line with constant speed, the speed of the *i*-th mouse is equal to (*v**i**x*,<=*v**i**y*), that means that the *x* coordinate of the mouse increases by *v**i**x* units per second, while the *y* coordinates increases by *v**i**y* units. The mousetrap is open initially so that the mice are able to move freely on the desk. Igor can close the mousetrap at any moment catching all the mice that are strictly inside the mousetrap.
Igor works a lot, so he is busy in the dream as well, and he asks you to write a program that by given mousetrap's coordinates, the initial coordinates of the mice and their speeds determines the earliest time moment in which he is able to catch all the mice. Please note that Igor can close the mousetrap only once.
Input Specification:
The first line contains single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of computer mice on the desk.
The second line contains four integers *x*1, *y*1, *x*2 and *y*2 (0<=≤<=*x*1<=≤<=*x*2<=≤<=100<=000), (0<=≤<=*y*1<=≤<=*y*2<=≤<=100<=000) — the coordinates of the opposite corners of the mousetrap.
The next *n* lines contain the information about mice.
The *i*-th of these lines contains four integers *r**i**x*, *r**i**y*, *v**i**x* and *v**i**y*, (0<=≤<=*r**i**x*,<=*r**i**y*<=≤<=100<=000, <=-<=100<=000<=≤<=*v**i**x*,<=*v**i**y*<=≤<=100<=000), where (*r**i**x*,<=*r**i**y*) is the initial position of the mouse, and (*v**i**x*,<=*v**i**y*) is its speed.
Output Specification:
In the only line print minimum possible non-negative number *t* such that if Igor closes the mousetrap at *t* seconds from the beginning, then all the mice are strictly inside the mousetrap. If there is no such *t*, print -1.
Your answer is considered correct if its absolute or relative error doesn't exceed 10<=-<=6.
Formally, let your answer be *a*, and the jury's answer be *b*. Your answer is considered correct if .
Demo Input:
['4\n7 7 9 8\n3 5 7 5\n7 5 2 4\n3 3 7 8\n6 6 3 2\n', '4\n7 7 9 8\n0 3 -5 4\n5 0 5 4\n9 9 -1 -6\n10 5 -7 -10\n']
Demo Output:
['0.57142857142857139685\n', '-1\n']
Note:
Here is a picture of the first sample
Points A, B, C, D - start mice positions, segments are their paths.
<img class="tex-graphics" src="https://espresso.codeforces.com/9b2a39ff850b63eb3f41de7ce9efc61a192e99b5.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Then, at first time when all mice will be in rectangle it will be looks like this:
<img class="tex-graphics" src="https://espresso.codeforces.com/bfdaed392636d2b1790e7986ca711c1c3ebe298c.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Here is a picture of the second sample
<img class="tex-graphics" src="https://espresso.codeforces.com/a49c381e9f3e453fe5be91a972128def69042e45.png" style="max-width: 100.0%;max-height: 100.0%;"/>
Points A, D, B will never enter rectangle.
|
```python
n = int(input())
x1, y1, x2, y2 = list(map(int, input().split()))
span = [0, 10000000]
for _ in range(n):
m = list(map(int, input().split()))
x_range = sorted([(x1-m[0])/m[2], (x2-m[0])/m[2]])
y_range = sorted([(y1-m[1])/m[3], (y2-m[1])/m[3]])
if x_range[1] < 0 or y_range[1] < 0:
span = []
break
r = [max(x_range[0], y_range[0]), min(x_range[1], y_range[1])]
span = [max(r[0], span[0]), min(r[1], span[1])]
#print(span)
if len(span) == 0 or span[1] <= span[0]:
print('-1')
else:
print('%.8f' % (span[0]+0.00000001))
```
| -1
|
|
597
|
A
|
Divisibility
|
PROGRAMMING
| 1,600
|
[
"math"
] | null | null |
Find the number of *k*-divisible numbers on the segment [*a*,<=*b*]. In other words you need to find the number of such integer values *x* that *a*<=≤<=*x*<=≤<=*b* and *x* is divisible by *k*.
|
The only line contains three space-separated integers *k*, *a* and *b* (1<=≤<=*k*<=≤<=1018;<=-<=1018<=≤<=*a*<=≤<=*b*<=≤<=1018).
|
Print the required number.
|
[
"1 1 10\n",
"2 -4 4\n"
] |
[
"10\n",
"5\n"
] |
none
| 500
|
[
{
"input": "1 1 10",
"output": "10"
},
{
"input": "2 -4 4",
"output": "5"
},
{
"input": "1 1 1",
"output": "1"
},
{
"input": "1 0 0",
"output": "1"
},
{
"input": "1 0 1",
"output": "2"
},
{
"input": "1 10181 10182",
"output": "2"
},
{
"input": "1 10182 10183",
"output": "2"
},
{
"input": "1 -191 1011",
"output": "1203"
},
{
"input": "2 0 0",
"output": "1"
},
{
"input": "2 0 1",
"output": "1"
},
{
"input": "2 1 2",
"output": "1"
},
{
"input": "2 2 3",
"output": "1"
},
{
"input": "2 -1 0",
"output": "1"
},
{
"input": "2 -1 1",
"output": "1"
},
{
"input": "2 -7 -6",
"output": "1"
},
{
"input": "2 -7 -5",
"output": "1"
},
{
"input": "2 -6 -6",
"output": "1"
},
{
"input": "2 -6 -4",
"output": "2"
},
{
"input": "2 -6 13",
"output": "10"
},
{
"input": "2 -19171 1911",
"output": "10541"
},
{
"input": "3 123 456",
"output": "112"
},
{
"input": "3 124 456",
"output": "111"
},
{
"input": "3 125 456",
"output": "111"
},
{
"input": "3 381 281911",
"output": "93844"
},
{
"input": "3 381 281912",
"output": "93844"
},
{
"input": "3 381 281913",
"output": "93845"
},
{
"input": "3 382 281911",
"output": "93843"
},
{
"input": "3 382 281912",
"output": "93843"
},
{
"input": "3 382 281913",
"output": "93844"
},
{
"input": "3 383 281911",
"output": "93843"
},
{
"input": "3 383 281912",
"output": "93843"
},
{
"input": "3 383 281913",
"output": "93844"
},
{
"input": "3 -381 281911",
"output": "94098"
},
{
"input": "3 -381 281912",
"output": "94098"
},
{
"input": "3 -381 281913",
"output": "94099"
},
{
"input": "3 -380 281911",
"output": "94097"
},
{
"input": "3 -380 281912",
"output": "94097"
},
{
"input": "3 -380 281913",
"output": "94098"
},
{
"input": "3 -379 281911",
"output": "94097"
},
{
"input": "3 -379 281912",
"output": "94097"
},
{
"input": "3 -379 281913",
"output": "94098"
},
{
"input": "3 -191381 -1911",
"output": "63157"
},
{
"input": "3 -191381 -1910",
"output": "63157"
},
{
"input": "3 -191381 -1909",
"output": "63157"
},
{
"input": "3 -191380 -1911",
"output": "63157"
},
{
"input": "3 -191380 -1910",
"output": "63157"
},
{
"input": "3 -191380 -1909",
"output": "63157"
},
{
"input": "3 -191379 -1911",
"output": "63157"
},
{
"input": "3 -191379 -1910",
"output": "63157"
},
{
"input": "3 -191379 -1909",
"output": "63157"
},
{
"input": "3 -2810171 0",
"output": "936724"
},
{
"input": "3 0 29101",
"output": "9701"
},
{
"input": "3 -2810170 0",
"output": "936724"
},
{
"input": "3 0 29102",
"output": "9701"
},
{
"input": "3 -2810169 0",
"output": "936724"
},
{
"input": "3 0 29103",
"output": "9702"
},
{
"input": "1 -1000000000000000000 1000000000000000000",
"output": "2000000000000000001"
},
{
"input": "2 -1000000000000000000 1000000000000000000",
"output": "1000000000000000001"
},
{
"input": "3 -1000000000000000000 1000000000000000000",
"output": "666666666666666667"
},
{
"input": "4 -1000000000000000000 1000000000000000000",
"output": "500000000000000001"
},
{
"input": "5 -1000000000000000000 1000000000000000000",
"output": "400000000000000001"
},
{
"input": "6 -1000000000000000000 1000000000000000000",
"output": "333333333333333333"
},
{
"input": "7 -1000000000000000000 1000000000000000000",
"output": "285714285714285715"
},
{
"input": "1 -1000000000000000000 -100000000000000000",
"output": "900000000000000001"
},
{
"input": "2 -1000000000000000000 -10000000000000000",
"output": "495000000000000001"
},
{
"input": "3 -1000000000000000000 -10218000000000000",
"output": "329927333333333334"
},
{
"input": "4 -1000000000000000000 -320110181919100",
"output": "249919972454520226"
},
{
"input": "5 -1000000000000000000 -402710171917",
"output": "199999919457965617"
},
{
"input": "6 -1000000000000000000 -6666666666",
"output": "166666665555555556"
},
{
"input": "7 -1000000000000000000 -77777777777778",
"output": "142846031746031746"
},
{
"input": "1000000000000000000 -1000000000000000000 1000000000000000000",
"output": "3"
},
{
"input": "1000000000000000000 0 1000000000000000000",
"output": "2"
},
{
"input": "1000000000000000000 1000000000000000000 1000000000000000000",
"output": "1"
},
{
"input": "100000000000000321 1000000000000000000 1000000000000000000",
"output": "0"
},
{
"input": "100000000000000321 -1000000000000000000 1000000000000000000",
"output": "19"
},
{
"input": "1000000000000000000 0 0",
"output": "1"
},
{
"input": "1000000000000000000 1 1",
"output": "0"
},
{
"input": "1000000000000000000 -1 -1",
"output": "0"
},
{
"input": "1000000000000000000 -2 -1",
"output": "0"
},
{
"input": "142000000000000271 -228118171 -1382811",
"output": "0"
},
{
"input": "1 1 1000000000000000000",
"output": "1000000000000000000"
}
] | 1,613,462,560
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 58
| 62
| 0
|
def divisibility(k, a, b):
mod = a % k
if mod != 0:
a += k - mod
return int((b - a) / k) + 1
if __name__ == '__main__':
inp = input()
k, a, b = (int(i) for i in inp.split(' '))
print(divisibility(k, a, b))
|
Title: Divisibility
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Find the number of *k*-divisible numbers on the segment [*a*,<=*b*]. In other words you need to find the number of such integer values *x* that *a*<=≤<=*x*<=≤<=*b* and *x* is divisible by *k*.
Input Specification:
The only line contains three space-separated integers *k*, *a* and *b* (1<=≤<=*k*<=≤<=1018;<=-<=1018<=≤<=*a*<=≤<=*b*<=≤<=1018).
Output Specification:
Print the required number.
Demo Input:
['1 1 10\n', '2 -4 4\n']
Demo Output:
['10\n', '5\n']
Note:
none
|
```python
def divisibility(k, a, b):
mod = a % k
if mod != 0:
a += k - mod
return int((b - a) / k) + 1
if __name__ == '__main__':
inp = input()
k, a, b = (int(i) for i in inp.split(' '))
print(divisibility(k, a, b))
```
| 0
|
|
389
|
A
|
Fox and Number Game
|
PROGRAMMING
| 1,000
|
[
"greedy",
"math"
] | null | null |
Fox Ciel is playing a game with numbers now.
Ciel has *n* positive integers: *x*1, *x*2, ..., *x**n*. She can do the following operation as many times as needed: select two different indexes *i* and *j* such that *x**i* > *x**j* hold, and then apply assignment *x**i* = *x**i* - *x**j*. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
|
The first line contains an integer *n* (2<=≤<=*n*<=≤<=100). Then the second line contains *n* integers: *x*1, *x*2, ..., *x**n* (1<=≤<=*x**i*<=≤<=100).
|
Output a single integer — the required minimal sum.
|
[
"2\n1 2\n",
"3\n2 4 6\n",
"2\n12 18\n",
"5\n45 12 27 30 18\n"
] |
[
"2\n",
"6\n",
"12\n",
"15\n"
] |
In the first example the optimal way is to do the assignment: *x*<sub class="lower-index">2</sub> = *x*<sub class="lower-index">2</sub> - *x*<sub class="lower-index">1</sub>.
In the second example the optimal sequence of operations is: *x*<sub class="lower-index">3</sub> = *x*<sub class="lower-index">3</sub> - *x*<sub class="lower-index">2</sub>, *x*<sub class="lower-index">2</sub> = *x*<sub class="lower-index">2</sub> - *x*<sub class="lower-index">1</sub>.
| 500
|
[
{
"input": "2\n1 2",
"output": "2"
},
{
"input": "3\n2 4 6",
"output": "6"
},
{
"input": "2\n12 18",
"output": "12"
},
{
"input": "5\n45 12 27 30 18",
"output": "15"
},
{
"input": "2\n1 1",
"output": "2"
},
{
"input": "2\n100 100",
"output": "200"
},
{
"input": "2\n87 58",
"output": "58"
},
{
"input": "39\n52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52",
"output": "2028"
},
{
"input": "59\n96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96 96",
"output": "5664"
},
{
"input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100",
"output": "10000"
},
{
"input": "100\n70 70 77 42 98 84 56 91 35 21 7 70 77 77 56 63 14 84 56 14 77 77 63 70 14 7 28 91 63 49 21 84 98 56 77 98 98 84 98 14 7 56 49 28 91 98 7 56 14 91 14 98 49 28 98 14 98 98 14 70 35 28 63 28 49 63 63 56 91 98 35 42 42 35 63 35 42 14 63 21 77 56 42 77 35 91 56 21 28 84 56 70 70 91 98 70 84 63 21 98",
"output": "700"
},
{
"input": "39\n63 21 21 42 21 63 21 84 42 21 84 63 42 63 84 84 84 42 42 84 21 63 42 63 42 42 63 42 42 63 84 42 21 84 21 63 42 21 42",
"output": "819"
},
{
"input": "59\n70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70 70",
"output": "4130"
},
{
"input": "87\n44 88 88 88 88 66 88 22 22 88 88 44 88 22 22 22 88 88 88 88 66 22 88 88 88 88 66 66 44 88 44 44 66 22 88 88 22 44 66 44 88 66 66 22 22 22 22 88 22 22 44 66 88 22 22 88 66 66 88 22 66 88 66 88 66 44 88 44 22 44 44 22 44 88 44 44 44 44 22 88 88 88 66 66 88 44 22",
"output": "1914"
},
{
"input": "15\n63 63 63 63 63 63 63 63 63 63 63 63 63 63 63",
"output": "945"
},
{
"input": "39\n63 77 21 14 14 35 21 21 70 42 21 70 28 77 28 77 7 42 63 7 98 49 98 84 35 70 70 91 14 42 98 7 42 7 98 42 56 35 91",
"output": "273"
},
{
"input": "18\n18 18 18 36 36 36 54 72 54 36 72 54 36 36 36 36 18 36",
"output": "324"
},
{
"input": "46\n71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71 71",
"output": "3266"
},
{
"input": "70\n66 11 66 11 44 11 44 99 55 22 88 11 11 22 55 44 22 77 44 77 77 22 44 55 88 11 99 99 88 22 77 77 66 11 11 66 99 55 55 44 66 44 77 44 44 55 33 55 44 88 77 77 22 66 33 44 11 22 55 44 22 66 77 33 33 44 44 44 22 33",
"output": "770"
},
{
"input": "10\n60 12 96 48 60 24 60 36 60 60",
"output": "120"
},
{
"input": "20\n51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51 51",
"output": "1020"
},
{
"input": "50\n58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58",
"output": "2900"
},
{
"input": "98\n70 60 100 30 70 20 30 50 50 30 90 40 30 40 60 80 60 60 80 50 10 80 20 10 20 10 50 70 30 80 30 50 60 90 90 100 60 30 90 20 30 60 90 80 60 60 10 90 10 50 40 40 80 90 100 40 70 40 30 50 60 50 60 30 40 20 90 60 20 20 20 70 60 70 50 100 90 50 20 40 80 60 10 60 50 40 40 10 50 10 40 10 80 100 100 90 10 90",
"output": "980"
},
{
"input": "100\n82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82 82",
"output": "8200"
},
{
"input": "100\n11 87 77 93 3 54 21 93 9 71 37 23 69 85 74 3 48 99 51 31 56 19 21 96 39 6 4 4 29 69 100 42 1 22 81 53 48 49 81 61 10 7 40 61 7 71 51 59 79 44 50 35 95 80 83 8 98 40 18 94 84 49 52 74 66 69 39 37 100 44 38 62 2 80 46 31 35 53 5 60 21 49 63 55 20 53 80 53 66 34 23 92 77 50 86 63 65 24 12 70",
"output": "100"
},
{
"input": "2\n100 1",
"output": "2"
},
{
"input": "2\n18 30",
"output": "12"
},
{
"input": "2\n3 5",
"output": "2"
},
{
"input": "2\n1 10",
"output": "2"
},
{
"input": "2\n8 5",
"output": "2"
},
{
"input": "5\n2 3 5 8 18",
"output": "5"
},
{
"input": "5\n2 4 1 6 8",
"output": "5"
},
{
"input": "3\n12 10 5",
"output": "3"
},
{
"input": "3\n6 10 15",
"output": "3"
}
] | 1,658,231,159
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 4
| 46
| 0
|
n = int(input())
x = list(map(int, input().split()))
if len(x) == 1:
print(x[0])
elif len(x) == 2:
print(abs(x[0] - x[1]) * 2)
else:
min_value = abs(x[0] - x[1])
for i in range(n):
for j in range(n - 1):
if i != j:
if abs(x[i] - x[j]) < min_value:
min_value = abs(x[i] - x[j])
print(min_value * n)
|
Title: Fox and Number Game
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fox Ciel is playing a game with numbers now.
Ciel has *n* positive integers: *x*1, *x*2, ..., *x**n*. She can do the following operation as many times as needed: select two different indexes *i* and *j* such that *x**i* > *x**j* hold, and then apply assignment *x**i* = *x**i* - *x**j*. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input Specification:
The first line contains an integer *n* (2<=≤<=*n*<=≤<=100). Then the second line contains *n* integers: *x*1, *x*2, ..., *x**n* (1<=≤<=*x**i*<=≤<=100).
Output Specification:
Output a single integer — the required minimal sum.
Demo Input:
['2\n1 2\n', '3\n2 4 6\n', '2\n12 18\n', '5\n45 12 27 30 18\n']
Demo Output:
['2\n', '6\n', '12\n', '15\n']
Note:
In the first example the optimal way is to do the assignment: *x*<sub class="lower-index">2</sub> = *x*<sub class="lower-index">2</sub> - *x*<sub class="lower-index">1</sub>.
In the second example the optimal sequence of operations is: *x*<sub class="lower-index">3</sub> = *x*<sub class="lower-index">3</sub> - *x*<sub class="lower-index">2</sub>, *x*<sub class="lower-index">2</sub> = *x*<sub class="lower-index">2</sub> - *x*<sub class="lower-index">1</sub>.
|
```python
n = int(input())
x = list(map(int, input().split()))
if len(x) == 1:
print(x[0])
elif len(x) == 2:
print(abs(x[0] - x[1]) * 2)
else:
min_value = abs(x[0] - x[1])
for i in range(n):
for j in range(n - 1):
if i != j:
if abs(x[i] - x[j]) < min_value:
min_value = abs(x[i] - x[j])
print(min_value * n)
```
| 0
|
|
53
|
B
|
Blog Photo
|
PROGRAMMING
| 1,700
|
[
"binary search",
"implementation"
] |
B. Blog Photo
|
2
|
256
|
One popular blog site edits the uploaded photos like this. It cuts a rectangular area out of them so that the ratio of height to width (i.e. the *height*<=/<=*width* quotient) can vary from 0.8 to 1.25 inclusively. Besides, at least one side of the cut area should have a size, equal to some power of number 2 (2*x* for some integer *x*). If those rules don't indicate the size of the cut are clearly, then the way with which the cut part possesses the largest area is chosen. Of course, both sides of the cut area should be integer. If there are several answers to this problem, you should choose the answer with the maximal height.
|
The first line contains a pair of integers *h* and *w* (1<=≤<=*h*,<=*w*<=≤<=109) which are the height and width of the uploaded photo in pixels.
|
Print two integers which are the height and width of the cut area.
|
[
"2 1\n",
"2 2\n",
"5 5\n"
] |
[
"1 1\n",
"2 2\n",
"5 4\n"
] |
none
| 1,000
|
[
{
"input": "2 1",
"output": "1 1"
},
{
"input": "2 2",
"output": "2 2"
},
{
"input": "5 5",
"output": "5 4"
},
{
"input": "9 10",
"output": "8 10"
},
{
"input": "15 13",
"output": "10 8"
},
{
"input": "47 46",
"output": "40 32"
},
{
"input": "99 100",
"output": "80 64"
},
{
"input": "939 887",
"output": "640 512"
},
{
"input": "4774 4806",
"output": "4096 4806"
},
{
"input": "39271 49032",
"output": "32768 40960"
},
{
"input": "483242 484564",
"output": "327680 262144"
},
{
"input": "4939191 4587461",
"output": "4939191 4194304"
},
{
"input": "9909199 9945873",
"output": "8388608 9945873"
},
{
"input": "49829224 49889315",
"output": "41943040 33554432"
},
{
"input": "49728622 49605627",
"output": "41943040 33554432"
},
{
"input": "49934587 49239195",
"output": "41943040 33554432"
},
{
"input": "48298903 49928606",
"output": "41943040 33554432"
},
{
"input": "49874820 49474021",
"output": "41943040 33554432"
},
{
"input": "48945079 49798393",
"output": "41943040 33554432"
},
{
"input": "99692141 99232337",
"output": "83886080 67108864"
},
{
"input": "998557701 924591072",
"output": "671088640 536870912"
},
{
"input": "644590722 593296648",
"output": "644590722 536870912"
},
{
"input": "792322809 775058858",
"output": "671088640 536870912"
},
{
"input": "971840165 826141527",
"output": "671088640 536870912"
},
{
"input": "944976601 976175854",
"output": "671088640 536870912"
},
{
"input": "1000000000 1000000000",
"output": "671088640 536870912"
}
] | 1,612,966,963
| 2,147,483,647
|
PyPy 3
|
OK
|
TESTS
| 26
| 186
| 0
|
import math
h,w = map(int,input().split())
if h/w>=0.8 and h/w<=1.25 and ((math.log(h,2)%1==0) or (math.log(w,2)%1==0)):
print(h,w)
else:
w1 = 2**(math.log(w,2)//1)
h1 = min(h,(w1*1.25)//1)
h2 = 2**(math.log(h,2)//1)
w2 = min(w,(h2*1.25)//1)
if (h1/w1>=0.8 and h1/w1<=1.25) and (h2/w2>=0.8 and h2/w2<=1.25):
if h1>=h2 and h1*w1>=h2*w2:
print(int(h1),int(w1))
else:
print(int(h2),int(w2))
elif (h1/w1>=0.8 and h1/w1<=1.25):
print(int(h1),int(w1))
else:
print(int(h2),int(w2))
|
Title: Blog Photo
Time Limit: 2 seconds
Memory Limit: 256 megabytes
Problem Description:
One popular blog site edits the uploaded photos like this. It cuts a rectangular area out of them so that the ratio of height to width (i.e. the *height*<=/<=*width* quotient) can vary from 0.8 to 1.25 inclusively. Besides, at least one side of the cut area should have a size, equal to some power of number 2 (2*x* for some integer *x*). If those rules don't indicate the size of the cut are clearly, then the way with which the cut part possesses the largest area is chosen. Of course, both sides of the cut area should be integer. If there are several answers to this problem, you should choose the answer with the maximal height.
Input Specification:
The first line contains a pair of integers *h* and *w* (1<=≤<=*h*,<=*w*<=≤<=109) which are the height and width of the uploaded photo in pixels.
Output Specification:
Print two integers which are the height and width of the cut area.
Demo Input:
['2 1\n', '2 2\n', '5 5\n']
Demo Output:
['1 1\n', '2 2\n', '5 4\n']
Note:
none
|
```python
import math
h,w = map(int,input().split())
if h/w>=0.8 and h/w<=1.25 and ((math.log(h,2)%1==0) or (math.log(w,2)%1==0)):
print(h,w)
else:
w1 = 2**(math.log(w,2)//1)
h1 = min(h,(w1*1.25)//1)
h2 = 2**(math.log(h,2)//1)
w2 = min(w,(h2*1.25)//1)
if (h1/w1>=0.8 and h1/w1<=1.25) and (h2/w2>=0.8 and h2/w2<=1.25):
if h1>=h2 and h1*w1>=h2*w2:
print(int(h1),int(w1))
else:
print(int(h2),int(w2))
elif (h1/w1>=0.8 and h1/w1<=1.25):
print(int(h1),int(w1))
else:
print(int(h2),int(w2))
```
| 3.9535
|
151
|
A
|
Soft Drinking
|
PROGRAMMING
| 800
|
[
"implementation",
"math"
] | null | null |
This winter is so cold in Nvodsk! A group of *n* friends decided to buy *k* bottles of a soft drink called "Take-It-Light" to warm up a bit. Each bottle has *l* milliliters of the drink. Also they bought *c* limes and cut each of them into *d* slices. After that they found *p* grams of salt.
To make a toast, each friend needs *nl* milliliters of the drink, a slice of lime and *np* grams of salt. The friends want to make as many toasts as they can, provided they all drink the same amount. How many toasts can each friend make?
|
The first and only line contains positive integers *n*, *k*, *l*, *c*, *d*, *p*, *nl*, *np*, not exceeding 1000 and no less than 1. The numbers are separated by exactly one space.
|
Print a single integer — the number of toasts each friend can make.
|
[
"3 4 5 10 8 100 3 1\n",
"5 100 10 1 19 90 4 3\n",
"10 1000 1000 25 23 1 50 1\n"
] |
[
"2\n",
"3\n",
"0\n"
] |
A comment to the first sample:
Overall the friends have 4 * 5 = 20 milliliters of the drink, it is enough to make 20 / 3 = 6 toasts. The limes are enough for 10 * 8 = 80 toasts and the salt is enough for 100 / 1 = 100 toasts. However, there are 3 friends in the group, so the answer is *min*(6, 80, 100) / 3 = 2.
| 500
|
[
{
"input": "3 4 5 10 8 100 3 1",
"output": "2"
},
{
"input": "5 100 10 1 19 90 4 3",
"output": "3"
},
{
"input": "10 1000 1000 25 23 1 50 1",
"output": "0"
},
{
"input": "1 7 4 5 5 8 3 2",
"output": "4"
},
{
"input": "2 3 3 5 5 10 1 3",
"output": "1"
},
{
"input": "2 6 4 5 6 5 1 3",
"output": "0"
},
{
"input": "1 7 3 5 3 6 2 1",
"output": "6"
},
{
"input": "2 4 5 4 5 7 3 2",
"output": "1"
},
{
"input": "2 3 6 5 7 8 2 1",
"output": "4"
},
{
"input": "1 4 5 5 3 10 3 1",
"output": "6"
},
{
"input": "1 4 6 7 3 5 1 3",
"output": "1"
},
{
"input": "1 6 5 5 5 8 3 1",
"output": "8"
},
{
"input": "1 7 5 3 3 9 2 1",
"output": "9"
},
{
"input": "3 5 3 7 6 10 3 1",
"output": "1"
},
{
"input": "3 6 3 5 3 6 3 1",
"output": "2"
},
{
"input": "1 7 5 5 5 5 2 2",
"output": "2"
},
{
"input": "2 5 3 5 6 9 2 1",
"output": "3"
},
{
"input": "3 4 3 5 3 6 2 1",
"output": "2"
},
{
"input": "1 5 5 4 7 6 3 1",
"output": "6"
},
{
"input": "2 3 7 6 5 9 3 1",
"output": "3"
},
{
"input": "2 6 5 3 3 8 1 1",
"output": "4"
},
{
"input": "2 4 7 3 4 10 2 1",
"output": "5"
},
{
"input": "1 1000 1000 1000 1000 1000 1 1",
"output": "1000"
},
{
"input": "17 1000 1000 1000 1000 1000 3 7",
"output": "8"
},
{
"input": "115 1000 1000 1000 1000 1000 17 15",
"output": "0"
},
{
"input": "1 587 981 1 2 1 1 1",
"output": "1"
},
{
"input": "1 1 2 1 2 2 1 1",
"output": "2"
}
] | 1,688,480,280
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 0
| 62
| 0
|
ls_input = list(map(int,input().split()))
count = 0
total_vol = ls_input[1]*ls_input[0]
total_slices = ls_input[3]*ls_input[4]
p = ls_input[5]
while True:
total_vol -= ls_input[0]*ls_input[6]
total_slices -= ls_input[0]
p -= ls_input[0]*ls_input[7]
if total_vol >= 0 and total_slices >= 0 and p >= 0:
count += 1
else:
break
print(count)
|
Title: Soft Drinking
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
This winter is so cold in Nvodsk! A group of *n* friends decided to buy *k* bottles of a soft drink called "Take-It-Light" to warm up a bit. Each bottle has *l* milliliters of the drink. Also they bought *c* limes and cut each of them into *d* slices. After that they found *p* grams of salt.
To make a toast, each friend needs *nl* milliliters of the drink, a slice of lime and *np* grams of salt. The friends want to make as many toasts as they can, provided they all drink the same amount. How many toasts can each friend make?
Input Specification:
The first and only line contains positive integers *n*, *k*, *l*, *c*, *d*, *p*, *nl*, *np*, not exceeding 1000 and no less than 1. The numbers are separated by exactly one space.
Output Specification:
Print a single integer — the number of toasts each friend can make.
Demo Input:
['3 4 5 10 8 100 3 1\n', '5 100 10 1 19 90 4 3\n', '10 1000 1000 25 23 1 50 1\n']
Demo Output:
['2\n', '3\n', '0\n']
Note:
A comment to the first sample:
Overall the friends have 4 * 5 = 20 milliliters of the drink, it is enough to make 20 / 3 = 6 toasts. The limes are enough for 10 * 8 = 80 toasts and the salt is enough for 100 / 1 = 100 toasts. However, there are 3 friends in the group, so the answer is *min*(6, 80, 100) / 3 = 2.
|
```python
ls_input = list(map(int,input().split()))
count = 0
total_vol = ls_input[1]*ls_input[0]
total_slices = ls_input[3]*ls_input[4]
p = ls_input[5]
while True:
total_vol -= ls_input[0]*ls_input[6]
total_slices -= ls_input[0]
p -= ls_input[0]*ls_input[7]
if total_vol >= 0 and total_slices >= 0 and p >= 0:
count += 1
else:
break
print(count)
```
| 0
|
|
510
|
A
|
Fox And Snake
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a *n* by *m* table. Denote *c*-th cell of *r*-th row as (*r*,<=*c*). The tail of the snake is located at (1,<=1), then it's body extends to (1,<=*m*), then goes down 2 rows to (3,<=*m*), then goes left to (3,<=1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
|
The only line contains two integers: *n* and *m* (3<=≤<=*n*,<=*m*<=≤<=50).
*n* is an odd number.
|
Output *n* lines. Each line should contain a string consisting of *m* characters. Do not output spaces.
|
[
"3 3\n",
"3 4\n",
"5 3\n",
"9 9\n"
] |
[
"###\n..#\n###\n",
"####\n...#\n####\n",
"###\n..#\n###\n#..\n###\n",
"#########\n........#\n#########\n#........\n#########\n........#\n#########\n#........\n#########\n"
] |
none
| 500
|
[
{
"input": "3 3",
"output": "###\n..#\n###"
},
{
"input": "3 4",
"output": "####\n...#\n####"
},
{
"input": "5 3",
"output": "###\n..#\n###\n#..\n###"
},
{
"input": "9 9",
"output": "#########\n........#\n#########\n#........\n#########\n........#\n#########\n#........\n#########"
},
{
"input": "3 5",
"output": "#####\n....#\n#####"
},
{
"input": "3 6",
"output": "######\n.....#\n######"
},
{
"input": "7 3",
"output": "###\n..#\n###\n#..\n###\n..#\n###"
},
{
"input": "7 4",
"output": "####\n...#\n####\n#...\n####\n...#\n####"
},
{
"input": "49 50",
"output": "##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.............................................."
},
{
"input": "43 50",
"output": "##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.............................................."
},
{
"input": "43 27",
"output": "###########################\n..........................#\n###########################\n#..........................\n###########################\n..........................#\n###########################\n#..........................\n###########################\n..........................#\n###########################\n#..........................\n###########################\n..........................#\n###########################\n#..........................\n###########################\n....................."
},
{
"input": "11 15",
"output": "###############\n..............#\n###############\n#..............\n###############\n..............#\n###############\n#..............\n###############\n..............#\n###############"
},
{
"input": "11 3",
"output": "###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###"
},
{
"input": "19 3",
"output": "###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###"
},
{
"input": "23 50",
"output": "##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.................................................#\n##################################################\n#.................................................\n##################################################\n.............................................."
},
{
"input": "49 49",
"output": "#################################################\n................................................#\n#################################################\n#................................................\n#################################################\n................................................#\n#################################################\n#................................................\n#################################################\n................................................#\n#..."
},
{
"input": "33 43",
"output": "###########################################\n..........................................#\n###########################################\n#..........................................\n###########################################\n..........................................#\n###########################################\n#..........................................\n###########################################\n..........................................#\n###########################################\n#.................."
},
{
"input": "33 44",
"output": "############################################\n...........................................#\n############################################\n#...........................................\n############################################\n...........................................#\n############################################\n#...........................................\n############################################\n...........................................#\n############################################\n#......."
},
{
"input": "45 45",
"output": "#############################################\n............................................#\n#############################################\n#............................................\n#############################################\n............................................#\n#############################################\n#............................................\n#############################################\n............................................#\n#########################################..."
},
{
"input": "45 49",
"output": "#################################################\n................................................#\n#################################################\n#................................................\n#################################################\n................................................#\n#################################################\n#................................................\n#################################################\n................................................#\n#..."
},
{
"input": "45 3",
"output": "###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###\n..#\n###\n#..\n###"
},
{
"input": "45 4",
"output": "####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####\n...#\n####\n#...\n####"
},
{
"input": "5 4",
"output": "####\n...#\n####\n#...\n####"
},
{
"input": "5 5",
"output": "#####\n....#\n#####\n#....\n#####"
},
{
"input": "5 6",
"output": "######\n.....#\n######\n#.....\n######"
},
{
"input": "7 5",
"output": "#####\n....#\n#####\n#....\n#####\n....#\n#####"
},
{
"input": "7 6",
"output": "######\n.....#\n######\n#.....\n######\n.....#\n######"
},
{
"input": "7 7",
"output": "#######\n......#\n#######\n#......\n#######\n......#\n#######"
}
] | 1,697,592,692
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 31
| 0
|
n = [int(x) for x in input().split()]
line = n[0]
symbols = n[1]
points = symbols
line_hash = ""
line_points = ""
hashes = "#"*symbols
points = "."*(points -1)
izquierda = False
for lines in range(line):
if lines % 2 != 1:
print(hashes)
else:
if not izquierda:
print(points + "#")
else:
print("#" + points)
|
Title: Fox And Snake
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a *n* by *m* table. Denote *c*-th cell of *r*-th row as (*r*,<=*c*). The tail of the snake is located at (1,<=1), then it's body extends to (1,<=*m*), then goes down 2 rows to (3,<=*m*), then goes left to (3,<=1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input Specification:
The only line contains two integers: *n* and *m* (3<=≤<=*n*,<=*m*<=≤<=50).
*n* is an odd number.
Output Specification:
Output *n* lines. Each line should contain a string consisting of *m* characters. Do not output spaces.
Demo Input:
['3 3\n', '3 4\n', '5 3\n', '9 9\n']
Demo Output:
['###\n..#\n###\n', '####\n...#\n####\n', '###\n..#\n###\n#..\n###\n', '#########\n........#\n#########\n#........\n#########\n........#\n#########\n#........\n#########\n']
Note:
none
|
```python
n = [int(x) for x in input().split()]
line = n[0]
symbols = n[1]
points = symbols
line_hash = ""
line_points = ""
hashes = "#"*symbols
points = "."*(points -1)
izquierda = False
for lines in range(line):
if lines % 2 != 1:
print(hashes)
else:
if not izquierda:
print(points + "#")
else:
print("#" + points)
```
| 0
|
|
855
|
A
|
Tom Riddle's Diary
|
PROGRAMMING
| 800
|
[
"brute force",
"implementation",
"strings"
] | null | null |
Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they are not under its influence.
He has names of *n* people who possessed the diary in order. You need to tell, for each person, if he/she possessed the diary at some point before or not.
Formally, for a name *s**i* in the *i*-th line, output "YES" (without quotes) if there exists an index *j* such that *s**i*<==<=*s**j* and *j*<=<<=*i*, otherwise, output "NO" (without quotes).
|
First line of input contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of names in the list.
Next *n* lines each contain a string *s**i*, consisting of lowercase English letters. The length of each string is between 1 and 100.
|
Output *n* lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not.
You can print each letter in any case (upper or lower).
|
[
"6\ntom\nlucius\nginny\nharry\nginny\nharry\n",
"3\na\na\na\n"
] |
[
"NO\nNO\nNO\nNO\nYES\nYES\n",
"NO\nYES\nYES\n"
] |
In test case 1, for *i* = 5 there exists *j* = 3 such that *s*<sub class="lower-index">*i*</sub> = *s*<sub class="lower-index">*j*</sub> and *j* < *i*, which means that answer for *i* = 5 is "YES".
| 500
|
[
{
"input": "6\ntom\nlucius\nginny\nharry\nginny\nharry",
"output": "NO\nNO\nNO\nNO\nYES\nYES"
},
{
"input": "3\na\na\na",
"output": "NO\nYES\nYES"
},
{
"input": "1\nzn",
"output": "NO"
},
{
"input": "9\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nliyzmbjwnzryjokufuxcqtzwworjeoxkbaqrujrhdidqdvwdfzilwszgnzglnnbogaclckfnbqovtziuhwvyrqwmskx\nhrtm\nssjqvixduertmotgagizamvfucfwtxqnhuowbqbzctgznivehelpcyigwrbbdsxnewfqvcf\nhyrtxvozpbveexfkgalmguozzakitjiwsduqxonb\nwcyxteiwtcyuztaguilqpbiwcwjaiq\nwcyxteiwtcyuztaguilqpbiwcwjaiq\nbdbivqzvhggth",
"output": "NO\nYES\nYES\nNO\nNO\nNO\nNO\nYES\nNO"
},
{
"input": "10\nkkiubdktydpdcbbttwpfdplhhjhrpqmpg\nkkiubdktydpdcbbttwpfdplhhjhrpqmpg\nmvutw\nqooeqoxzxwetlpecqiwgdbogiqqulttysyohwhzxzphvsfmnplizxoebzcvvfyppqbhxjksuzepuezqqzxlfmdanoeaoqmor\nmvutw\nvchawxjoreboqzuklifv\nvchawxjoreboqzuklifv\nnivijte\nrflybruq\nvchawxjoreboqzuklifv",
"output": "NO\nYES\nNO\nNO\nYES\nNO\nYES\nNO\nNO\nYES"
},
{
"input": "1\nz",
"output": "NO"
},
{
"input": "9\nl\ny\nm\nj\nn\nr\nj\nk\nf",
"output": "NO\nNO\nNO\nNO\nNO\nNO\nYES\nNO\nNO"
},
{
"input": "14\nw\na\nh\np\nk\nw\ny\nv\ns\nf\nx\nd\nk\nr",
"output": "NO\nNO\nNO\nNO\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nNO"
},
{
"input": "25\np\nk\nu\nl\nf\nt\nc\ns\nq\nd\nb\nq\no\ni\ni\nd\ni\nw\nn\ng\nw\nt\na\ne\ni",
"output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nNO\nNO\nYES\nYES\nYES\nNO\nNO\nNO\nYES\nYES\nNO\nNO\nYES"
},
{
"input": "20\nd\nh\ng\no\np\ne\nt\nj\nv\ni\nt\nh\ns\ni\nw\nf\nx\na\nl\ni",
"output": "NO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nNO\nYES\nYES\nNO\nYES\nNO\nNO\nNO\nNO\nNO\nYES"
},
{
"input": "3\nbbbbbbb\nbbbbbbbbb\nbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"output": "NO\nNO\nNO"
},
{
"input": "2\nab\nba",
"output": "NO\nNO"
},
{
"input": "6\ntom\nlucius\nginnys\nharpy\nginny\nharry",
"output": "NO\nNO\nNO\nNO\nNO\nNO"
},
{
"input": "2\nabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde\nabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde",
"output": "NO\nYES"
},
{
"input": "42\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na\na",
"output": "NO\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nYES"
}
] | 1,671,346,309
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 55
| 46
| 0
|
n = int(input())
x = {}
for i in range(n):
s = input()
if not x.get(s):
x[s] = 1
print("NO")
else:
print("YES")
|
Title: Tom Riddle's Diary
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Harry Potter is on a mission to destroy You-Know-Who's Horcruxes. The first Horcrux that he encountered in the Chamber of Secrets is Tom Riddle's diary. The diary was with Ginny and it forced her to open the Chamber of Secrets. Harry wants to know the different people who had ever possessed the diary to make sure they are not under its influence.
He has names of *n* people who possessed the diary in order. You need to tell, for each person, if he/she possessed the diary at some point before or not.
Formally, for a name *s**i* in the *i*-th line, output "YES" (without quotes) if there exists an index *j* such that *s**i*<==<=*s**j* and *j*<=<<=*i*, otherwise, output "NO" (without quotes).
Input Specification:
First line of input contains an integer *n* (1<=≤<=*n*<=≤<=100) — the number of names in the list.
Next *n* lines each contain a string *s**i*, consisting of lowercase English letters. The length of each string is between 1 and 100.
Output Specification:
Output *n* lines each containing either "YES" or "NO" (without quotes), depending on whether this string was already present in the stream or not.
You can print each letter in any case (upper or lower).
Demo Input:
['6\ntom\nlucius\nginny\nharry\nginny\nharry\n', '3\na\na\na\n']
Demo Output:
['NO\nNO\nNO\nNO\nYES\nYES\n', 'NO\nYES\nYES\n']
Note:
In test case 1, for *i* = 5 there exists *j* = 3 such that *s*<sub class="lower-index">*i*</sub> = *s*<sub class="lower-index">*j*</sub> and *j* < *i*, which means that answer for *i* = 5 is "YES".
|
```python
n = int(input())
x = {}
for i in range(n):
s = input()
if not x.get(s):
x[s] = 1
print("NO")
else:
print("YES")
```
| 3
|
|
431
|
A
|
Black Square
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
Quite recently, a very smart student named Jury decided that lectures are boring, so he downloaded a game called "Black Square" on his super cool touchscreen phone.
In this game, the phone's screen is divided into four vertical strips. Each second, a black square appears on some of the strips. According to the rules of the game, Jury must use this second to touch the corresponding strip to make the square go away. As Jury is both smart and lazy, he counted that he wastes exactly *a**i* calories on touching the *i*-th strip.
You've got a string *s*, describing the process of the game and numbers *a*1,<=*a*2,<=*a*3,<=*a*4. Calculate how many calories Jury needs to destroy all the squares?
|
The first line contains four space-separated integers *a*1, *a*2, *a*3, *a*4 (0<=≤<=*a*1,<=*a*2,<=*a*3,<=*a*4<=≤<=104).
The second line contains string *s* (1<=≤<=|*s*|<=≤<=105), where the *і*-th character of the string equals "1", if on the *i*-th second of the game the square appears on the first strip, "2", if it appears on the second strip, "3", if it appears on the third strip, "4", if it appears on the fourth strip.
|
Print a single integer — the total number of calories that Jury wastes.
|
[
"1 2 3 4\n123214\n",
"1 5 3 2\n11221\n"
] |
[
"13\n",
"13\n"
] |
none
| 500
|
[
{
"input": "1 2 3 4\n123214",
"output": "13"
},
{
"input": "1 5 3 2\n11221",
"output": "13"
},
{
"input": "5 5 5 1\n3422",
"output": "16"
},
{
"input": "4 3 2 1\n2",
"output": "3"
},
{
"input": "5651 6882 6954 4733\n2442313421",
"output": "60055"
},
{
"input": "0 0 0 0\n4132",
"output": "0"
},
{
"input": "3163 5778 83 7640\n11141442444",
"output": "64270"
},
{
"input": "1809 1302 7164 6122\n3144121413113111223311232232114144321414421243443243422322144324121433444342231344234443332241322442",
"output": "420780"
},
{
"input": "0 0 0 0\n1",
"output": "0"
},
{
"input": "1 2 3 4\n4",
"output": "4"
},
{
"input": "2343 7653 1242 5432\n1",
"output": "2343"
},
{
"input": "2343 7653 1242 5432\n2",
"output": "7653"
},
{
"input": "2343 7653 1242 5432\n3",
"output": "1242"
},
{
"input": "2343 7653 1242 5432\n4",
"output": "5432"
},
{
"input": "1 2 3 4\n123412",
"output": "13"
},
{
"input": "50 50 50 50\n11111111111111111111111111111111111111111111111111111",
"output": "2650"
},
{
"input": "1 2 3 4\n11111111111111111111111111111111111111111111111111",
"output": "50"
},
{
"input": "1 2 3 4\n23123231321231231231231231221232123121312321",
"output": "87"
},
{
"input": "1 2 3 4\n1111111111111222222222233333333333444444444444444",
"output": "126"
},
{
"input": "2 3 1 4\n121321232412342112312313213123123412131231231232",
"output": "105"
}
] | 1,684,282,416
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 49
| 77
| 102,400
|
cal=list(map(int, input().split()))
do_training=input()
count=0
for i in do_training:
count+=cal[int(i)-1]
print((count))
|
Title: Black Square
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Quite recently, a very smart student named Jury decided that lectures are boring, so he downloaded a game called "Black Square" on his super cool touchscreen phone.
In this game, the phone's screen is divided into four vertical strips. Each second, a black square appears on some of the strips. According to the rules of the game, Jury must use this second to touch the corresponding strip to make the square go away. As Jury is both smart and lazy, he counted that he wastes exactly *a**i* calories on touching the *i*-th strip.
You've got a string *s*, describing the process of the game and numbers *a*1,<=*a*2,<=*a*3,<=*a*4. Calculate how many calories Jury needs to destroy all the squares?
Input Specification:
The first line contains four space-separated integers *a*1, *a*2, *a*3, *a*4 (0<=≤<=*a*1,<=*a*2,<=*a*3,<=*a*4<=≤<=104).
The second line contains string *s* (1<=≤<=|*s*|<=≤<=105), where the *і*-th character of the string equals "1", if on the *i*-th second of the game the square appears on the first strip, "2", if it appears on the second strip, "3", if it appears on the third strip, "4", if it appears on the fourth strip.
Output Specification:
Print a single integer — the total number of calories that Jury wastes.
Demo Input:
['1 2 3 4\n123214\n', '1 5 3 2\n11221\n']
Demo Output:
['13\n', '13\n']
Note:
none
|
```python
cal=list(map(int, input().split()))
do_training=input()
count=0
for i in do_training:
count+=cal[int(i)-1]
print((count))
```
| 3
|
|
932
|
B
|
Recursive Queries
|
PROGRAMMING
| 1,300
|
[
"binary search",
"data structures",
"dfs and similar"
] | null | null |
Let us define two functions *f* and *g* on positive integer numbers.
You need to process *Q* queries. In each query, you will be given three integers *l*, *r* and *k*. You need to print the number of integers *x* between *l* and *r* inclusive, such that *g*(*x*)<==<=*k*.
|
The first line of the input contains an integer *Q* (1<=≤<=*Q*<=≤<=2<=×<=105) representing the number of queries.
*Q* lines follow, each of which contains 3 integers *l*, *r* and *k* (1<=≤<=*l*<=≤<=*r*<=≤<=106,<=1<=≤<=*k*<=≤<=9).
|
For each query, print a single line containing the answer for that query.
|
[
"4\n22 73 9\n45 64 6\n47 55 7\n2 62 4\n",
"4\n82 94 6\n56 67 4\n28 59 9\n39 74 4\n"
] |
[
"1\n4\n0\n8\n",
"3\n1\n1\n5\n"
] |
In the first example:
- *g*(33) = 9 as *g*(33) = *g*(3 × 3) = *g*(9) = 9 - *g*(47) = *g*(48) = *g*(60) = *g*(61) = 6 - There are no such integers between 47 and 55. - *g*(4) = *g*(14) = *g*(22) = *g*(27) = *g*(39) = *g*(40) = *g*(41) = *g*(58) = 4
| 1,000
|
[
{
"input": "4\n22 73 9\n45 64 6\n47 55 7\n2 62 4",
"output": "1\n4\n0\n8"
},
{
"input": "4\n82 94 6\n56 67 4\n28 59 9\n39 74 4",
"output": "3\n1\n1\n5"
}
] | 1,518,773,102
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 46
| 5,632,000
|
cache = {0: [0] * 10}
def f(x):
m = 1
if x < 10:
return x
while x > 0:
if x % 10 != 0:
m *= x % 10
x = x // 10
return f(m)
def fill_arr(cache, r):
for i in range(len(cache), r + 1):
x = f(i)
cache[i] = cache[i - 1][0:10]
cache[i][x] += 1
for i in range(int(input())):
l, r, k = (int(x) for x in input().split())
if r not in cache:
fill_arr(cache, r)
print(cache[r][k] - cache[l][k])
# fill_arr(cache, 14)
# print('\n'.join(str(x) for x in cache.items()))
# # print(cache)
|
Title: Recursive Queries
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Let us define two functions *f* and *g* on positive integer numbers.
You need to process *Q* queries. In each query, you will be given three integers *l*, *r* and *k*. You need to print the number of integers *x* between *l* and *r* inclusive, such that *g*(*x*)<==<=*k*.
Input Specification:
The first line of the input contains an integer *Q* (1<=≤<=*Q*<=≤<=2<=×<=105) representing the number of queries.
*Q* lines follow, each of which contains 3 integers *l*, *r* and *k* (1<=≤<=*l*<=≤<=*r*<=≤<=106,<=1<=≤<=*k*<=≤<=9).
Output Specification:
For each query, print a single line containing the answer for that query.
Demo Input:
['4\n22 73 9\n45 64 6\n47 55 7\n2 62 4\n', '4\n82 94 6\n56 67 4\n28 59 9\n39 74 4\n']
Demo Output:
['1\n4\n0\n8\n', '3\n1\n1\n5\n']
Note:
In the first example:
- *g*(33) = 9 as *g*(33) = *g*(3 × 3) = *g*(9) = 9 - *g*(47) = *g*(48) = *g*(60) = *g*(61) = 6 - There are no such integers between 47 and 55. - *g*(4) = *g*(14) = *g*(22) = *g*(27) = *g*(39) = *g*(40) = *g*(41) = *g*(58) = 4
|
```python
cache = {0: [0] * 10}
def f(x):
m = 1
if x < 10:
return x
while x > 0:
if x % 10 != 0:
m *= x % 10
x = x // 10
return f(m)
def fill_arr(cache, r):
for i in range(len(cache), r + 1):
x = f(i)
cache[i] = cache[i - 1][0:10]
cache[i][x] += 1
for i in range(int(input())):
l, r, k = (int(x) for x in input().split())
if r not in cache:
fill_arr(cache, r)
print(cache[r][k] - cache[l][k])
# fill_arr(cache, 14)
# print('\n'.join(str(x) for x in cache.items()))
# # print(cache)
```
| 0
|
|
688
|
B
|
Lovely Palindromes
|
PROGRAMMING
| 1,000
|
[
"constructive algorithms",
"math"
] | null | null |
Pari has a friend who loves palindrome numbers. A palindrome number is a number that reads the same forward or backward. For example 12321, 100001 and 1 are palindrome numbers, while 112 and 1021 are not.
Pari is trying to love them too, but only very special and gifted people can understand the beauty behind palindrome numbers. Pari loves integers with even length (i.e. the numbers with even number of digits), so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them.
Now Pari asks you to write a program that gets a huge integer *n* from the input and tells what is the *n*-th even-length positive palindrome number?
|
The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=10100<=000).
|
Print the *n*-th even-length palindrome number.
|
[
"1\n",
"10\n"
] |
[
"11\n",
"1001\n"
] |
The first 10 even-length palindrome numbers are 11, 22, 33, ... , 88, 99 and 1001.
| 1,000
|
[
{
"input": "1",
"output": "11"
},
{
"input": "10",
"output": "1001"
},
{
"input": "11",
"output": "1111"
},
{
"input": "12",
"output": "1221"
},
{
"input": "100",
"output": "100001"
},
{
"input": "1321",
"output": "13211231"
},
{
"input": "2",
"output": "22"
},
{
"input": "3",
"output": "33"
},
{
"input": "4",
"output": "44"
},
{
"input": "5",
"output": "55"
},
{
"input": "6",
"output": "66"
},
{
"input": "7",
"output": "77"
},
{
"input": "8",
"output": "88"
},
{
"input": "9",
"output": "99"
},
{
"input": "13",
"output": "1331"
},
{
"input": "14",
"output": "1441"
},
{
"input": "15",
"output": "1551"
},
{
"input": "16",
"output": "1661"
},
{
"input": "17",
"output": "1771"
},
{
"input": "18",
"output": "1881"
},
{
"input": "19",
"output": "1991"
},
{
"input": "20",
"output": "2002"
},
{
"input": "26550",
"output": "2655005562"
},
{
"input": "16137",
"output": "1613773161"
},
{
"input": "91471",
"output": "9147117419"
},
{
"input": "41242",
"output": "4124224214"
},
{
"input": "30866",
"output": "3086666803"
},
{
"input": "4442231232741003009964183199713851566466079882929007253443848371978048610682180431295671905105980116",
"output": "44422312327410030099641831997138515664660798829290072534438483719780486106821804312956719051059801166110895015091765921340812860168408791738483443527009292889706646651583179913814699003001472321322444"
},
{
"input": "7806526084732010742850470902979267046151204705563201965818390803445852115032119297648697933316807252",
"output": "78065260847320107428504709029792670461512047055632019658183908034458521150321192976486979333168072522527086133397968467929112305112585443080938185691023655074021516407629792090740582470102374806256087"
},
{
"input": "2244399823612183124978103773977739948197709395321563148611877999503840818596183803323258317041875913",
"output": "22443998236121831249781037739777399481977093953215631486118779995038408185961838033232583170418759133195781407138523233083816958180483059997781168413651235939077918499377793773018794213812163289934422"
},
{
"input": "123451",
"output": "123451154321"
}
] | 1,688,104,597
| 2,147,483,647
|
PyPy 3-64
|
OK
|
TESTS
| 40
| 62
| 409,600
|
x = input()
y = x[::-1]
z = x+y
print(z)
|
Title: Lovely Palindromes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Pari has a friend who loves palindrome numbers. A palindrome number is a number that reads the same forward or backward. For example 12321, 100001 and 1 are palindrome numbers, while 112 and 1021 are not.
Pari is trying to love them too, but only very special and gifted people can understand the beauty behind palindrome numbers. Pari loves integers with even length (i.e. the numbers with even number of digits), so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them.
Now Pari asks you to write a program that gets a huge integer *n* from the input and tells what is the *n*-th even-length positive palindrome number?
Input Specification:
The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=10100<=000).
Output Specification:
Print the *n*-th even-length palindrome number.
Demo Input:
['1\n', '10\n']
Demo Output:
['11\n', '1001\n']
Note:
The first 10 even-length palindrome numbers are 11, 22, 33, ... , 88, 99 and 1001.
|
```python
x = input()
y = x[::-1]
z = x+y
print(z)
```
| 3
|
|
849
|
A
|
Odds and Ends
|
PROGRAMMING
| 1,000
|
[
"implementation"
] | null | null |
Where do odds begin, and where do they end? Where does hope emerge, and will they ever break?
Given an integer sequence *a*1,<=*a*2,<=...,<=*a**n* of length *n*. Decide whether it is possible to divide it into an odd number of non-empty subsegments, the each of which has an odd length and begins and ends with odd numbers.
A subsegment is a contiguous slice of the whole sequence. For example, {3,<=4,<=5} and {1} are subsegments of sequence {1,<=2,<=3,<=4,<=5,<=6}, while {1,<=2,<=4} and {7} are not.
|
The first line of input contains a non-negative integer *n* (1<=≤<=*n*<=≤<=100) — the length of the sequence.
The second line contains *n* space-separated non-negative integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=100) — the elements of the sequence.
|
Output "Yes" if it's possible to fulfill the requirements, and "No" otherwise.
You can output each letter in any case (upper or lower).
|
[
"3\n1 3 5\n",
"5\n1 0 1 5 1\n",
"3\n4 3 1\n",
"4\n3 9 9 3\n"
] |
[
"Yes\n",
"Yes\n",
"No\n",
"No\n"
] |
In the first example, divide the sequence into 1 subsegment: {1, 3, 5} and the requirements will be met.
In the second example, divide the sequence into 3 subsegments: {1, 0, 1}, {5}, {1}.
In the third example, one of the subsegments must start with 4 which is an even number, thus the requirements cannot be met.
In the fourth example, the sequence can be divided into 2 subsegments: {3, 9, 9}, {3}, but this is not a valid solution because 2 is an even number.
| 500
|
[
{
"input": "3\n1 3 5",
"output": "Yes"
},
{
"input": "5\n1 0 1 5 1",
"output": "Yes"
},
{
"input": "3\n4 3 1",
"output": "No"
},
{
"input": "4\n3 9 9 3",
"output": "No"
},
{
"input": "1\n1",
"output": "Yes"
},
{
"input": "5\n100 99 100 99 99",
"output": "No"
},
{
"input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100",
"output": "No"
},
{
"input": "1\n0",
"output": "No"
},
{
"input": "2\n1 1",
"output": "No"
},
{
"input": "2\n10 10",
"output": "No"
},
{
"input": "2\n54 21",
"output": "No"
},
{
"input": "5\n0 0 0 0 0",
"output": "No"
},
{
"input": "5\n67 92 0 26 43",
"output": "Yes"
},
{
"input": "15\n45 52 35 80 68 80 93 57 47 32 69 23 63 90 43",
"output": "Yes"
},
{
"input": "15\n81 28 0 82 71 64 63 89 87 92 38 30 76 72 36",
"output": "No"
},
{
"input": "50\n49 32 17 59 77 98 65 50 85 10 40 84 65 34 52 25 1 31 61 45 48 24 41 14 76 12 33 76 44 86 53 33 92 58 63 93 50 24 31 79 67 50 72 93 2 38 32 14 87 99",
"output": "No"
},
{
"input": "55\n65 69 53 66 11 100 68 44 43 17 6 66 24 2 6 6 61 72 91 53 93 61 52 96 56 42 6 8 79 49 76 36 83 58 8 43 2 90 71 49 80 21 75 13 76 54 95 61 58 82 40 33 73 61 46",
"output": "No"
},
{
"input": "99\n73 89 51 85 42 67 22 80 75 3 90 0 52 100 90 48 7 15 41 1 54 2 23 62 86 68 2 87 57 12 45 34 68 54 36 49 27 46 22 70 95 90 57 91 90 79 48 89 67 92 28 27 25 37 73 66 13 89 7 99 62 53 48 24 73 82 62 88 26 39 21 86 50 95 26 27 60 6 56 14 27 90 55 80 97 18 37 36 70 2 28 53 36 77 39 79 82 42 69",
"output": "Yes"
},
{
"input": "99\n99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99",
"output": "Yes"
},
{
"input": "100\n61 63 34 45 20 91 31 28 40 27 94 1 73 5 69 10 56 94 80 23 79 99 59 58 13 56 91 59 77 78 88 72 80 72 70 71 63 60 41 41 41 27 83 10 43 14 35 48 0 78 69 29 63 33 42 67 1 74 51 46 79 41 37 61 16 29 82 28 22 14 64 49 86 92 82 55 54 24 75 58 95 31 3 34 26 23 78 91 49 6 30 57 27 69 29 54 42 0 61 83",
"output": "No"
},
{
"input": "6\n1 2 2 2 2 1",
"output": "No"
},
{
"input": "3\n1 2 1",
"output": "Yes"
},
{
"input": "4\n1 3 2 3",
"output": "No"
},
{
"input": "6\n1 1 1 1 1 1",
"output": "No"
},
{
"input": "6\n1 1 0 0 1 1",
"output": "No"
},
{
"input": "4\n1 4 9 3",
"output": "No"
},
{
"input": "4\n1 0 1 1",
"output": "No"
},
{
"input": "10\n1 0 0 1 1 1 1 1 1 1",
"output": "No"
},
{
"input": "10\n9 2 5 7 8 3 1 9 4 9",
"output": "No"
},
{
"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 2",
"output": "No"
},
{
"input": "6\n1 2 1 2 2 1",
"output": "No"
},
{
"input": "6\n1 0 1 0 0 1",
"output": "No"
},
{
"input": "4\n1 3 4 7",
"output": "No"
},
{
"input": "8\n1 1 1 2 1 1 1 1",
"output": "No"
},
{
"input": "3\n1 1 2",
"output": "No"
},
{
"input": "5\n1 2 1 2 1",
"output": "Yes"
},
{
"input": "5\n5 4 4 2 1",
"output": "Yes"
},
{
"input": "6\n1 3 3 3 3 1",
"output": "No"
},
{
"input": "7\n1 2 1 2 2 2 1",
"output": "Yes"
},
{
"input": "4\n1 2 2 1",
"output": "No"
},
{
"input": "6\n1 2 3 4 6 5",
"output": "No"
},
{
"input": "5\n1 1 2 2 2",
"output": "No"
},
{
"input": "5\n1 0 0 1 1",
"output": "Yes"
},
{
"input": "3\n1 2 4",
"output": "No"
},
{
"input": "3\n1 0 2",
"output": "No"
},
{
"input": "5\n1 1 1 0 1",
"output": "Yes"
},
{
"input": "4\n3 9 2 3",
"output": "No"
},
{
"input": "6\n1 1 1 4 4 1",
"output": "No"
},
{
"input": "6\n1 2 3 5 6 7",
"output": "No"
},
{
"input": "6\n1 1 1 2 2 1",
"output": "No"
},
{
"input": "6\n1 1 1 0 0 1",
"output": "No"
},
{
"input": "5\n1 2 2 5 5",
"output": "Yes"
},
{
"input": "5\n1 3 2 4 5",
"output": "Yes"
},
{
"input": "8\n1 2 3 5 7 8 8 5",
"output": "No"
},
{
"input": "10\n1 1 1 2 1 1 1 1 1 1",
"output": "No"
},
{
"input": "4\n1 0 0 1",
"output": "No"
},
{
"input": "7\n1 0 1 1 0 0 1",
"output": "Yes"
},
{
"input": "7\n1 4 5 7 6 6 3",
"output": "Yes"
},
{
"input": "4\n2 2 2 2",
"output": "No"
},
{
"input": "5\n2 3 4 5 6",
"output": "No"
},
{
"input": "4\n1 1 2 1",
"output": "No"
},
{
"input": "3\n1 2 3",
"output": "Yes"
},
{
"input": "6\n1 3 3 2 2 3",
"output": "No"
},
{
"input": "4\n1 1 2 3",
"output": "No"
},
{
"input": "4\n1 2 3 5",
"output": "No"
},
{
"input": "5\n3 4 4 3 3",
"output": "Yes"
},
{
"input": "4\n3 2 2 3",
"output": "No"
},
{
"input": "6\n1 1 1 1 2 1",
"output": "No"
},
{
"input": "6\n1 1 2 2 1 1",
"output": "No"
},
{
"input": "10\n3 4 2 4 3 2 2 4 4 3",
"output": "No"
},
{
"input": "7\n1 2 4 3 2 4 5",
"output": "Yes"
},
{
"input": "28\n75 51 25 52 13 7 34 29 5 59 68 56 13 2 9 37 59 83 18 32 36 30 20 43 92 76 78 67",
"output": "No"
},
{
"input": "79\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 18",
"output": "No"
},
{
"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": "No"
}
] | 1,504,273,620
| 720
|
Python 3
|
SKIPPED
|
PRETESTS
| 7
| 46
| 0
|
n=int(input())
ip=list(map(int,input().split()))
count=0
for i in ip:
if i%2==1:
count+=1
if n%2==1 and ip[0]%2==1 and ip[-1]%2==1:
print('Yes')
else:
if ip[0]%2==0 or ip[-1]%2==0:
print('No')
else:
b=0
#print("entered")
for i in range(1,n-2):
#print(i)
if ip[i]%2==1 and ip[i+1]%2==1 and (i+1)%2==1 and (n-i-1)%2==1:
b=1
print('Yes')
break
if b==0:
print('No')
|
Title: Odds and Ends
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Where do odds begin, and where do they end? Where does hope emerge, and will they ever break?
Given an integer sequence *a*1,<=*a*2,<=...,<=*a**n* of length *n*. Decide whether it is possible to divide it into an odd number of non-empty subsegments, the each of which has an odd length and begins and ends with odd numbers.
A subsegment is a contiguous slice of the whole sequence. For example, {3,<=4,<=5} and {1} are subsegments of sequence {1,<=2,<=3,<=4,<=5,<=6}, while {1,<=2,<=4} and {7} are not.
Input Specification:
The first line of input contains a non-negative integer *n* (1<=≤<=*n*<=≤<=100) — the length of the sequence.
The second line contains *n* space-separated non-negative integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=100) — the elements of the sequence.
Output Specification:
Output "Yes" if it's possible to fulfill the requirements, and "No" otherwise.
You can output each letter in any case (upper or lower).
Demo Input:
['3\n1 3 5\n', '5\n1 0 1 5 1\n', '3\n4 3 1\n', '4\n3 9 9 3\n']
Demo Output:
['Yes\n', 'Yes\n', 'No\n', 'No\n']
Note:
In the first example, divide the sequence into 1 subsegment: {1, 3, 5} and the requirements will be met.
In the second example, divide the sequence into 3 subsegments: {1, 0, 1}, {5}, {1}.
In the third example, one of the subsegments must start with 4 which is an even number, thus the requirements cannot be met.
In the fourth example, the sequence can be divided into 2 subsegments: {3, 9, 9}, {3}, but this is not a valid solution because 2 is an even number.
|
```python
n=int(input())
ip=list(map(int,input().split()))
count=0
for i in ip:
if i%2==1:
count+=1
if n%2==1 and ip[0]%2==1 and ip[-1]%2==1:
print('Yes')
else:
if ip[0]%2==0 or ip[-1]%2==0:
print('No')
else:
b=0
#print("entered")
for i in range(1,n-2):
#print(i)
if ip[i]%2==1 and ip[i+1]%2==1 and (i+1)%2==1 and (n-i-1)%2==1:
b=1
print('Yes')
break
if b==0:
print('No')
```
| -1
|
|
440
|
B
|
Balancer
|
PROGRAMMING
| 1,600
|
[
"greedy",
"implementation"
] | null | 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,598,198,757
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 1
| 93
| 6,656,000
|
n=int(input())
a=list(map(int,input().split()));cnt=0;b=sum(a)//n
for i in a :
cnt+=abs(b-i)
print(cnt)
|
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=list(map(int,input().split()));cnt=0;b=sum(a)//n
for i in a :
cnt+=abs(b-i)
print(cnt)
```
| 0
|
|
1,006
|
B
|
Polycarp's Practice
|
PROGRAMMING
| 1,200
|
[
"greedy",
"implementation",
"sortings"
] | null | null |
Polycarp is practicing his problem solving skill. He has a list of $n$ problems with difficulties $a_1, a_2, \dots, a_n$, respectively. His plan is to practice for exactly $k$ days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all $n$ problems in exactly $k$ days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in $k$ days he will solve all the $n$ problems.
The profit of the $j$-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the $j$-th day (i.e. if he solves problems with indices from $l$ to $r$ during a day, then the profit of the day is $\max\limits_{l \le i \le r}a_i$). The total profit of his practice is the sum of the profits over all $k$ days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all $n$ problems between $k$ days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if $n = 8, k = 3$ and $a = [5, 4, 2, 6, 5, 1, 9, 2]$, one of the possible distributions with maximum total profit is: $[5, 4, 2], [6, 5], [1, 9, 2]$. Here the total profit equals $5 + 6 + 9 = 20$.
|
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 2000$) — the number of problems and the number of days, respectively.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2000$) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
|
In the first line of the output print the maximum possible total profit.
In the second line print exactly $k$ positive integers $t_1, t_2, \dots, t_k$ ($t_1 + t_2 + \dots + t_k$ must equal $n$), where $t_j$ means the number of problems Polycarp will solve during the $j$-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
|
[
"8 3\n5 4 2 6 5 1 9 2\n",
"5 1\n1 1 1 1 1\n",
"4 2\n1 2000 2000 2\n"
] |
[
"20\n3 2 3",
"1\n5\n",
"4000\n2 2\n"
] |
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: $[1, 2000], [2000, 2]$. The total profit of this distribution is $2000 + 2000 = 4000$.
| 0
|
[
{
"input": "8 3\n5 4 2 6 5 1 9 2",
"output": "20\n4 1 3"
},
{
"input": "5 1\n1 1 1 1 1",
"output": "1\n5"
},
{
"input": "4 2\n1 2000 2000 2",
"output": "4000\n2 2"
},
{
"input": "1 1\n2000",
"output": "2000\n1"
},
{
"input": "1 1\n1234",
"output": "1234\n1"
},
{
"input": "3 2\n1 1 1",
"output": "2\n2 1"
},
{
"input": "4 2\n3 5 1 1",
"output": "8\n1 3"
},
{
"input": "5 3\n5 5 6 7 1",
"output": "18\n2 1 2"
},
{
"input": "6 4\n1 1 1 1 2 2",
"output": "6\n3 1 1 1"
},
{
"input": "5 3\n5 5 6 6 4",
"output": "17\n2 1 2"
},
{
"input": "16 15\n14 4 9 12 17 1 1 8 12 13 6 9 17 2 18 12",
"output": "154\n1 1 1 1 1 2 1 1 1 1 1 1 1 1 1"
},
{
"input": "1 1\n1996",
"output": "1996\n1"
},
{
"input": "5 3\n5 5 5 9 10",
"output": "24\n3 1 1"
},
{
"input": "18 15\n18 2 13 1 18 3 2 18 18 20 9 2 20 20 4 20 9 12",
"output": "204\n1 2 2 1 2 1 1 1 1 1 1 1 1 1 1"
},
{
"input": "5 3\n1 20 20 50 50",
"output": "120\n3 1 1"
},
{
"input": "8 3\n15 14 11 19 17 14 14 8",
"output": "51\n1 3 4"
},
{
"input": "5 2\n15 20 6 19 6",
"output": "39\n2 3"
},
{
"input": "6 3\n5 5 5 5 6 9",
"output": "20\n4 1 1"
},
{
"input": "5 3\n2 2 2 3 3",
"output": "8\n3 1 1"
},
{
"input": "7 3\n2 2 2 2 2 3 3",
"output": "8\n5 1 1"
},
{
"input": "6 5\n1 1 6 6 6 6",
"output": "25\n2 1 1 1 1"
},
{
"input": "8 4\n1 2 2 2 2 3 4 5",
"output": "14\n5 1 1 1"
},
{
"input": "6 4\n1 1 1 5 5 5",
"output": "16\n3 1 1 1"
},
{
"input": "6 3\n1 2 2 2 4 5",
"output": "11\n4 1 1"
},
{
"input": "18 6\n17 17 19 14 10 20 18 16 6 7 2 15 14 16 13 6 12 11",
"output": "107\n1 1 1 3 1 11"
},
{
"input": "6 3\n1 1 2 2 3 4",
"output": "9\n4 1 1"
},
{
"input": "8 3\n5 4 2 5 6 1 9 2",
"output": "20\n4 1 3"
}
] | 1,597,677,549
| 3,369
|
PyPy 3
|
OK
|
TESTS
| 37
| 140
| 2,457,600
|
n , k = map(int, input().split())
a = list(map(int, input().split()))
b = []
for i in range(n):
b.append((a[i], i))
b.sort(reverse = True)
temp = []; ans = 0
for i in range(k):
temp.append(abs(b[i][1]))
ans += b[i][0]
temp.sort()
if k > 1:
c = [temp[0] + 1]
for i in range(1, len(temp) - 1):
c.append(temp[i] - temp[i-1])
c.append(n - temp[-2]-1)
else:
c = [n]
print(ans)
print(*c)
|
Title: Polycarp's Practice
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp is practicing his problem solving skill. He has a list of $n$ problems with difficulties $a_1, a_2, \dots, a_n$, respectively. His plan is to practice for exactly $k$ days. Each day he has to solve at least one problem from his list. Polycarp solves the problems in the order they are given in his list, he cannot skip any problem from his list. He has to solve all $n$ problems in exactly $k$ days.
Thus, each day Polycarp solves a contiguous sequence of (consecutive) problems from the start of the list. He can't skip problems or solve them multiple times. As a result, in $k$ days he will solve all the $n$ problems.
The profit of the $j$-th day of Polycarp's practice is the maximum among all the difficulties of problems Polycarp solves during the $j$-th day (i.e. if he solves problems with indices from $l$ to $r$ during a day, then the profit of the day is $\max\limits_{l \le i \le r}a_i$). The total profit of his practice is the sum of the profits over all $k$ days of his practice.
You want to help Polycarp to get the maximum possible total profit over all valid ways to solve problems. Your task is to distribute all $n$ problems between $k$ days satisfying the conditions above in such a way, that the total profit is maximum.
For example, if $n = 8, k = 3$ and $a = [5, 4, 2, 6, 5, 1, 9, 2]$, one of the possible distributions with maximum total profit is: $[5, 4, 2], [6, 5], [1, 9, 2]$. Here the total profit equals $5 + 6 + 9 = 20$.
Input Specification:
The first line of the input contains two integers $n$ and $k$ ($1 \le k \le n \le 2000$) — the number of problems and the number of days, respectively.
The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 2000$) — difficulties of problems in Polycarp's list, in the order they are placed in the list (i.e. in the order Polycarp will solve them).
Output Specification:
In the first line of the output print the maximum possible total profit.
In the second line print exactly $k$ positive integers $t_1, t_2, \dots, t_k$ ($t_1 + t_2 + \dots + t_k$ must equal $n$), where $t_j$ means the number of problems Polycarp will solve during the $j$-th day in order to achieve the maximum possible total profit of his practice.
If there are many possible answers, you may print any of them.
Demo Input:
['8 3\n5 4 2 6 5 1 9 2\n', '5 1\n1 1 1 1 1\n', '4 2\n1 2000 2000 2\n']
Demo Output:
['20\n3 2 3', '1\n5\n', '4000\n2 2\n']
Note:
The first example is described in the problem statement.
In the second example there is only one possible distribution.
In the third example the best answer is to distribute problems in the following way: $[1, 2000], [2000, 2]$. The total profit of this distribution is $2000 + 2000 = 4000$.
|
```python
n , k = map(int, input().split())
a = list(map(int, input().split()))
b = []
for i in range(n):
b.append((a[i], i))
b.sort(reverse = True)
temp = []; ans = 0
for i in range(k):
temp.append(abs(b[i][1]))
ans += b[i][0]
temp.sort()
if k > 1:
c = [temp[0] + 1]
for i in range(1, len(temp) - 1):
c.append(temp[i] - temp[i-1])
c.append(n - temp[-2]-1)
else:
c = [n]
print(ans)
print(*c)
```
| 3
|
|
886
|
A
|
ACM ICPC
|
PROGRAMMING
| 1,000
|
[
"brute force"
] | null | null |
In a small but very proud high school it was decided to win ACM ICPC. This goal requires to compose as many teams of three as possible, but since there were only 6 students who wished to participate, the decision was to build exactly two teams.
After practice competition, participant number *i* got a score of *a**i*. Team score is defined as sum of scores of its participants. High school management is interested if it's possible to build two teams with equal scores. Your task is to answer that question.
|
The single line contains six integers *a*1,<=...,<=*a*6 (0<=≤<=*a**i*<=≤<=1000) — scores of the participants
|
Print "YES" (quotes for clarity), if it is possible to build teams with equal score, and "NO" otherwise.
You can print each character either upper- or lowercase ("YeS" and "yes" are valid when the answer is "YES").
|
[
"1 3 2 1 2 1\n",
"1 1 1 1 1 99\n"
] |
[
"YES\n",
"NO\n"
] |
In the first sample, first team can be composed of 1st, 2nd and 6th participant, second — of 3rd, 4th and 5th: team scores are 1 + 3 + 1 = 2 + 1 + 2 = 5.
In the second sample, score of participant number 6 is too high: his team score will be definitely greater.
| 500
|
[
{
"input": "1 3 2 1 2 1",
"output": "YES"
},
{
"input": "1 1 1 1 1 99",
"output": "NO"
},
{
"input": "1000 1000 1000 1000 1000 1000",
"output": "YES"
},
{
"input": "0 0 0 0 0 0",
"output": "YES"
},
{
"input": "633 609 369 704 573 416",
"output": "NO"
},
{
"input": "353 313 327 470 597 31",
"output": "NO"
},
{
"input": "835 638 673 624 232 266",
"output": "NO"
},
{
"input": "936 342 19 398 247 874",
"output": "NO"
},
{
"input": "417 666 978 553 271 488",
"output": "NO"
},
{
"input": "71 66 124 199 67 147",
"output": "YES"
},
{
"input": "54 26 0 171 239 12",
"output": "YES"
},
{
"input": "72 8 186 92 267 69",
"output": "YES"
},
{
"input": "180 179 188 50 75 214",
"output": "YES"
},
{
"input": "16 169 110 136 404 277",
"output": "YES"
},
{
"input": "101 400 9 200 300 10",
"output": "YES"
},
{
"input": "101 400 200 9 300 10",
"output": "YES"
},
{
"input": "101 200 400 9 300 10",
"output": "YES"
},
{
"input": "101 400 200 300 9 10",
"output": "YES"
},
{
"input": "101 200 400 300 9 10",
"output": "YES"
},
{
"input": "4 4 4 4 5 4",
"output": "NO"
},
{
"input": "2 2 2 2 2 1",
"output": "NO"
},
{
"input": "1000 1000 999 1000 1000 1000",
"output": "NO"
},
{
"input": "129 1 10 29 8 111",
"output": "NO"
},
{
"input": "1000 1000 1000 999 999 1000",
"output": "YES"
},
{
"input": "101 200 300 400 9 10",
"output": "YES"
},
{
"input": "101 400 200 300 10 9",
"output": "YES"
},
{
"input": "101 200 400 300 10 9",
"output": "YES"
},
{
"input": "101 200 300 400 10 9",
"output": "YES"
},
{
"input": "101 200 300 10 400 9",
"output": "YES"
},
{
"input": "1 1 1 1 1 5",
"output": "NO"
},
{
"input": "8 1 1 3 3 0",
"output": "NO"
},
{
"input": "1 1 2 2 3 3",
"output": "YES"
},
{
"input": "1 2 2 5 2 5",
"output": "NO"
},
{
"input": "1 2 3 6 6 6",
"output": "NO"
},
{
"input": "36 91 7 86 51 89",
"output": "NO"
},
{
"input": "10 1 1 1 23 24",
"output": "NO"
},
{
"input": "1 1 1 10 23 24",
"output": "NO"
},
{
"input": "20 10 1 2 3 44",
"output": "NO"
},
{
"input": "7 0 14 11 8 6",
"output": "NO"
},
{
"input": "100 496 1 1 1 1",
"output": "NO"
},
{
"input": "5 4 2 5 11 3",
"output": "NO"
},
{
"input": "1 3 7 8 8 9",
"output": "YES"
},
{
"input": "1 3 4 5 18 19",
"output": "YES"
},
{
"input": "5 5 1 2 2 15",
"output": "NO"
},
{
"input": "2 1 0 0 0 5",
"output": "NO"
},
{
"input": "1 6 6 1 20 2",
"output": "NO"
},
{
"input": "2 10 0 0 0 0",
"output": "NO"
},
{
"input": "1 1 3 1 1 11",
"output": "NO"
},
{
"input": "10 10 1 1 1 37",
"output": "NO"
},
{
"input": "1 1 0 0 0 4",
"output": "NO"
},
{
"input": "1 1 10 1 1 28",
"output": "NO"
},
{
"input": "1 5 5 5 6 8",
"output": "YES"
},
{
"input": "0 2 3 4 4 5",
"output": "YES"
}
] | 1,649,766,967
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 53
| 46
| 0
|
line = input().split()
arr = [0, 0, 0, 0, 0, 0]
for i in range(6):
arr[i] = int(line[i])
total = sum(arr)
def calculate(arr, total):
rest1 = arr.copy()
for firstIndex in range(6):
firstElem = rest1[firstIndex]
rest2 = rest1[firstIndex+1:]
for secondIndex in range(len(rest2)):
secondElem = rest2[secondIndex]
rest3 = rest2[secondIndex+1:]
for thirdElem in rest3:
if(firstElem + secondElem + thirdElem == total/2):
return(True)
return(False)
if (total%2 != 0):
print("NO")
else:
if calculate(arr, total):
print("YES")
else:
print("NO")
|
Title: ACM ICPC
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
In a small but very proud high school it was decided to win ACM ICPC. This goal requires to compose as many teams of three as possible, but since there were only 6 students who wished to participate, the decision was to build exactly two teams.
After practice competition, participant number *i* got a score of *a**i*. Team score is defined as sum of scores of its participants. High school management is interested if it's possible to build two teams with equal scores. Your task is to answer that question.
Input Specification:
The single line contains six integers *a*1,<=...,<=*a*6 (0<=≤<=*a**i*<=≤<=1000) — scores of the participants
Output Specification:
Print "YES" (quotes for clarity), if it is possible to build teams with equal score, and "NO" otherwise.
You can print each character either upper- or lowercase ("YeS" and "yes" are valid when the answer is "YES").
Demo Input:
['1 3 2 1 2 1\n', '1 1 1 1 1 99\n']
Demo Output:
['YES\n', 'NO\n']
Note:
In the first sample, first team can be composed of 1st, 2nd and 6th participant, second — of 3rd, 4th and 5th: team scores are 1 + 3 + 1 = 2 + 1 + 2 = 5.
In the second sample, score of participant number 6 is too high: his team score will be definitely greater.
|
```python
line = input().split()
arr = [0, 0, 0, 0, 0, 0]
for i in range(6):
arr[i] = int(line[i])
total = sum(arr)
def calculate(arr, total):
rest1 = arr.copy()
for firstIndex in range(6):
firstElem = rest1[firstIndex]
rest2 = rest1[firstIndex+1:]
for secondIndex in range(len(rest2)):
secondElem = rest2[secondIndex]
rest3 = rest2[secondIndex+1:]
for thirdElem in rest3:
if(firstElem + secondElem + thirdElem == total/2):
return(True)
return(False)
if (total%2 != 0):
print("NO")
else:
if calculate(arr, total):
print("YES")
else:
print("NO")
```
| 3
|
|
139
|
A
|
Petr and Book
|
PROGRAMMING
| 1,000
|
[
"implementation"
] | null | null |
One Sunday Petr went to a bookshop and bought a new book on sports programming. The book had exactly *n* pages.
Petr decided to start reading it starting from the next day, that is, from Monday. Petr's got a very tight schedule and for each day of the week he knows how many pages he will be able to read on that day. Some days are so busy that Petr will have no time to read whatsoever. However, we know that he will be able to read at least one page a week.
Assuming that Petr will not skip days and will read as much as he can every day, determine on which day of the week he will read the last page of the book.
|
The first input line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of pages in the book.
The second line contains seven non-negative space-separated integers that do not exceed 1000 — those integers represent how many pages Petr can read on Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday correspondingly. It is guaranteed that at least one of those numbers is larger than zero.
|
Print a single number — the number of the day of the week, when Petr will finish reading the book. The days of the week are numbered starting with one in the natural order: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday.
|
[
"100\n15 20 20 15 10 30 45\n",
"2\n1 0 0 0 0 0 0\n"
] |
[
"6\n",
"1\n"
] |
Note to the first sample:
By the end of Monday and therefore, by the beginning of Tuesday Petr has 85 pages left. He has 65 pages left by Wednesday, 45 by Thursday, 30 by Friday, 20 by Saturday and on Saturday Petr finishes reading the book (and he also has time to read 10 pages of something else).
Note to the second sample:
On Monday of the first week Petr will read the first page. On Monday of the second week Petr will read the second page and will finish reading the book.
| 500
|
[
{
"input": "100\n15 20 20 15 10 30 45",
"output": "6"
},
{
"input": "2\n1 0 0 0 0 0 0",
"output": "1"
},
{
"input": "100\n100 200 100 200 300 400 500",
"output": "1"
},
{
"input": "3\n1 1 1 1 1 1 1",
"output": "3"
},
{
"input": "1\n1 1 1 1 1 1 1",
"output": "1"
},
{
"input": "20\n5 3 7 2 1 6 4",
"output": "6"
},
{
"input": "10\n5 1 1 1 1 1 5",
"output": "6"
},
{
"input": "50\n10 1 10 1 10 1 10",
"output": "1"
},
{
"input": "77\n11 11 11 11 11 11 10",
"output": "1"
},
{
"input": "1\n1000 1000 1000 1000 1000 1000 1000",
"output": "1"
},
{
"input": "1000\n100 100 100 100 100 100 100",
"output": "3"
},
{
"input": "999\n10 20 10 20 30 20 10",
"output": "3"
},
{
"input": "433\n109 58 77 10 39 125 15",
"output": "7"
},
{
"input": "1\n0 0 0 0 0 0 1",
"output": "7"
},
{
"input": "5\n1 0 1 0 1 0 1",
"output": "1"
},
{
"input": "997\n1 1 0 0 1 0 1",
"output": "1"
},
{
"input": "1000\n1 1 1 1 1 1 1",
"output": "6"
},
{
"input": "1000\n1000 1000 1000 1000 1000 1000 1000",
"output": "1"
},
{
"input": "1000\n1 0 0 0 0 0 0",
"output": "1"
},
{
"input": "1000\n0 0 0 0 0 0 1",
"output": "7"
},
{
"input": "1000\n1 0 0 1 0 0 1",
"output": "1"
},
{
"input": "509\n105 23 98 0 7 0 155",
"output": "2"
},
{
"input": "7\n1 1 1 1 1 1 1",
"output": "7"
},
{
"input": "2\n1 1 0 0 0 0 0",
"output": "2"
},
{
"input": "1\n0 0 0 0 0 1 0",
"output": "6"
},
{
"input": "10\n0 0 0 0 0 0 1",
"output": "7"
},
{
"input": "5\n0 0 0 0 0 6 0",
"output": "6"
},
{
"input": "3\n0 1 0 0 0 0 0",
"output": "2"
},
{
"input": "10\n0 0 0 0 0 0 10",
"output": "7"
},
{
"input": "28\n1 2 3 4 5 6 7",
"output": "7"
},
{
"input": "100\n5 5 5 5 5 5 5",
"output": "6"
},
{
"input": "4\n1 0 0 0 0 0 1",
"output": "7"
},
{
"input": "2\n0 0 0 0 0 0 1",
"output": "7"
},
{
"input": "7\n0 0 0 0 0 0 7",
"output": "7"
},
{
"input": "7\n2 1 1 1 1 1 0",
"output": "6"
},
{
"input": "2\n0 0 1 1 0 0 0",
"output": "4"
},
{
"input": "6\n1 1 1 1 1 1 0",
"output": "6"
},
{
"input": "5\n1 1 1 0 0 1 1",
"output": "7"
},
{
"input": "100\n10 20 30 10 10 10 10",
"output": "7"
},
{
"input": "1\n0 0 0 1 0 0 0",
"output": "4"
},
{
"input": "70\n10 10 10 10 10 10 10",
"output": "7"
},
{
"input": "22\n1 2 3 4 5 6 10",
"output": "7"
},
{
"input": "5\n0 0 0 1 0 0 0",
"output": "4"
},
{
"input": "2\n0 0 0 1 0 0 0",
"output": "4"
},
{
"input": "6\n1 0 0 0 0 0 2",
"output": "7"
},
{
"input": "10\n1 2 2 1 2 1 1",
"output": "7"
},
{
"input": "5\n0 0 0 0 0 0 10",
"output": "7"
},
{
"input": "4\n0 1 1 0 0 0 0",
"output": "3"
},
{
"input": "100\n0 0 0 0 0 1 0",
"output": "6"
}
] | 1,690,899,300
| 2,147,483,647
|
Python 3
|
RUNTIME_ERROR
|
TESTS
| 0
| 62
| 0
|
total = int(input())
list = []
for i in range(total):
list.append(input().split())
count= 0
for item in list:
# print('first_loop', item)
tempRight = []
tempLift = []
tempUpper = []
tempLower = []
for i in list:
# print(i)
if item == i:
break
if i[0] > item[0] and i[1] == item[1]:
tempRight.append([i[0], i[1]])
if i[0] < item[0] and i[1] == item[1]:
tempLift.append([i[0], i[1]])
if i[0] == item[0] and i[1] > item[1]:
tempUpper.append([i[0], i[1]])
if i[0] == item[0] and i[1] < item[1]:
tempLower.append([i[0], i[1]])
if len(tempRight) >= 1 and len(tempLift) >= 1 and len(tempUpper) >= 1 and len(tempLower) >= 1:
count += 1
print(count)
|
Title: Petr and Book
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One Sunday Petr went to a bookshop and bought a new book on sports programming. The book had exactly *n* pages.
Petr decided to start reading it starting from the next day, that is, from Monday. Petr's got a very tight schedule and for each day of the week he knows how many pages he will be able to read on that day. Some days are so busy that Petr will have no time to read whatsoever. However, we know that he will be able to read at least one page a week.
Assuming that Petr will not skip days and will read as much as he can every day, determine on which day of the week he will read the last page of the book.
Input Specification:
The first input line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of pages in the book.
The second line contains seven non-negative space-separated integers that do not exceed 1000 — those integers represent how many pages Petr can read on Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday correspondingly. It is guaranteed that at least one of those numbers is larger than zero.
Output Specification:
Print a single number — the number of the day of the week, when Petr will finish reading the book. The days of the week are numbered starting with one in the natural order: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday.
Demo Input:
['100\n15 20 20 15 10 30 45\n', '2\n1 0 0 0 0 0 0\n']
Demo Output:
['6\n', '1\n']
Note:
Note to the first sample:
By the end of Monday and therefore, by the beginning of Tuesday Petr has 85 pages left. He has 65 pages left by Wednesday, 45 by Thursday, 30 by Friday, 20 by Saturday and on Saturday Petr finishes reading the book (and he also has time to read 10 pages of something else).
Note to the second sample:
On Monday of the first week Petr will read the first page. On Monday of the second week Petr will read the second page and will finish reading the book.
|
```python
total = int(input())
list = []
for i in range(total):
list.append(input().split())
count= 0
for item in list:
# print('first_loop', item)
tempRight = []
tempLift = []
tempUpper = []
tempLower = []
for i in list:
# print(i)
if item == i:
break
if i[0] > item[0] and i[1] == item[1]:
tempRight.append([i[0], i[1]])
if i[0] < item[0] and i[1] == item[1]:
tempLift.append([i[0], i[1]])
if i[0] == item[0] and i[1] > item[1]:
tempUpper.append([i[0], i[1]])
if i[0] == item[0] and i[1] < item[1]:
tempLower.append([i[0], i[1]])
if len(tempRight) >= 1 and len(tempLift) >= 1 and len(tempUpper) >= 1 and len(tempLower) >= 1:
count += 1
print(count)
```
| -1
|
|
688
|
B
|
Lovely Palindromes
|
PROGRAMMING
| 1,000
|
[
"constructive algorithms",
"math"
] | null | null |
Pari has a friend who loves palindrome numbers. A palindrome number is a number that reads the same forward or backward. For example 12321, 100001 and 1 are palindrome numbers, while 112 and 1021 are not.
Pari is trying to love them too, but only very special and gifted people can understand the beauty behind palindrome numbers. Pari loves integers with even length (i.e. the numbers with even number of digits), so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them.
Now Pari asks you to write a program that gets a huge integer *n* from the input and tells what is the *n*-th even-length positive palindrome number?
|
The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=10100<=000).
|
Print the *n*-th even-length palindrome number.
|
[
"1\n",
"10\n"
] |
[
"11\n",
"1001\n"
] |
The first 10 even-length palindrome numbers are 11, 22, 33, ... , 88, 99 and 1001.
| 1,000
|
[
{
"input": "1",
"output": "11"
},
{
"input": "10",
"output": "1001"
},
{
"input": "11",
"output": "1111"
},
{
"input": "12",
"output": "1221"
},
{
"input": "100",
"output": "100001"
},
{
"input": "1321",
"output": "13211231"
},
{
"input": "2",
"output": "22"
},
{
"input": "3",
"output": "33"
},
{
"input": "4",
"output": "44"
},
{
"input": "5",
"output": "55"
},
{
"input": "6",
"output": "66"
},
{
"input": "7",
"output": "77"
},
{
"input": "8",
"output": "88"
},
{
"input": "9",
"output": "99"
},
{
"input": "13",
"output": "1331"
},
{
"input": "14",
"output": "1441"
},
{
"input": "15",
"output": "1551"
},
{
"input": "16",
"output": "1661"
},
{
"input": "17",
"output": "1771"
},
{
"input": "18",
"output": "1881"
},
{
"input": "19",
"output": "1991"
},
{
"input": "20",
"output": "2002"
},
{
"input": "26550",
"output": "2655005562"
},
{
"input": "16137",
"output": "1613773161"
},
{
"input": "91471",
"output": "9147117419"
},
{
"input": "41242",
"output": "4124224214"
},
{
"input": "30866",
"output": "3086666803"
},
{
"input": "4442231232741003009964183199713851566466079882929007253443848371978048610682180431295671905105980116",
"output": "44422312327410030099641831997138515664660798829290072534438483719780486106821804312956719051059801166110895015091765921340812860168408791738483443527009292889706646651583179913814699003001472321322444"
},
{
"input": "7806526084732010742850470902979267046151204705563201965818390803445852115032119297648697933316807252",
"output": "78065260847320107428504709029792670461512047055632019658183908034458521150321192976486979333168072522527086133397968467929112305112585443080938185691023655074021516407629792090740582470102374806256087"
},
{
"input": "2244399823612183124978103773977739948197709395321563148611877999503840818596183803323258317041875913",
"output": "22443998236121831249781037739777399481977093953215631486118779995038408185961838033232583170418759133195781407138523233083816958180483059997781168413651235939077918499377793773018794213812163289934422"
},
{
"input": "123451",
"output": "123451154321"
}
] | 1,585,149,285
| 2,147,483,647
|
Python 3
|
TIME_LIMIT_EXCEEDED
|
TESTS
| 7
| 1,000
| 819,200
|
n=list(input());s=""
for i in range(len(n)) :
s=s+n[i]
for i in range(len(n)-1,-1,-1) :
s=s+n[i]
print(int(s))
|
Title: Lovely Palindromes
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Pari has a friend who loves palindrome numbers. A palindrome number is a number that reads the same forward or backward. For example 12321, 100001 and 1 are palindrome numbers, while 112 and 1021 are not.
Pari is trying to love them too, but only very special and gifted people can understand the beauty behind palindrome numbers. Pari loves integers with even length (i.e. the numbers with even number of digits), so she tries to see a lot of big palindrome numbers with even length (like a 2-digit 11 or 6-digit 122221), so maybe she could see something in them.
Now Pari asks you to write a program that gets a huge integer *n* from the input and tells what is the *n*-th even-length positive palindrome number?
Input Specification:
The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=10100<=000).
Output Specification:
Print the *n*-th even-length palindrome number.
Demo Input:
['1\n', '10\n']
Demo Output:
['11\n', '1001\n']
Note:
The first 10 even-length palindrome numbers are 11, 22, 33, ... , 88, 99 and 1001.
|
```python
n=list(input());s=""
for i in range(len(n)) :
s=s+n[i]
for i in range(len(n)-1,-1,-1) :
s=s+n[i]
print(int(s))
```
| 0
|
|
844
|
A
|
Diversity
|
PROGRAMMING
| 1,000
|
[
"greedy",
"implementation",
"strings"
] | null | null |
Calculate the minimum number of characters you need to change in the string *s*, so that it contains at least *k* different letters, or print that it is impossible.
String *s* consists only of lowercase Latin letters, and it is allowed to change characters only to lowercase Latin letters too.
|
First line of input contains string *s*, consisting only of lowercase Latin letters (1<=≤<=|*s*|<=≤<=1000, |*s*| denotes the length of *s*).
Second line of input contains integer *k* (1<=≤<=*k*<=≤<=26).
|
Print single line with a minimum number of necessary changes, or the word «impossible» (without quotes) if it is impossible.
|
[
"yandex\n6\n",
"yahoo\n5\n",
"google\n7\n"
] |
[
"0\n",
"1\n",
"impossible\n"
] |
In the first test case string contains 6 different letters, so we don't need to change anything.
In the second test case string contains 4 different letters: {'*a*', '*h*', '*o*', '*y*'}. To get 5 different letters it is necessary to change one occurrence of '*o*' to some letter, which doesn't occur in the string, for example, {'*b*'}.
In the third test case, it is impossible to make 7 different letters because the length of the string is 6.
| 500
|
[
{
"input": "yandex\n6",
"output": "0"
},
{
"input": "yahoo\n5",
"output": "1"
},
{
"input": "google\n7",
"output": "impossible"
},
{
"input": "a\n1",
"output": "0"
},
{
"input": "z\n2",
"output": "impossible"
},
{
"input": "fwgfrwgkuwghfiruhewgirueguhergiqrbvgrgf\n26",
"output": "14"
},
{
"input": "nfevghreuoghrueighoqghbnebvnejbvnbgneluqe\n26",
"output": "12"
},
{
"input": "a\n3",
"output": "impossible"
},
{
"input": "smaxpqplaqqbxuqxalqmbmmgubbpspxhawbxsuqhhegpmmpebqmqpbbeplwaepxmsahuepuhuhwxeqmmlgqubuaxehwuwasgxpqmugbmuawuhwqlswllssueglbxepbmwgs\n1",
"output": "0"
},
{
"input": "cuguccgcugcugucgggggcgcgucgucugcuuuccccuugccg\n4",
"output": "1"
},
{
"input": "fcfccfcfccfcfcffcffffffcfccfccfcffccccfcffffccfccfcffcfcccccffcfffcccffcfccfffffcccfccffffffccfccccf\n20",
"output": "18"
},
{
"input": "swmkwaruyv\n5",
"output": "0"
},
{
"input": "tnbqpsuhkczmejirvyfdolxwga\n22",
"output": "0"
},
{
"input": "abcde\n3",
"output": "0"
},
{
"input": "abb\n1",
"output": "0"
},
{
"input": "aaaa\n1",
"output": "0"
},
{
"input": "abcde\n2",
"output": "0"
},
{
"input": "yandex\n4",
"output": "0"
},
{
"input": "aaabbbccc\n1",
"output": "0"
},
{
"input": "abcd\n2",
"output": "0"
},
{
"input": "asdfgh\n2",
"output": "0"
},
{
"input": "aab\n1",
"output": "0"
},
{
"input": "mynameissako\n5",
"output": "0"
},
{
"input": "abcde\n1",
"output": "0"
},
{
"input": "abcd\n3",
"output": "0"
},
{
"input": "abcdef\n2",
"output": "0"
},
{
"input": "abcdefg\n4",
"output": "0"
},
{
"input": "abc\n1",
"output": "0"
},
{
"input": "asdafjsgljdllgjdgkl\n5",
"output": "0"
},
{
"input": "yaay\n3",
"output": "1"
},
{
"input": "yaay\n4",
"output": "2"
},
{
"input": "zzzzzz\n2",
"output": "1"
}
] | 1,505,460,884
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 41
| 62
| 0
|
a = input()
b = int(input())
print('impossible' if len(a) < b else max(0, b - len(set(c for c in a))))
|
Title: Diversity
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Calculate the minimum number of characters you need to change in the string *s*, so that it contains at least *k* different letters, or print that it is impossible.
String *s* consists only of lowercase Latin letters, and it is allowed to change characters only to lowercase Latin letters too.
Input Specification:
First line of input contains string *s*, consisting only of lowercase Latin letters (1<=≤<=|*s*|<=≤<=1000, |*s*| denotes the length of *s*).
Second line of input contains integer *k* (1<=≤<=*k*<=≤<=26).
Output Specification:
Print single line with a minimum number of necessary changes, or the word «impossible» (without quotes) if it is impossible.
Demo Input:
['yandex\n6\n', 'yahoo\n5\n', 'google\n7\n']
Demo Output:
['0\n', '1\n', 'impossible\n']
Note:
In the first test case string contains 6 different letters, so we don't need to change anything.
In the second test case string contains 4 different letters: {'*a*', '*h*', '*o*', '*y*'}. To get 5 different letters it is necessary to change one occurrence of '*o*' to some letter, which doesn't occur in the string, for example, {'*b*'}.
In the third test case, it is impossible to make 7 different letters because the length of the string is 6.
|
```python
a = input()
b = int(input())
print('impossible' if len(a) < b else max(0, b - len(set(c for c in a))))
```
| 3
|
|
513
|
B2
|
Permutations
|
PROGRAMMING
| 1,800
|
[
"bitmasks",
"divide and conquer",
"math"
] | null | null |
You are given a permutation *p* of numbers 1,<=2,<=...,<=*n*. Let's define *f*(*p*) as the following sum:
Find the lexicographically *m*-th permutation of length *n* in the set of permutations having the maximum possible value of *f*(*p*).
|
The single line of input contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*cnt**n*), where *cnt**n* is the number of permutations of length *n* with maximum possible value of *f*(*p*).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
- In subproblem B1 (3 points), the constraint 1<=≤<=*n*<=≤<=8 will hold. - In subproblem B2 (4 points), the constraint 1<=≤<=*n*<=≤<=50 will hold.
|
Output *n* number forming the required permutation.
|
[
"2 2\n",
"3 2\n"
] |
[
"2 1 \n",
"1 3 2 \n"
] |
In the first example, both permutations of numbers {1, 2} yield maximum possible *f*(*p*) which is equal to 4. Among them, (2, 1) comes second in lexicographical order.
| 4
|
[
{
"input": "2 2",
"output": "2 1 "
},
{
"input": "3 2",
"output": "1 3 2 "
},
{
"input": "1 1",
"output": "1 "
},
{
"input": "3 1",
"output": "1 2 3 "
},
{
"input": "3 3",
"output": "2 3 1 "
},
{
"input": "3 4",
"output": "3 2 1 "
},
{
"input": "4 1",
"output": "1 2 3 4 "
},
{
"input": "4 3",
"output": "1 3 4 2 "
},
{
"input": "4 4",
"output": "1 4 3 2 "
},
{
"input": "4 8",
"output": "4 3 2 1 "
},
{
"input": "5 2",
"output": "1 2 3 5 4 "
},
{
"input": "5 7",
"output": "1 4 5 3 2 "
},
{
"input": "5 15",
"output": "4 5 3 2 1 "
},
{
"input": "6 23",
"output": "2 5 6 4 3 1 "
},
{
"input": "7 7",
"output": "1 2 3 6 7 5 4 "
},
{
"input": "7 44",
"output": "2 4 7 6 5 3 1 "
},
{
"input": "8 1",
"output": "1 2 3 4 5 6 7 8 "
},
{
"input": "8 127",
"output": "7 8 6 5 4 3 2 1 "
},
{
"input": "8 128",
"output": "8 7 6 5 4 3 2 1 "
},
{
"input": "49 120715613380345",
"output": "1 4 7 11 12 14 16 17 19 20 22 25 27 28 29 30 31 33 34 35 40 46 47 48 49 45 44 43 42 41 39 38 37 36 32 26 24 23 21 18 15 13 10 9 8 6 5 3 2 "
},
{
"input": "42 345287088783",
"output": "1 2 4 6 7 8 9 10 13 14 16 17 19 22 25 28 31 33 35 36 37 41 42 40 39 38 34 32 30 29 27 26 24 23 21 20 18 15 12 11 5 3 "
},
{
"input": "42 916944885285",
"output": "1 4 6 8 10 17 18 19 21 24 25 27 28 30 33 34 35 37 38 40 41 42 39 36 32 31 29 26 23 22 20 16 15 14 13 12 11 9 7 5 3 2 "
},
{
"input": "42 1490750165435",
"output": "2 4 7 10 11 12 14 19 21 22 23 25 26 28 30 31 32 35 39 41 42 40 38 37 36 34 33 29 27 24 20 18 17 16 15 13 9 8 6 5 3 1 "
},
{
"input": "48 114212593995090",
"output": "3 4 11 12 13 14 15 16 17 20 21 22 24 25 26 29 30 31 32 33 34 35 38 40 42 44 45 46 48 47 43 41 39 37 36 28 27 23 19 18 10 9 8 7 6 5 2 1 "
},
{
"input": "42 850453132167",
"output": "1 4 5 6 9 10 11 12 13 14 15 17 22 24 25 30 31 35 36 37 38 41 42 40 39 34 33 32 29 28 27 26 23 21 20 19 18 16 8 7 3 2 "
},
{
"input": "42 1422110928669",
"output": "2 4 5 7 10 11 12 16 17 18 21 23 25 27 29 34 35 36 40 41 42 39 38 37 33 32 31 30 28 26 24 22 20 19 15 14 13 9 8 6 3 1 "
},
{
"input": "50 1",
"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 "
},
{
"input": "50 7",
"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 49 50 48 47 "
},
{
"input": "50 562949953421312",
"output": "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 "
},
{
"input": "50 562949953421311",
"output": "49 50 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 "
},
{
"input": "50 562949953421310",
"output": "48 50 49 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 "
},
{
"input": "50 500000000000007",
"output": "4 5 6 9 11 18 20 22 23 25 26 29 30 31 34 36 37 38 39 40 41 42 43 44 45 46 49 50 48 47 35 33 32 28 27 24 21 19 17 16 15 14 13 12 10 8 7 3 2 1 "
}
] | 1,423,331,379
| 2,979
|
Python 3
|
OK
|
TESTS2
| 32
| 46
| 0
|
n,m = map(int,input().split())
l = [0 for i in range(n)]
lr = [0,n-1]
for i in range(n,0,-1):
if m > 2**(i-2):
l[lr[1]] = str(n-i+1)
lr[1] -= 1
m -= 2**(i-2)
else:
l[lr[0]] = str(n-i+1)
lr[0] += 1
print(' '.join(l))
|
Title: Permutations
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
You are given a permutation *p* of numbers 1,<=2,<=...,<=*n*. Let's define *f*(*p*) as the following sum:
Find the lexicographically *m*-th permutation of length *n* in the set of permutations having the maximum possible value of *f*(*p*).
Input Specification:
The single line of input contains two integers *n* and *m* (1<=≤<=*m*<=≤<=*cnt**n*), where *cnt**n* is the number of permutations of length *n* with maximum possible value of *f*(*p*).
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
- In subproblem B1 (3 points), the constraint 1<=≤<=*n*<=≤<=8 will hold. - In subproblem B2 (4 points), the constraint 1<=≤<=*n*<=≤<=50 will hold.
Output Specification:
Output *n* number forming the required permutation.
Demo Input:
['2 2\n', '3 2\n']
Demo Output:
['2 1 \n', '1 3 2 \n']
Note:
In the first example, both permutations of numbers {1, 2} yield maximum possible *f*(*p*) which is equal to 4. Among them, (2, 1) comes second in lexicographical order.
|
```python
n,m = map(int,input().split())
l = [0 for i in range(n)]
lr = [0,n-1]
for i in range(n,0,-1):
if m > 2**(i-2):
l[lr[1]] = str(n-i+1)
lr[1] -= 1
m -= 2**(i-2)
else:
l[lr[0]] = str(n-i+1)
lr[0] += 1
print(' '.join(l))
```
| 3
|
|
131
|
A
|
cAPS lOCK
|
PROGRAMMING
| 1,000
|
[
"implementation",
"strings"
] | null | 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,698,868,542
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 2
| 30
| 0
|
s = input()
if (len(s) == 1 and s[0].lower() == s[0]):
print(s[0].upper())
else:
c = s[0]
cur = ''
for i in range(1, len(s)):
cur += s[i]
if (cur == cur.lower() and c == c.lower()):
ans = c + cur
print(ans)
else:
ans = c.upper() + cur.lower()
print(ans)
# Wed Nov 01 2023 22:55:41 GMT+0300 (Moscow Standard Time)
|
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
s = input()
if (len(s) == 1 and s[0].lower() == s[0]):
print(s[0].upper())
else:
c = s[0]
cur = ''
for i in range(1, len(s)):
cur += s[i]
if (cur == cur.lower() and c == c.lower()):
ans = c + cur
print(ans)
else:
ans = c.upper() + cur.lower()
print(ans)
# Wed Nov 01 2023 22:55:41 GMT+0300 (Moscow Standard Time)
```
| 0
|
|
432
|
A
|
Choosing Teams
|
PROGRAMMING
| 800
|
[
"greedy",
"implementation",
"sortings"
] | null | null |
The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. According to the ACM ICPC rules, each person can participate in the world championship at most 5 times.
The head of the SSU OPTC is recently gathering teams to participate in the world championship. Each team must consist of exactly three people, at that, any person cannot be a member of two or more teams. What maximum number of teams can the head make if he wants each team to participate in the world championship with the same members at least *k* times?
|
The first line contains two integers, *n* and *k* (1<=≤<=*n*<=≤<=2000; 1<=≤<=*k*<=≤<=5). The next line contains *n* integers: *y*1,<=*y*2,<=...,<=*y**n* (0<=≤<=*y**i*<=≤<=5), where *y**i* shows the number of times the *i*-th person participated in the ACM ICPC world championship.
|
Print a single number — the answer to the problem.
|
[
"5 2\n0 4 5 1 0\n",
"6 4\n0 1 2 3 4 5\n",
"6 5\n0 0 0 0 0 0\n"
] |
[
"1\n",
"0\n",
"2\n"
] |
In the first sample only one team could be made: the first, the fourth and the fifth participants.
In the second sample no teams could be created.
In the third sample two teams could be created. Any partition into two teams fits.
| 500
|
[
{
"input": "5 2\n0 4 5 1 0",
"output": "1"
},
{
"input": "6 4\n0 1 2 3 4 5",
"output": "0"
},
{
"input": "6 5\n0 0 0 0 0 0",
"output": "2"
},
{
"input": "3 4\n0 1 0",
"output": "1"
},
{
"input": "3 4\n0 2 0",
"output": "0"
},
{
"input": "6 5\n0 0 0 0 0 0",
"output": "2"
},
{
"input": "12 2\n0 1 2 3 4 0 1 2 3 4 0 1",
"output": "3"
},
{
"input": "15 2\n0 1 2 3 4 0 1 2 3 4 0 1 2 3 4",
"output": "4"
},
{
"input": "13 1\n5 0 5 0 1 5 0 4 1 1 1 4 1",
"output": "3"
},
{
"input": "20 1\n5 0 4 2 2 3 2 1 2 4 1 3 5 5 5 4 4 1 3 0",
"output": "5"
},
{
"input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4",
"output": "4"
},
{
"input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4",
"output": "4"
},
{
"input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4",
"output": "4"
},
{
"input": "20 2\n1 4 5 1 3 4 0 5 0 3 3 0 4 0 0 1 4 2 0 4",
"output": "4"
},
{
"input": "6 3\n4 4 4 4 4 4",
"output": "0"
},
{
"input": "1 4\n1",
"output": "0"
},
{
"input": "1 1\n0",
"output": "0"
},
{
"input": "2 3\n0 0",
"output": "0"
}
] | 1,685,340,150
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 35
| 46
| 0
|
i=lambda:map(int,input().split())
n,k=i()
a=i()
a=list(map(lambda x:x+k,a))
count=0
for i in range(len(a)):
if a[i]<=5:
count+=1
print(int(count/3))
|
Title: Choosing Teams
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
The Saratov State University Olympiad Programmers Training Center (SSU OPTC) has *n* students. For each student you know the number of times he/she has participated in the ACM ICPC world programming championship. According to the ACM ICPC rules, each person can participate in the world championship at most 5 times.
The head of the SSU OPTC is recently gathering teams to participate in the world championship. Each team must consist of exactly three people, at that, any person cannot be a member of two or more teams. What maximum number of teams can the head make if he wants each team to participate in the world championship with the same members at least *k* times?
Input Specification:
The first line contains two integers, *n* and *k* (1<=≤<=*n*<=≤<=2000; 1<=≤<=*k*<=≤<=5). The next line contains *n* integers: *y*1,<=*y*2,<=...,<=*y**n* (0<=≤<=*y**i*<=≤<=5), where *y**i* shows the number of times the *i*-th person participated in the ACM ICPC world championship.
Output Specification:
Print a single number — the answer to the problem.
Demo Input:
['5 2\n0 4 5 1 0\n', '6 4\n0 1 2 3 4 5\n', '6 5\n0 0 0 0 0 0\n']
Demo Output:
['1\n', '0\n', '2\n']
Note:
In the first sample only one team could be made: the first, the fourth and the fifth participants.
In the second sample no teams could be created.
In the third sample two teams could be created. Any partition into two teams fits.
|
```python
i=lambda:map(int,input().split())
n,k=i()
a=i()
a=list(map(lambda x:x+k,a))
count=0
for i in range(len(a)):
if a[i]<=5:
count+=1
print(int(count/3))
```
| 3
|
|
231
|
A
|
Team
|
PROGRAMMING
| 800
|
[
"brute force",
"greedy"
] | null | null |
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
This contest offers *n* problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
|
The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of problems in the contest. Then *n* lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
|
Print a single integer — the number of problems the friends will implement on the contest.
|
[
"3\n1 1 0\n1 1 1\n1 0 0\n",
"2\n1 0 0\n0 1 1\n"
] |
[
"2\n",
"1\n"
] |
In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
| 500
|
[
{
"input": "3\n1 1 0\n1 1 1\n1 0 0",
"output": "2"
},
{
"input": "2\n1 0 0\n0 1 1",
"output": "1"
},
{
"input": "1\n1 0 0",
"output": "0"
},
{
"input": "2\n1 0 0\n1 1 1",
"output": "1"
},
{
"input": "5\n1 0 0\n0 1 0\n1 1 1\n0 0 1\n0 0 0",
"output": "1"
},
{
"input": "10\n0 1 0\n0 1 0\n1 1 0\n1 0 0\n0 0 1\n0 1 1\n1 1 1\n1 1 0\n0 0 0\n0 0 0",
"output": "4"
},
{
"input": "15\n0 1 0\n1 0 0\n1 1 0\n1 1 1\n0 1 0\n0 0 1\n1 0 1\n1 0 1\n1 0 1\n0 0 0\n1 1 1\n1 1 0\n0 1 1\n1 1 0\n1 1 1",
"output": "10"
},
{
"input": "50\n0 0 0\n0 1 1\n1 1 1\n0 1 0\n1 0 1\n1 1 1\n0 0 1\n1 0 0\n1 1 0\n1 0 1\n0 1 0\n0 0 1\n1 1 0\n0 1 0\n1 1 0\n0 0 0\n1 1 1\n1 0 1\n0 0 1\n1 1 0\n1 1 1\n0 1 1\n1 1 0\n0 0 0\n0 0 0\n1 1 1\n0 0 0\n1 1 1\n0 1 1\n0 0 1\n0 0 0\n0 0 0\n1 1 0\n1 1 0\n1 0 1\n1 0 0\n1 0 1\n1 0 1\n0 1 1\n1 1 0\n1 1 0\n0 1 0\n1 0 1\n0 0 0\n0 0 0\n0 0 0\n0 0 1\n1 1 1\n0 1 1\n1 0 1",
"output": "29"
},
{
"input": "1\n1 1 1",
"output": "1"
},
{
"input": "8\n0 0 0\n0 0 1\n0 0 0\n0 1 1\n1 0 0\n1 0 1\n1 1 0\n1 1 1",
"output": "4"
},
{
"input": "16\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1",
"output": "16"
}
] | 1,698,840,317
| 2,147,483,647
|
Python 3
|
OK
|
TESTS
| 21
| 92
| 0
|
n=int(input())
a=[]
c=0
for i in range(n):
a.append(input())
for i in range(n):
if a[i].count('1')>=2:
c+=1
print(c)
|
Title: Team
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day three best friends Petya, Vasya and Tonya decided to form a team and take part in programming contests. Participants are usually offered several problems during programming contests. Long before the start the friends decided that they will implement a problem if at least two of them are sure about the solution. Otherwise, the friends won't write the problem's solution.
This contest offers *n* problems to the participants. For each problem we know, which friend is sure about the solution. Help the friends find the number of problems for which they will write a solution.
Input Specification:
The first input line contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of problems in the contest. Then *n* lines contain three integers each, each integer is either 0 or 1. If the first number in the line equals 1, then Petya is sure about the problem's solution, otherwise he isn't sure. The second number shows Vasya's view on the solution, the third number shows Tonya's view. The numbers on the lines are separated by spaces.
Output Specification:
Print a single integer — the number of problems the friends will implement on the contest.
Demo Input:
['3\n1 1 0\n1 1 1\n1 0 0\n', '2\n1 0 0\n0 1 1\n']
Demo Output:
['2\n', '1\n']
Note:
In the first sample Petya and Vasya are sure that they know how to solve the first problem and all three of them know how to solve the second problem. That means that they will write solutions for these problems. Only Petya is sure about the solution for the third problem, but that isn't enough, so the friends won't take it.
In the second sample the friends will only implement the second problem, as Vasya and Tonya are sure about the solution.
|
```python
n=int(input())
a=[]
c=0
for i in range(n):
a.append(input())
for i in range(n):
if a[i].count('1')>=2:
c+=1
print(c)
```
| 3
|
|
208
|
A
|
Dubstep
|
PROGRAMMING
| 900
|
[
"strings"
] | null | null |
Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consists of some number of words. To make the dubstep remix of this song, Vasya inserts a certain number of words "WUB" before the first word of the song (the number may be zero), after the last word (the number may be zero), and between words (at least one between any pair of neighbouring words), and then the boy glues together all the words, including "WUB", in one string and plays the song at the club.
For example, a song with words "I AM X" can transform into a dubstep remix as "WUBWUBIWUBAMWUBWUBX" and cannot transform into "WUBWUBIAMWUBX".
Recently, Petya has heard Vasya's new dubstep track, but since he isn't into modern music, he decided to find out what was the initial song that Vasya remixed. Help Petya restore the original song.
|
The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters. It is guaranteed that before Vasya remixed the song, no word contained substring "WUB" in it; Vasya didn't change the word order. It is also guaranteed that initially the song had at least one word.
|
Print the words of the initial song that Vasya used to make a dubsteb remix. Separate the words with a space.
|
[
"WUBWUBABCWUB\n",
"WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB\n"
] |
[
"ABC ",
"WE ARE THE CHAMPIONS MY FRIEND "
] |
In the first sample: "WUBWUBABCWUB" = "WUB" + "WUB" + "ABC" + "WUB". That means that the song originally consisted of a single word "ABC", and all words "WUB" were added by Vasya.
In the second sample Vasya added a single word "WUB" between all neighbouring words, in the beginning and in the end, except for words "ARE" and "THE" — between them Vasya added two "WUB".
| 500
|
[
{
"input": "WUBWUBABCWUB",
"output": "ABC "
},
{
"input": "WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB",
"output": "WE ARE THE CHAMPIONS MY FRIEND "
},
{
"input": "WUBWUBWUBSR",
"output": "SR "
},
{
"input": "RWUBWUBWUBLWUB",
"output": "R L "
},
{
"input": "ZJWUBWUBWUBJWUBWUBWUBL",
"output": "ZJ J L "
},
{
"input": "CWUBBWUBWUBWUBEWUBWUBWUBQWUBWUBWUB",
"output": "C B E Q "
},
{
"input": "WUBJKDWUBWUBWBIRAQKFWUBWUBYEWUBWUBWUBWVWUBWUB",
"output": "JKD WBIRAQKF YE WV "
},
{
"input": "WUBKSDHEMIXUJWUBWUBRWUBWUBWUBSWUBWUBWUBHWUBWUBWUB",
"output": "KSDHEMIXUJ R S H "
},
{
"input": "OGWUBWUBWUBXWUBWUBWUBIWUBWUBWUBKOWUBWUB",
"output": "OG X I KO "
},
{
"input": "QWUBQQWUBWUBWUBIWUBWUBWWWUBWUBWUBJOPJPBRH",
"output": "Q QQ I WW JOPJPBRH "
},
{
"input": "VSRNVEATZTLGQRFEGBFPWUBWUBWUBAJWUBWUBWUBPQCHNWUBCWUB",
"output": "VSRNVEATZTLGQRFEGBFP AJ PQCHN C "
},
{
"input": "WUBWUBEWUBWUBWUBIQMJNIQWUBWUBWUBGZZBQZAUHYPWUBWUBWUBPMRWUBWUBWUBDCV",
"output": "E IQMJNIQ GZZBQZAUHYP PMR DCV "
},
{
"input": "WUBWUBWUBFVWUBWUBWUBBPSWUBWUBWUBRXNETCJWUBWUBWUBJDMBHWUBWUBWUBBWUBWUBVWUBWUBB",
"output": "FV BPS RXNETCJ JDMBH B V B "
},
{
"input": "WUBWUBWUBFBQWUBWUBWUBIDFSYWUBWUBWUBCTWDMWUBWUBWUBSXOWUBWUBWUBQIWUBWUBWUBL",
"output": "FBQ IDFSY CTWDM SXO QI L "
},
{
"input": "IWUBWUBQLHDWUBYIIKZDFQWUBWUBWUBCXWUBWUBUWUBWUBWUBKWUBWUBWUBNL",
"output": "I QLHD YIIKZDFQ CX U K NL "
},
{
"input": "KWUBUPDYXGOKUWUBWUBWUBAGOAHWUBIZDWUBWUBWUBIYWUBWUBWUBVWUBWUBWUBPWUBWUBWUBE",
"output": "K UPDYXGOKU AGOAH IZD IY V P E "
},
{
"input": "WUBWUBOWUBWUBWUBIPVCQAFWYWUBWUBWUBQWUBWUBWUBXHDKCPYKCTWWYWUBWUBWUBVWUBWUBWUBFZWUBWUB",
"output": "O IPVCQAFWY Q XHDKCPYKCTWWY V FZ "
},
{
"input": "PAMJGYWUBWUBWUBXGPQMWUBWUBWUBTKGSXUYWUBWUBWUBEWUBWUBWUBNWUBWUBWUBHWUBWUBWUBEWUBWUB",
"output": "PAMJGY XGPQM TKGSXUY E N H E "
},
{
"input": "WUBYYRTSMNWUWUBWUBWUBCWUBWUBWUBCWUBWUBWUBFSYUINDWOBVWUBWUBWUBFWUBWUBWUBAUWUBWUBWUBVWUBWUBWUBJB",
"output": "YYRTSMNWU C C FSYUINDWOBV F AU V JB "
},
{
"input": "WUBWUBYGPYEYBNRTFKOQCWUBWUBWUBUYGRTQEGWLFYWUBWUBWUBFVWUBHPWUBWUBWUBXZQWUBWUBWUBZDWUBWUBWUBM",
"output": "YGPYEYBNRTFKOQC UYGRTQEGWLFY FV HP XZQ ZD M "
},
{
"input": "WUBZVMJWUBWUBWUBFOIMJQWKNZUBOFOFYCCWUBWUBWUBAUWWUBRDRADWUBWUBWUBCHQVWUBWUBWUBKFTWUBWUBWUBW",
"output": "ZVMJ FOIMJQWKNZUBOFOFYCC AUW RDRAD CHQV KFT W "
},
{
"input": "WUBWUBZBKOKHQLGKRVIMZQMQNRWUBWUBWUBDACWUBWUBNZHFJMPEYKRVSWUBWUBWUBPPHGAVVPRZWUBWUBWUBQWUBWUBAWUBG",
"output": "ZBKOKHQLGKRVIMZQMQNR DAC NZHFJMPEYKRVS PPHGAVVPRZ Q A G "
},
{
"input": "WUBWUBJWUBWUBWUBNFLWUBWUBWUBGECAWUBYFKBYJWTGBYHVSSNTINKWSINWSMAWUBWUBWUBFWUBWUBWUBOVWUBWUBLPWUBWUBWUBN",
"output": "J NFL GECA YFKBYJWTGBYHVSSNTINKWSINWSMA F OV LP N "
},
{
"input": "WUBWUBLCWUBWUBWUBZGEQUEATJVIXETVTWUBWUBWUBEXMGWUBWUBWUBRSWUBWUBWUBVWUBWUBWUBTAWUBWUBWUBCWUBWUBWUBQG",
"output": "LC ZGEQUEATJVIXETVT EXMG RS V TA C QG "
},
{
"input": "WUBMPWUBWUBWUBORWUBWUBDLGKWUBWUBWUBVVZQCAAKVJTIKWUBWUBWUBTJLUBZJCILQDIFVZWUBWUBYXWUBWUBWUBQWUBWUBWUBLWUB",
"output": "MP OR DLGK VVZQCAAKVJTIK TJLUBZJCILQDIFVZ YX Q L "
},
{
"input": "WUBNXOLIBKEGXNWUBWUBWUBUWUBGITCNMDQFUAOVLWUBWUBWUBAIJDJZJHFMPVTPOXHPWUBWUBWUBISCIOWUBWUBWUBGWUBWUBWUBUWUB",
"output": "NXOLIBKEGXN U GITCNMDQFUAOVL AIJDJZJHFMPVTPOXHP ISCIO G U "
},
{
"input": "WUBWUBNMMWCZOLYPNBELIYVDNHJUNINWUBWUBWUBDXLHYOWUBWUBWUBOJXUWUBWUBWUBRFHTGJCEFHCGWARGWUBWUBWUBJKWUBWUBSJWUBWUB",
"output": "NMMWCZOLYPNBELIYVDNHJUNIN DXLHYO OJXU RFHTGJCEFHCGWARG JK SJ "
},
{
"input": "SGWLYSAUJOJBNOXNWUBWUBWUBBOSSFWKXPDPDCQEWUBWUBWUBDIRZINODWUBWUBWUBWWUBWUBWUBPPHWUBWUBWUBRWUBWUBWUBQWUBWUBWUBJWUB",
"output": "SGWLYSAUJOJBNOXN BOSSFWKXPDPDCQE DIRZINOD W PPH R Q J "
},
{
"input": "TOWUBWUBWUBGBTBNWUBWUBWUBJVIOJBIZFUUYHUAIEBQLQXPQKZJMPTCWBKPOSAWUBWUBWUBSWUBWUBWUBTOLVXWUBWUBWUBNHWUBWUBWUBO",
"output": "TO GBTBN JVIOJBIZFUUYHUAIEBQLQXPQKZJMPTCWBKPOSA S TOLVX NH O "
},
{
"input": "WUBWUBWSPLAYSZSAUDSWUBWUBWUBUWUBWUBWUBKRWUBWUBWUBRSOKQMZFIYZQUWUBWUBWUBELSHUWUBWUBWUBUKHWUBWUBWUBQXEUHQWUBWUBWUBBWUBWUBWUBR",
"output": "WSPLAYSZSAUDS U KR RSOKQMZFIYZQU ELSHU UKH QXEUHQ B R "
},
{
"input": "WUBXEMWWVUHLSUUGRWUBWUBWUBAWUBXEGILZUNKWUBWUBWUBJDHHKSWUBWUBWUBDTSUYSJHWUBWUBWUBPXFWUBMOHNJWUBWUBWUBZFXVMDWUBWUBWUBZMWUBWUB",
"output": "XEMWWVUHLSUUGR A XEGILZUNK JDHHKS DTSUYSJH PXF MOHNJ ZFXVMD ZM "
},
{
"input": "BMBWUBWUBWUBOQKWUBWUBWUBPITCIHXHCKLRQRUGXJWUBWUBWUBVWUBWUBWUBJCWUBWUBWUBQJPWUBWUBWUBBWUBWUBWUBBMYGIZOOXWUBWUBWUBTAGWUBWUBHWUB",
"output": "BMB OQK PITCIHXHCKLRQRUGXJ V JC QJP B BMYGIZOOX TAG H "
},
{
"input": "CBZNWUBWUBWUBNHWUBWUBWUBYQSYWUBWUBWUBMWUBWUBWUBXRHBTMWUBWUBWUBPCRCWUBWUBWUBTZUYLYOWUBWUBWUBCYGCWUBWUBWUBCLJWUBWUBWUBSWUBWUBWUB",
"output": "CBZN NH YQSY M XRHBTM PCRC TZUYLYO CYGC CLJ S "
},
{
"input": "DPDWUBWUBWUBEUQKWPUHLTLNXHAEKGWUBRRFYCAYZFJDCJLXBAWUBWUBWUBHJWUBOJWUBWUBWUBNHBJEYFWUBWUBWUBRWUBWUBWUBSWUBWWUBWUBWUBXDWUBWUBWUBJWUB",
"output": "DPD EUQKWPUHLTLNXHAEKG RRFYCAYZFJDCJLXBA HJ OJ NHBJEYF R S W XD J "
},
{
"input": "WUBWUBWUBISERPQITVIYERSCNWUBWUBWUBQWUBWUBWUBDGSDIPWUBWUBWUBCAHKDZWEXBIBJVVSKKVQJWUBWUBWUBKIWUBWUBWUBCWUBWUBWUBAWUBWUBWUBPWUBWUBWUBHWUBWUBWUBF",
"output": "ISERPQITVIYERSCN Q DGSDIP CAHKDZWEXBIBJVVSKKVQJ KI C A P H F "
},
{
"input": "WUBWUBWUBIWUBWUBLIKNQVWUBWUBWUBPWUBWUBWUBHWUBWUBWUBMWUBWUBWUBDPRSWUBWUBWUBBSAGYLQEENWXXVWUBWUBWUBXMHOWUBWUBWUBUWUBWUBWUBYRYWUBWUBWUBCWUBWUBWUBY",
"output": "I LIKNQV P H M DPRS BSAGYLQEENWXXV XMHO U YRY C Y "
},
{
"input": "WUBWUBWUBMWUBWUBWUBQWUBWUBWUBITCFEYEWUBWUBWUBHEUWGNDFNZGWKLJWUBWUBWUBMZPWUBWUBWUBUWUBWUBWUBBWUBWUBWUBDTJWUBHZVIWUBWUBWUBPWUBFNHHWUBWUBWUBVTOWUB",
"output": "M Q ITCFEYE HEUWGNDFNZGWKLJ MZP U B DTJ HZVI P FNHH VTO "
},
{
"input": "WUBWUBNDNRFHYJAAUULLHRRDEDHYFSRXJWUBWUBWUBMUJVDTIRSGYZAVWKRGIFWUBWUBWUBHMZWUBWUBWUBVAIWUBWUBWUBDDKJXPZRGWUBWUBWUBSGXWUBWUBWUBIFKWUBWUBWUBUWUBWUBWUBW",
"output": "NDNRFHYJAAUULLHRRDEDHYFSRXJ MUJVDTIRSGYZAVWKRGIF HMZ VAI DDKJXPZRG SGX IFK U W "
},
{
"input": "WUBOJMWRSLAXXHQRTPMJNCMPGWUBWUBWUBNYGMZIXNLAKSQYWDWUBWUBWUBXNIWUBWUBWUBFWUBWUBWUBXMBWUBWUBWUBIWUBWUBWUBINWUBWUBWUBWDWUBWUBWUBDDWUBWUBWUBD",
"output": "OJMWRSLAXXHQRTPMJNCMPG NYGMZIXNLAKSQYWD XNI F XMB I IN WD DD D "
},
{
"input": "WUBWUBWUBREHMWUBWUBWUBXWUBWUBWUBQASNWUBWUBWUBNLSMHLCMTICWUBWUBWUBVAWUBWUBWUBHNWUBWUBWUBNWUBWUBWUBUEXLSFOEULBWUBWUBWUBXWUBWUBWUBJWUBWUBWUBQWUBWUBWUBAWUBWUB",
"output": "REHM X QASN NLSMHLCMTIC VA HN N UEXLSFOEULB X J Q A "
},
{
"input": "WUBWUBWUBSTEZTZEFFIWUBWUBWUBSWUBWUBWUBCWUBFWUBHRJPVWUBWUBWUBDYJUWUBWUBWUBPWYDKCWUBWUBWUBCWUBWUBWUBUUEOGCVHHBWUBWUBWUBEXLWUBWUBWUBVCYWUBWUBWUBMWUBWUBWUBYWUB",
"output": "STEZTZEFFI S C F HRJPV DYJU PWYDKC C UUEOGCVHHB EXL VCY M Y "
},
{
"input": "WPPNMSQOQIWUBWUBWUBPNQXWUBWUBWUBHWUBWUBWUBNFLWUBWUBWUBGWSGAHVJFNUWUBWUBWUBFWUBWUBWUBWCMLRICFSCQQQTNBWUBWUBWUBSWUBWUBWUBKGWUBWUBWUBCWUBWUBWUBBMWUBWUBWUBRWUBWUB",
"output": "WPPNMSQOQI PNQX H NFL GWSGAHVJFNU F WCMLRICFSCQQQTNB S KG C BM R "
},
{
"input": "YZJOOYITZRARKVFYWUBWUBRZQGWUBWUBWUBUOQWUBWUBWUBIWUBWUBWUBNKVDTBOLETKZISTWUBWUBWUBWLWUBQQFMMGSONZMAWUBZWUBWUBWUBQZUXGCWUBWUBWUBIRZWUBWUBWUBLTTVTLCWUBWUBWUBY",
"output": "YZJOOYITZRARKVFY RZQG UOQ I NKVDTBOLETKZIST WL QQFMMGSONZMA Z QZUXGC IRZ LTTVTLC Y "
},
{
"input": "WUBCAXNCKFBVZLGCBWCOAWVWOFKZVQYLVTWUBWUBWUBNLGWUBWUBWUBAMGDZBDHZMRMQMDLIRMIWUBWUBWUBGAJSHTBSWUBWUBWUBCXWUBWUBWUBYWUBZLXAWWUBWUBWUBOHWUBWUBWUBZWUBWUBWUBGBWUBWUBWUBE",
"output": "CAXNCKFBVZLGCBWCOAWVWOFKZVQYLVT NLG AMGDZBDHZMRMQMDLIRMI GAJSHTBS CX Y ZLXAW OH Z GB E "
},
{
"input": "WUBWUBCHXSOWTSQWUBWUBWUBCYUZBPBWUBWUBWUBSGWUBWUBWKWORLRRLQYUUFDNWUBWUBWUBYYGOJNEVEMWUBWUBWUBRWUBWUBWUBQWUBWUBWUBIHCKWUBWUBWUBKTWUBWUBWUBRGSNTGGWUBWUBWUBXCXWUBWUBWUBS",
"output": "CHXSOWTSQ CYUZBPB SG WKWORLRRLQYUUFDN YYGOJNEVEM R Q IHCK KT RGSNTGG XCX S "
},
{
"input": "WUBWUBWUBHJHMSBURXTHXWSCHNAIJOWBHLZGJZDHEDSPWBWACCGQWUBWUBWUBXTZKGIITWUBWUBWUBAWUBWUBWUBVNCXPUBCQWUBWUBWUBIDPNAWUBWUBWUBOWUBWUBWUBYGFWUBWUBWUBMQOWUBWUBWUBKWUBWUBWUBAZVWUBWUBWUBEP",
"output": "HJHMSBURXTHXWSCHNAIJOWBHLZGJZDHEDSPWBWACCGQ XTZKGIIT A VNCXPUBCQ IDPNA O YGF MQO K AZV EP "
},
{
"input": "WUBKYDZOYWZSNGMKJSWAXFDFLTHDHEOGTDBNZMSMKZTVWUBWUBWUBLRMIIWUBWUBWUBGWUBWUBWUBADPSWUBWUBWUBANBWUBWUBPCWUBWUBWUBPWUBWUBWUBGPVNLSWIRFORYGAABUXMWUBWUBWUBOWUBWUBWUBNWUBWUBWUBYWUBWUB",
"output": "KYDZOYWZSNGMKJSWAXFDFLTHDHEOGTDBNZMSMKZTV LRMII G ADPS ANB PC P GPVNLSWIRFORYGAABUXM O N Y "
},
{
"input": "REWUBWUBWUBJDWUBWUBWUBNWUBWUBWUBTWWUBWUBWUBWZDOCKKWUBWUBWUBLDPOVBFRCFWUBWUBAKZIBQKEUAZEEWUBWUBWUBLQYPNPFWUBYEWUBWUBWUBFWUBWUBWUBBPWUBWUBWUBAWWUBWUBWUBQWUBWUBWUBBRWUBWUBWUBXJL",
"output": "RE JD N TW WZDOCKK LDPOVBFRCF AKZIBQKEUAZEE LQYPNPF YE F BP AW Q BR XJL "
},
{
"input": "CUFGJDXGMWUBWUBWUBOMWUBWUBWUBSIEWUBWUBWUBJJWKNOWUBWUBWUBYBHVNRNORGYWUBWUBWUBOAGCAWUBWUBWUBSBLBKTPFKPBIWUBWUBWUBJBWUBWUBWUBRMFCJPGWUBWUBWUBDWUBWUBWUBOJOWUBWUBWUBZPWUBWUBWUBMWUBRWUBWUBWUBFXWWUBWUBWUBO",
"output": "CUFGJDXGM OM SIE JJWKNO YBHVNRNORGY OAGCA SBLBKTPFKPBI JB RMFCJPG D OJO ZP M R FXW O "
},
{
"input": "WUBJZGAEXFMFEWMAKGQLUWUBWUBWUBICYTPQWGENELVYWANKUOJYWUBWUBWUBGWUBWUBWUBHYCJVLPHTUPNEGKCDGQWUBWUBWUBOFWUBWUBWUBCPGSOGZBRPRPVJJEWUBWUBWUBDQBCWUBWUBWUBHWUBWUBWUBMHOHYBMATWUBWUBWUBVWUBWUBWUBSWUBWUBWUBKOWU",
"output": "JZGAEXFMFEWMAKGQLU ICYTPQWGENELVYWANKUOJY G HYCJVLPHTUPNEGKCDGQ OF CPGSOGZBRPRPVJJE DQBC H MHOHYBMAT V S KOWU "
},
{
"input": "A",
"output": "A "
},
{
"input": "WUBA",
"output": "A "
},
{
"input": "WUBWUBA",
"output": "A "
},
{
"input": "AWUBWUBWUB",
"output": "A "
},
{
"input": "AWUBBWUBCWUBD",
"output": "A B C D "
},
{
"input": "WUBWWUBWUBWUBUWUBWUBBWUB",
"output": "W U B "
},
{
"input": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
"output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
},
{
"input": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
"output": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
},
{
"input": "WUWUBBWWUBUB",
"output": "WU BW UB "
},
{
"input": "WUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUABWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUB",
"output": "WUAB "
},
{
"input": "ZWUB",
"output": "Z "
},
{
"input": "WU",
"output": "WU "
},
{
"input": "UB",
"output": "UB "
},
{
"input": "U",
"output": "U "
},
{
"input": "WUBW",
"output": "W "
},
{
"input": "WUBWU",
"output": "WU "
},
{
"input": "WUWUB",
"output": "WU "
},
{
"input": "UBWUB",
"output": "UB "
},
{
"input": "WUWUBUBWUBUWUB",
"output": "WU UB U "
},
{
"input": "WUBWWUBAWUB",
"output": "W A "
},
{
"input": "WUUUUU",
"output": "WUUUUU "
}
] | 1,697,485,613
| 2,147,483,647
|
PyPy 3-64
|
WRONG_ANSWER
|
TESTS
| 1
| 92
| 0
|
s = input()
res = ""
i = 0
while i < len(s):
if i < len(s) - 2 and s[i] == "W" and s[i + 1] == "U" and s[i + 2] == "B":
i += 3
else:
res += s[i]
i += 1
print(res)
|
Title: Dubstep
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Vasya works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.
Let's assume that a song consists of some number of words. To make the dubstep remix of this song, Vasya inserts a certain number of words "WUB" before the first word of the song (the number may be zero), after the last word (the number may be zero), and between words (at least one between any pair of neighbouring words), and then the boy glues together all the words, including "WUB", in one string and plays the song at the club.
For example, a song with words "I AM X" can transform into a dubstep remix as "WUBWUBIWUBAMWUBWUBX" and cannot transform into "WUBWUBIAMWUBX".
Recently, Petya has heard Vasya's new dubstep track, but since he isn't into modern music, he decided to find out what was the initial song that Vasya remixed. Help Petya restore the original song.
Input Specification:
The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters. It is guaranteed that before Vasya remixed the song, no word contained substring "WUB" in it; Vasya didn't change the word order. It is also guaranteed that initially the song had at least one word.
Output Specification:
Print the words of the initial song that Vasya used to make a dubsteb remix. Separate the words with a space.
Demo Input:
['WUBWUBABCWUB\n', 'WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB\n']
Demo Output:
['ABC ', 'WE ARE THE CHAMPIONS MY FRIEND ']
Note:
In the first sample: "WUBWUBABCWUB" = "WUB" + "WUB" + "ABC" + "WUB". That means that the song originally consisted of a single word "ABC", and all words "WUB" were added by Vasya.
In the second sample Vasya added a single word "WUB" between all neighbouring words, in the beginning and in the end, except for words "ARE" and "THE" — between them Vasya added two "WUB".
|
```python
s = input()
res = ""
i = 0
while i < len(s):
if i < len(s) - 2 and s[i] == "W" and s[i + 1] == "U" and s[i + 2] == "B":
i += 3
else:
res += s[i]
i += 1
print(res)
```
| 0
|
|
190
|
A
|
Vasya and the Bus
|
PROGRAMMING
| 1,100
|
[
"greedy",
"math"
] | null | null |
One day Vasya heard a story: "In the city of High Bertown a bus number 62 left from the bus station. It had *n* grown-ups and *m* kids..."
The latter events happen to be of no importance to us. Vasya is an accountant and he loves counting money. So he wondered what maximum and minimum sum of money these passengers could have paid for the ride.
The bus fare equals one berland ruble in High Bertown. However, not everything is that easy — no more than one child can ride for free with each grown-up passenger. That means that a grown-up passenger who rides with his *k* (*k*<=><=0) children, pays overall *k* rubles: a ticket for himself and (*k*<=-<=1) tickets for his children. Also, a grown-up can ride without children, in this case he only pays one ruble.
We know that in High Bertown children can't ride in a bus unaccompanied by grown-ups.
Help Vasya count the minimum and the maximum sum in Berland rubles, that all passengers of this bus could have paid in total.
|
The input file consists of a single line containing two space-separated numbers *n* and *m* (0<=≤<=*n*,<=*m*<=≤<=105) — the number of the grown-ups and the number of the children in the bus, correspondingly.
|
If *n* grown-ups and *m* children could have ridden in the bus, then print on a single line two space-separated integers — the minimum and the maximum possible total bus fare, correspondingly.
Otherwise, print "Impossible" (without the quotes).
|
[
"1 2\n",
"0 5\n",
"2 2\n"
] |
[
"2 2",
"Impossible",
"2 3"
] |
In the first sample a grown-up rides with two children and pays two rubles.
In the second sample there are only children in the bus, so the situation is impossible.
In the third sample there are two cases: - Each of the two grown-ups rides with one children and pays one ruble for the tickets. In this case the passengers pay two rubles in total. - One of the grown-ups ride with two children's and pays two rubles, the another one rides alone and pays one ruble for himself. So, they pay three rubles in total.
| 500
|
[
{
"input": "1 2",
"output": "2 2"
},
{
"input": "0 5",
"output": "Impossible"
},
{
"input": "2 2",
"output": "2 3"
},
{
"input": "2 7",
"output": "7 8"
},
{
"input": "4 10",
"output": "10 13"
},
{
"input": "6 0",
"output": "6 6"
},
{
"input": "7 1",
"output": "7 7"
},
{
"input": "0 0",
"output": "0 0"
},
{
"input": "71 24",
"output": "71 94"
},
{
"input": "16 70",
"output": "70 85"
},
{
"input": "0 1",
"output": "Impossible"
},
{
"input": "1 0",
"output": "1 1"
},
{
"input": "1 1",
"output": "1 1"
},
{
"input": "63 82",
"output": "82 144"
},
{
"input": "8 26",
"output": "26 33"
},
{
"input": "21 27",
"output": "27 47"
},
{
"input": "0 38",
"output": "Impossible"
},
{
"input": "46 84",
"output": "84 129"
},
{
"input": "59 96",
"output": "96 154"
},
{
"input": "63028 0",
"output": "63028 63028"
},
{
"input": "9458 0",
"output": "9458 9458"
},
{
"input": "80236 0",
"output": "80236 80236"
},
{
"input": "26666 0",
"output": "26666 26666"
},
{
"input": "59617 0",
"output": "59617 59617"
},
{
"input": "0 6048",
"output": "Impossible"
},
{
"input": "63028 28217",
"output": "63028 91244"
},
{
"input": "9458 39163",
"output": "39163 48620"
},
{
"input": "80236 14868",
"output": "80236 95103"
},
{
"input": "26666 52747",
"output": "52747 79412"
},
{
"input": "59617 28452",
"output": "59617 88068"
},
{
"input": "6048 4158",
"output": "6048 10205"
},
{
"input": "76826 4210",
"output": "76826 81035"
},
{
"input": "23256 15156",
"output": "23256 38411"
},
{
"input": "56207 53035",
"output": "56207 109241"
},
{
"input": "2637 28740",
"output": "28740 31376"
},
{
"input": "73415 4445",
"output": "73415 77859"
},
{
"input": "82019 4498",
"output": "82019 86516"
},
{
"input": "28449 80204",
"output": "80204 108652"
},
{
"input": "99227 53323",
"output": "99227 152549"
},
{
"input": "45657 29028",
"output": "45657 74684"
},
{
"input": "78608 4733",
"output": "78608 83340"
},
{
"input": "25038 4786",
"output": "25038 29823"
},
{
"input": "95816 80492",
"output": "95816 176307"
},
{
"input": "42246 94024",
"output": "94024 136269"
},
{
"input": "0 100000",
"output": "Impossible"
},
{
"input": "100000 0",
"output": "100000 100000"
},
{
"input": "1 100000",
"output": "100000 100000"
},
{
"input": "100000 1",
"output": "100000 100000"
},
{
"input": "63028 63028",
"output": "63028 126055"
},
{
"input": "9458 9458",
"output": "9458 18915"
},
{
"input": "80236 80236",
"output": "80236 160471"
},
{
"input": "26666 26666",
"output": "26666 53331"
},
{
"input": "59617 59617",
"output": "59617 119233"
},
{
"input": "100000 100000",
"output": "100000 199999"
}
] | 1,545,146,495
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 5
| 372
| 819,200
|
import math
import queue
n,m=map(int,input().split())
if n==0:
if m>0:
print("Impossible")
else:
print("0 0")
else:
a=max(n,m)
b=n+m-1
print(a," ",b)
|
Title: Vasya and the Bus
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
One day Vasya heard a story: "In the city of High Bertown a bus number 62 left from the bus station. It had *n* grown-ups and *m* kids..."
The latter events happen to be of no importance to us. Vasya is an accountant and he loves counting money. So he wondered what maximum and minimum sum of money these passengers could have paid for the ride.
The bus fare equals one berland ruble in High Bertown. However, not everything is that easy — no more than one child can ride for free with each grown-up passenger. That means that a grown-up passenger who rides with his *k* (*k*<=><=0) children, pays overall *k* rubles: a ticket for himself and (*k*<=-<=1) tickets for his children. Also, a grown-up can ride without children, in this case he only pays one ruble.
We know that in High Bertown children can't ride in a bus unaccompanied by grown-ups.
Help Vasya count the minimum and the maximum sum in Berland rubles, that all passengers of this bus could have paid in total.
Input Specification:
The input file consists of a single line containing two space-separated numbers *n* and *m* (0<=≤<=*n*,<=*m*<=≤<=105) — the number of the grown-ups and the number of the children in the bus, correspondingly.
Output Specification:
If *n* grown-ups and *m* children could have ridden in the bus, then print on a single line two space-separated integers — the minimum and the maximum possible total bus fare, correspondingly.
Otherwise, print "Impossible" (without the quotes).
Demo Input:
['1 2\n', '0 5\n', '2 2\n']
Demo Output:
['2 2', 'Impossible', '2 3']
Note:
In the first sample a grown-up rides with two children and pays two rubles.
In the second sample there are only children in the bus, so the situation is impossible.
In the third sample there are two cases: - Each of the two grown-ups rides with one children and pays one ruble for the tickets. In this case the passengers pay two rubles in total. - One of the grown-ups ride with two children's and pays two rubles, the another one rides alone and pays one ruble for himself. So, they pay three rubles in total.
|
```python
import math
import queue
n,m=map(int,input().split())
if n==0:
if m>0:
print("Impossible")
else:
print("0 0")
else:
a=max(n,m)
b=n+m-1
print(a," ",b)
```
| 0
|
|
447
|
A
|
DZY Loves Hash
|
PROGRAMMING
| 800
|
[
"implementation"
] | null | null |
DZY has a hash table with *p* buckets, numbered from 0 to *p*<=-<=1. He wants to insert *n* numbers, in the order they are given, into the hash table. For the *i*-th number *x**i*, DZY will put it into the bucket numbered *h*(*x**i*), where *h*(*x*) is the hash function. In this problem we will assume, that *h*(*x*)<==<=*x* *mod* *p*. Operation *a* *mod* *b* denotes taking a remainder after division *a* by *b*.
However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the *i*-th insertion, you should output *i*. If no conflict happens, just output -1.
|
The first line contains two integers, *p* and *n* (2<=≤<=*p*,<=*n*<=≤<=300). Then *n* lines follow. The *i*-th of them contains an integer *x**i* (0<=≤<=*x**i*<=≤<=109).
|
Output a single integer — the answer to the problem.
|
[
"10 5\n0\n21\n53\n41\n53\n",
"5 5\n0\n1\n2\n3\n4\n"
] |
[
"4\n",
"-1\n"
] |
none
| 500
|
[
{
"input": "10 5\n0\n21\n53\n41\n53",
"output": "4"
},
{
"input": "5 5\n0\n1\n2\n3\n4",
"output": "-1"
},
{
"input": "10 6\n811966798\n734823552\n790326404\n929189974\n414343256\n560346537",
"output": "4"
},
{
"input": "2 2\n788371161\n801743052",
"output": "-1"
},
{
"input": "10 6\n812796223\n122860157\n199259103\n597650585\n447742024\n521549402",
"output": "3"
},
{
"input": "300 2\n822454942\n119374431",
"output": "-1"
},
{
"input": "300 2\n823284367\n507345500",
"output": "-1"
},
{
"input": "2 5\n791579811\n35613889\n997079893\n878677665\n693717467",
"output": "2"
},
{
"input": "20 5\n793926268\n28931770\n842870287\n974950617\n859404206",
"output": "-1"
},
{
"input": "100 15\n805069249\n778178198\n633897389\n844316223\n146759898\n870527016\n82668754\n42060733\n943602929\n979451110\n746979598\n47406033\n607284062\n850870259\n229415316",
"output": "5"
},
{
"input": "100 15\n806204335\n189490323\n718805086\n716787474\n262315718\n822030596\n894644222\n724054623\n141384399\n579354205\n192622443\n672556242\n97417563\n243354557\n208957882",
"output": "8"
},
{
"input": "100 15\n807033760\n577461392\n275221433\n532633429\n295714486\n783298996\n255799943\n99107143\n729119412\n59302896\n37640015\n313610861\n630550567\n534283052\n681062462",
"output": "8"
},
{
"input": "100 15\n808103310\n136224397\n360129131\n405104681\n263786657\n734802577\n67808179\n928584682\n926900882\n511722343\n483348395\n938695534\n120684068\n74152694\n808088675",
"output": "9"
},
{
"input": "2 2\n2\n2",
"output": "2"
},
{
"input": "300 2\n0\n300",
"output": "2"
},
{
"input": "2 2\n0\n0",
"output": "2"
}
] | 1,613,316,121
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 307,200
|
p,n = map(int, input() .split())
b = [-1]*n
t = True
m = 0
for i in range(n):
y = int(input())
b[i] = y % p
for j in range(n):
if b.count(b[j]) > 1:
for k in range(n):
if b[k] == b[j]:
m+=1
if m == 2:
print(k+1)
t = False
break
if t == False:
break
if t == True:
print(-1)
|
Title: DZY Loves Hash
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
DZY has a hash table with *p* buckets, numbered from 0 to *p*<=-<=1. He wants to insert *n* numbers, in the order they are given, into the hash table. For the *i*-th number *x**i*, DZY will put it into the bucket numbered *h*(*x**i*), where *h*(*x*) is the hash function. In this problem we will assume, that *h*(*x*)<==<=*x* *mod* *p*. Operation *a* *mod* *b* denotes taking a remainder after division *a* by *b*.
However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the *i*-th insertion, you should output *i*. If no conflict happens, just output -1.
Input Specification:
The first line contains two integers, *p* and *n* (2<=≤<=*p*,<=*n*<=≤<=300). Then *n* lines follow. The *i*-th of them contains an integer *x**i* (0<=≤<=*x**i*<=≤<=109).
Output Specification:
Output a single integer — the answer to the problem.
Demo Input:
['10 5\n0\n21\n53\n41\n53\n', '5 5\n0\n1\n2\n3\n4\n']
Demo Output:
['4\n', '-1\n']
Note:
none
|
```python
p,n = map(int, input() .split())
b = [-1]*n
t = True
m = 0
for i in range(n):
y = int(input())
b[i] = y % p
for j in range(n):
if b.count(b[j]) > 1:
for k in range(n):
if b[k] == b[j]:
m+=1
if m == 2:
print(k+1)
t = False
break
if t == False:
break
if t == True:
print(-1)
```
| 0
|
|
825
|
A
|
Binary Protocol
|
PROGRAMMING
| 1,100
|
[
"implementation"
] | null | null |
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
- Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). - Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
|
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=89) — length of the string *s*.
The second line contains string *s* — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
|
Print the decoded number.
|
[
"3\n111\n",
"9\n110011101\n"
] |
[
"3\n",
"2031\n"
] |
none
| 0
|
[
{
"input": "3\n111",
"output": "3"
},
{
"input": "9\n110011101",
"output": "2031"
},
{
"input": "1\n1",
"output": "1"
},
{
"input": "3\n100",
"output": "100"
},
{
"input": "5\n10001",
"output": "1001"
},
{
"input": "14\n11001100011000",
"output": "202002000"
},
{
"input": "31\n1000011111111100011110111111111",
"output": "100090049"
},
{
"input": "53\n10110111011110111110111111011111110111111110111111111",
"output": "123456789"
},
{
"input": "89\n11111111101111111110111111111011111111101111111110111111111011111111101111111110111111111",
"output": "999999999"
},
{
"input": "10\n1000000000",
"output": "1000000000"
},
{
"input": "2\n10",
"output": "10"
},
{
"input": "4\n1110",
"output": "30"
},
{
"input": "8\n10101010",
"output": "11110"
}
] | 1,509,871,699
| 2,147,483,647
|
Python 3
|
WRONG_ANSWER
|
TESTS
| 3
| 46
| 0
|
from itertools import groupby
noc = int(input())
arlist = [list(g) for k, g in groupby(input())]
out = ""
for i in arlist:
if i[0] == "1":
out += str(len(i))
elif i[0] == "0":
if len(i)>1:
out += "0"*(len(i)-1)
print(out)
|
Title: Binary Protocol
Time Limit: None seconds
Memory Limit: None megabytes
Problem Description:
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
- Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones). - Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input Specification:
The first line contains one integer number *n* (1<=≤<=*n*<=≤<=89) — length of the string *s*.
The second line contains string *s* — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output Specification:
Print the decoded number.
Demo Input:
['3\n111\n', '9\n110011101\n']
Demo Output:
['3\n', '2031\n']
Note:
none
|
```python
from itertools import groupby
noc = int(input())
arlist = [list(g) for k, g in groupby(input())]
out = ""
for i in arlist:
if i[0] == "1":
out += str(len(i))
elif i[0] == "0":
if len(i)>1:
out += "0"*(len(i)-1)
print(out)
```
| 0
|
Subsets and Splits
Successful Python Submissions
Retrieves all records from the train dataset where the verdict is 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Retrieves records of users with a rating of 1600 or higher and a verdict of 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Counts the number of entries with a rating above 2000 and a verdict of 'OK', providing basic filtering but limited analytical value.
SQL Console for MatrixStudio/Codeforces-Python-Submissions
Counts the number of entries with a 'OK' verdict, providing a basic overview of a specific category within the dataset.